DEV Community: TxDesk

Your Support Team Shouldn't Need to Read a Block Explorer

TxDesk — Mon, 04 May 2026 14:27:48 +0000

It's 3am UTC. Someone in your Discord pastes a transaction hash and the message: "did i just get drained??"

What happens next is mechanical. A moderator opens the block explorer, scrolls past gas limits and method calls and log topics, decodes the transfer, translates 0xa9059cbb into "this was an ERC20 transfer," cross-references the destination address, then types something like "looks like you swapped on Uniswap, here's the route." The user replies with a follow-up. Maybe the same flow runs five more times.

That same conversation will run two hundred times in this channel tonight. The moderator wasn't hired for forensics. The protocol didn't budget for it either.

The notification gap

The Drift exploit on April 1 ran for about twelve minutes. 31 withdrawal transactions, $285M out the door, and the protocol's first X post telling users to halt deposits arrived after on-chain analytics firms had already flagged the active attack. Wasabi on April 30 followed the same shape: the attacker started draining at 07:48 UTC, kept going for roughly two hours, and the official acknowledgment showed up afterward. Users watching the price action on their phones knew something was wrong before the team confirmed it.

This isn't anyone's fault. The sequence has to be: detect, pause, investigate, post. Posting first risks broadcasting an exploit before the contract is safe. Pausing first protects the funds. Communication is last because it has to be.

But during that gap, the people who deposited into the protocol have no answer to the question they care about most: is my position safe right now. They get told to "monitor official channels," and the official channel is silent.

The "am I affected?" flood

April 18, Kelp DAO: a forged LayerZero message drained 116,500 rsETH, about $292M. Within hours, nine downstream protocols had paused something. Aave froze rsETH and WETH markets. Around $8.45B fled Aave's pools in the next forty-eight hours. The Aave forum's incident report counted 119 borrower positions at liquidation risk after the dust settled.

Each of those protocols got the same wave. Discord channels filled with the same five questions: am I affected, do I need to do anything, where is my money, can I withdraw, what should I revoke. Same questions, hundreds of times, in parallel across nine protocols. Each answer requires looking at the user's specific position. The volunteer mod can't batch them.

Revoke.cash maintains a permanent page at revoke.cash/exploits called "Check If You're Affected." It exists because every exploit produces this exact flood, and someone built a static site as the least-bad triage tool. The existence of that page is the evidence.

The revoke.cash gap

After Wasabi, the official guidance was to revoke approvals at revoke.cash. Within hours, a phishing account named "Wascbi Profocol" posted a fake revoke link in the same threads where users were asking what to do. Per Blockzeit's coverage, it "apparently misled several people."

Read what the official advice actually asks of a user. Identify which contracts you've approved. Recognize the real protocol's account from the impostor. Open a tool you've probably never used. Sign a transaction whose effects you can't preview. Do all of this fast, while panicking, while scammers are setting up imitation links.

The revoke.cash advice is correct. It's also incomplete in a way that matters. Users following the safety procedure got drained again because the procedure assumed knowledge they didn't have, on the day they could least afford a wrong click.

The layer nobody built

Protocols have monitoring. Hypernative, Blockaid, Cyvers all detected the recent exploits within seconds. Protocols have docs, audit reports, X accounts, status pages, Discord. What's missing isn't information. It's translation.

A monitoring alert says "rsETH/WETH market frozen." A user wants to know "is my $40K still there, what is the worst case for me, and what do I need to do in the next ten minutes."

These are not the same artifact. One is protocol-shaped. The other is position-shaped. The translation between them is what Discord moderators have been doing manually, one user at a time, with a block explorer open in another tab.

Morpho moved its public Discord to read-only on February 1, 2026. Co-founder Merlin Egalite, on record: "Discord is actually full of scammers. people would get phished while actually searching for answers despite heavy monitoring, safeguards, etc." DefiLlama is migrating off Discord too. The volunteer-mod-with-block-explorer model is being abandoned by the protocols that originally built it.

What the workflow looks like instead

The piece I've been building is the translation layer. TxDesk (txdesk.io) takes one input, an address or a transaction hash, plus a question in plain English. It runs the lookups a moderator would run, against the user's actual on-chain state, and returns the answer in seconds.

A user pastes a tx hash and asks "what happened?" The agent decodes the transaction, returns status, parties, amounts, fees, and the decoded method call, in a paragraph a non-technical user can read.

A user asks "will I get liquidated if ETH drops 20%?" The agent calls explain_liquidation_risk against their lending position. It returns currentHealthFactor, distanceToLiquidationPercent, and an array of perAssetLiquidationPrices with one row per collateral asset. Plus suggestions: requiredDebtRepaymentUsd to hit a target health factor, or requiredCollateralAddUsd to add instead. The user gets a number, not a vibe.

A user pastes a Sui package ID and asks "is this safe?" The package risk tool returns riskLevel, isLatestVersion (false flags deprecated versions, the pattern that bit Scallop), and upgradeCapOwnerKind (AddressOwner with an upgradeable policy is the single-key blast-radius pattern that bit Volo). A full Cetus CLMM scan returns end-to-end in 1.7 seconds.

A user pastes a failed transaction. The diagnosis tool returns one of eight Sui failure categories, with two or three suggested fixes computed from the user's wallet state.

Every field is tagged dataAvailable: full | partial | unavailable, so the agent can't invent values that didn't load. 39 tools, 43+ chains.

Every exploit in April produced the same support failure. Different attack vector each time, same broken communication on the user side. The fix isn't more moderators, faster Discord triage, or better Twitter posts. It's an answer that runs in seconds, in plain English, against the user's actual on-chain position, available the moment the user asks. That layer didn't exist. Now it does.

Three Sui Exploits in One Week. So I Built 5 Security Tools to Catch Them.

TxDesk — Thu, 30 Apr 2026 13:21:02 +0000

In nine days, three Sui DeFi protocols got hit. Volo lost $3.5M on April 21. Scallop lost $142K on April 26. Aftermath Finance lost $1.14M USDC on April 29.

Three different protocols, three different attack patterns, one shared root cause: nobody had a way to check the structural risk before signing.

The three patterns

Scallop: Sui packages don't disappear when you upgrade them. They get superseded — but the old version stays callable on chain forever. Scallop's V2 staking-rewards package from November 2023 sat dormant for 17 months until someone found an uninitialized last_index counter and claimed rewards from a synthetic position that "existed since the spool launched." The frontend pointed at the new version. The on-chain remnants didn't care.

Volo: Not a smart-contract bug. The contracts were audited. The single keypair holding upgrade authority over three vaults got compromised. $3.5M gone in one signing session. The audit didn't matter because the audit assumed the key was safe.

Aftermath Finance: A public entry function called add_integrator_config had no authorization check. The attacker set max_taker_fee to 0. A signedness bug then interpreted that as negative. They got paid to trade. Eleven transactions, 36 minutes, $1.14M.

Three patterns: deprecated code still callable, single-key admin, missing auth on a public entry. None of them are detectable by reading dApp UIs. All three are detectable from RPC data.

The five tools

I built five Sui-specific security tools for TxDesk, the AI support layer for crypto products I've been working on. Each tool is a single TypeScript service, fully tested, plugged into the agent's tool registry.

assess_sui_package_risk. Detects deprecated package versions by walking the UpgradeCap chain — the original Scallop pattern. Classifies cap ownership (single-key vs Shared multisig vs Immutable) — the original Volo precondition. Counts public entry functions that don't take a Cap parameter — a heuristic for the AftermathFi pattern. The interesting bit: my original plan called for three discovery paths to find the UpgradeCap. Smoke testing against mainnet revealed Sui's 0x2::package module emits no Move events at all, so the event-based path was structurally impossible. Deleted it. The remaining publish-tx scan does all the work, faster.

diagnose_failed_sui_transaction. Classifies eight failure categories — INSUFFICIENT_GAS, MOVE_ABORT_SLIPPAGE, MOVE_ABORT_AUTH, MOVE_ABORT_GENERIC, OBJECT_VERSION_CONFLICT, SHARED_OBJECT_CONGESTION, INVALID_GAS_OBJECT, TYPE_ARGUMENT_ERROR — with plain-English suggestions per category. The interesting bit: I tightened the slippage heuristic during planning. The original idea was to guess slippage from module name alone (any abort in a pool module = probably slippage). That's wrong. Many functions in pool modules aren't swaps. Now slippage requires BOTH the module name to match (pool|swap|amm|dex|router) AND the function name to match (swap|trade|exchange|exact_(in|out)|exec). If the function name isn't resolvable from the abort error string, classification falls back to MOVE_ABORT_GENERIC. False negatives over false positives.

inspect_sui_object. Single-RPC tool that returns object type, ownership kind (one of AddressOwner / ObjectOwner / Shared / Immutable), version, and decoded content. For Coin<T> objects, a parallel suix_getCoinMetadata(T) call decodes the balance with proper decimals. The interesting bit: when the metadata fetch fails, we surface the raw balance string and decimals: null rather than defaulting to the SUI decimals. Showing "1,500,000,000 (raw, decimals unavailable)" is honest. Showing "1.5 SUI" when we don't know the actual decimals would be a guess.

check_sui_coin_metadata. Answers "is this token legit, and who can mint it?" Validates the coin type structure (also accepts the wrapped form 0x2::coin::Coin<...>), fetches metadata and total supply, locates the TreasuryCap<T> and inspects its current owner. The interesting bit: I introduced an RpcOutcome<T> discriminated union here — { ok: true; value: T | null } | { ok: false }. The reason is subtle. For metadata, a null result from suix_getCoinMetadata means "definitively no metadata published" (a scam signal). A network error means "we don't know yet." The original safeRpcCall helper flattened both to plain null, which would have falsely flagged real coins as scams during transient RPC outages. The discriminated union forces the call site to distinguish.

check_sui_account_risk. SUI balance, owned-object inventory, UpgradeCap inventory, recent transaction count. Flags addresses holding upgrade authority over five or more packages as CRITICAL — the Volo blast-radius pattern. The interesting bit: a 30-second total operation timeout wraps the entire pipeline. Whales with thousands of owned objects could otherwise drag the agent. If the deadline fires mid-pagination, the report returns with coverageComplete: false, which forces riskLevel: 'UNKNOWN'. We never fabricate a "looks fine" answer from a partial scan.

The mainnet smoke test

I picked Cetus CLMM as the target. It's a well-known Sui DEX, handles real daily volume, and the team is reputable. The package ID came from the Cetus contracts Move.toml on GitHub: 0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb.

The agent classified the intent as security_concern, routed correctly to assess_sui_package_risk (not assess_contract_risk — the EVM version), and returned CRITICAL in 1.7 seconds (post-cleanup). Two findings:

isLatestVersion: false. The package was superseded by 0x25ebb9a7…dfee5e3. Calling the old version is the Scallop pattern, live in production on a real protocol.
upgradeCapOwnerKind: 'AddressOwner'. A single keypair (0xdbfd…4a47) controls upgrades. The Volo precondition.

That's not a hand-picked test fixture. That's the product working on a real Sui DEX on day one.

The never-lie principle

The default engineering reflex when an API call fails is to return false. It compiles. It type-checks. It doesn't crash. And it's a lie.

"API failed" and "the answer is no" are different statements. Defaulting to false collapses them and propagates a wrong answer with full confidence.

Every Sui tool I built uses nullable booleans for every signal that could fail: isPackage: boolean | null, isLatestVersion: boolean | null, treasuryCapStatus: SuiTreasuryCapStatus | null. Each report includes a dataAvailable: 'full' | 'partial' | 'unavailable' flag. Only 'full' reports are cached. Partial reports are returned to the user but never written to Redis, so the next call retries.

Concrete example. If we can't find the UpgradeCap for a package — the publish tx got pruned, the RPC timed out, whatever — we don't say there's no cap. We say upgradeCapId: null, upgradeCapOwnerKind: null. Those are different statements. The first would imply an immutable package. The second admits we don't know.

The cost: users sometimes see "we couldn't determine X." The benefit: when we DO say something, it's worth trusting.

What mainnet smoke testing taught me

I wrote all five tools, wrote 87 tests, all green. Then I ran four curl commands against the actual Sui mainnet RPC. Three findings:

The SuiVision verification URL I'd put into the package-risk service (api.suivision.xyz/v1/packages/...) didn't resolve. DNS error. The endpoint I'd assumed existed never did.
The Move event filter for UpgradeCap discovery (MoveEventType: '0x2::package::PublishEvent') returned empty 200 responses. Broadening to the entire 0x2::package module returned zero events from any source. Sui packages don't emit Move events for publish — at all.
The CurrencyCreated event filter for TreasuryCap discovery DID return events, but the event type is generic (CurrencyCreated<T>) so a non-parameterized filter never matches, and the event's parsedJson only contains {decimals} — not the cap ID I'd assumed.

All three findings led to deletion, not workarounds. SuiVision call: deleted entirely. Path A in package-risk: deleted (Sui literally cannot provide what I was asking for). Path A in coin-metadata: replaced with a publish-tx scan that piggybacks on a sui_getObject call already happening, costing one additional RPC instead of three.

Tool execution dropped 46%. Code got smaller. The result is more honest. The lesson: never write a code path that depends on an API behavior you haven't verified — and when smoke testing reveals that path is dead, delete it. Don't leave it as a "best-effort fallback" that's actually a no-op.

Numbers

5 new services: 2,893 lines
5 test files: 2,080 lines
87 new tests, 1,097 across the codebase
37 tools total in TxDesk now (up from 32)
One evening session, planning through commit 54b2b40
Smoke test caught real CRITICAL issues on Cetus CLMM on day one

Closing

If you're building on Sui or using Sui DeFi protocols, these tools are live at txdesk.io. And if you're a protocol team dealing with fifty identical "am I affected?" messages after every exploit — that's the problem TxDesk solves.

What's the largest project you or any programmer you know has completed entirely with AI assistance?

TxDesk — Tue, 28 Apr 2026 10:49:45 +0000

I'm 18 and I built a Layer 1 blockchain from scratch in Rust

TxDesk — Mon, 27 Apr 2026 13:40:40 +0000

The project

NOVAI is a Layer 1 blockchain where AI entities are protocol primitives, not smart contracts. Most "AI blockchains" bolt AI onto an existing VM through oracle calls or contract wrappers. NOVAI does it differently. AI entities exist at the same level as accounts and validators. They have on-chain identity, persistent memory, economic balance, and capability flags. All enforced at the protocol layer.

There is no smart contract VM. No WASM runtime. Every transaction type is a native protocol operation.

The entire codebase is clean-room. No code from Substrate, Tendermint, Cosmos SDK, or any other implementation. 65,000+ lines of Rust across 16 crates, 1,100+ tests, zero unsafe code.

GitHub: github.com/0x-devc/NOVAI-node
Website: novai.network

What makes NOVAI different

On most blockchains, "AI integration" means an off-chain model that pokes the chain through oracle calls or contract wrappers. The AI runs somewhere else. The chain just stores the result.

NOVAI puts AI entities inside the protocol. An entity is a first-class on-chain identity that:

Holds its own balance and pays its own fees
Has its own Ed25519 signing key and signs its own transactions
Publishes signal commitments (anomaly, prediction, risk-score, and 4 more types)
Owns persistent memory objects (chain summaries, statistics snapshots, anomaly logs)
Has governance-controlled autonomy modes and capability flags

The chain doesn't need to interpret bytecode to understand what an entity is doing. Every operation has known semantics at the protocol layer.

What shipped this week

Open source launch

The full codebase went public under Apache 2.0. Git history was cleaned. CI is green on GitHub Actions.

Developer docs - 5 deliverables

1. Quick Start Tutorial - "Build Your First AI Entity on NOVAI in 10 Minutes"

Step-by-step CLI walkthrough. Generate keys, fund from faucet, register an AI entity with its own signing key, publish a signal, create a memory object, query everything back. Every command and output block is real captured data from a live 4-node devnet.

Read it on GitHub

2. TypeScript SDK Tutorial

170-line working example. Connect to a node, fund an account, transfer tokens, register an AI entity, verify it on chain. Self-contained npm project. Just run npm install && npm start.

See the example

3. Rust SDK Tutorial

Same flow in idiomatic async Rust on tokio. Single file, runs with cargo run --example quick-start.

See the example

4. RPC Reference

777 lines covering all 13 JSON-RPC endpoints. Each one has a description, parameter table, response shape, error table, and a real curl command with captured output.

Read it on GitHub

5. Architecture Deep Dive

Crate-by-crate walkthrough of all 16 crates organized by dependency layer. Mermaid diagrams for the consensus flow and the transaction lifecycle. Three guided reading paths for newcomers.

Read it on GitHub

Block explorer

React + Vite + Tailwind single-page app that calls the node's RPC endpoints. Live block list with 2-second polling, block detail page, account lookup, AI entity page with memory objects and signals, and a network stats dashboard. Developers run it locally against their devnet.

AI entity demos

Three runnable demos showing the AI-entity-as-protocol-primitive pattern.

Anomaly bot - A TypeScript bot that registers itself as an on-chain entity, polls chain activity every 1.5 seconds, runs three heuristic detectors (empty block streaks, round spikes, stalled chains), and publishes an anomaly signal plus a memory object whenever one fires. Cooldowns prevent re-firing on the same condition.

Multi-entity demo - Two bots interacting purely through the chain. Bot A (predictor) publishes prediction signals guessing future block tx counts. Bot B (risk-scorer) reads those predictions via on-chain memory objects, waits for the target block, compares predicted vs actual, and publishes a risk-score signal with the delta. No shared database. No API calls between them. Just on-chain data.

CLI demo script - Full entity lifecycle in bash with banner sections for blog posts or video recordings. Keygen, faucet, register, credit, signal publish, memory CRUD, query.

The bug fix that unblocked everything

While building the tutorials I found that entity-signed signal and memory transactions were silently failing through the RPC path. The root cause was four handlers using the wrong lookup key. They did a primary-key lookup with an address value instead of using the reverse index that maps address to entity ID. The entity record was never found so every signal and memory transaction quietly returned an error that got swallowed.

The fix was refactoring all four handlers into inner functions that take a pre-resolved entity. Added 7 regression tests that exercise the full dispatch path. Verified end-to-end on a live devnet.

I wrote about a similar silent-failure bug in my first blog post: The Bug That Silently Broke My Entire Blockchain

The numbers

65,000+ lines of Rust
16 crates in the workspace
1,100+ tests passing
30M+ blocks committed on the private testnet
Zero unsafe code
10 native transaction types
4-validator private testnet running since early 2026
HotStuff BFT consensus with 3-chain commit rule
Sparse Merkle Tree state with deterministic 32-byte roots
Ed25519 signatures, Blake3 hashing, Noise XX transport encryption
Apache 2.0 licensed

What's next

Public testnet. The private testnet runs on a shared VPS that causes state root divergence under sustained load. The fix is a dedicated CPU server. Once that's in place we'll have a public RPC with SSL, validator onboarding, and the block explorer deployed at explorer.novai.network.

I'm also looking for a technical co-founder. I'm building this solo. If you're a Rust engineer interested in BFT consensus, on-chain AI primitives, or clean-room blockchain development, the codebase is open and PRs are welcome.

Website: novai.network
GitHub: github.com/0x-devc/NOVAI-node
Twitter: @NOVAInetwork

I'm 18, I built an AI support agent for DeFi protocols with 77K lines of code, and I have zero customers

TxDesk — Sun, 26 Apr 2026 16:26:27 +0000

I'm Victor, 18 years old, solo founder. I've spent the last several months building TxDesk, an AI-powered support widget that DeFi protocols can embed on their sites. Users paste a transaction hash or wallet address, and the agent decodes it into plain English.
What it actually does
The agent pulls live on-chain data across 46 blockchains (21 EVM chains + Solana + Bitcoin + TRON + XRP + 20 more). It can:

Decode any transaction and explain what happened in plain language
Scan token approvals and flag risky unlimited allowances
Check wallet balances across any supported chain
Diagnose why a transaction failed
Track cross-chain bridge transfers
Assess smart contract risk
Verify wallet ownership via WalletConnect (Sign-In With Ethereum / Solana)

It deploys as an embeddable website widget (one script tag), a Discord bot, or a Telegram bot.
The stack

TypeScript monorepo (api + widget + website + shared package)
Preact for the widget (needs to be tiny, it loads on other people's sites)
Rollup for bundling the widget into a single JS file
OpenAI function calling for the AI agent layer
RocksDB-backed caching for chain data
30+ tool functions the AI can call depending on the question
WalletConnect v2 for wallet verification
Stripe for billing
Hetzner VPS, Nginx, Docker

How I built it
I don't write code from scratch. I use Claude Code (Anthropic's CLI coding tool) to build everything. I describe what I want, review the output, debug issues, and make architectural decisions. The AI writes the code, I steer the product.
This sounds like it shouldn't work for a production system. But here's what the repo looks like after months of this workflow:

~77,000 lines of TypeScript
~1,700 tests passing
Zero clippy-equivalent warnings
Multi-tenant SaaS with auth, billing, rate limiting, and role-based access
Full CI pipeline

The key to making AI-assisted coding work at scale is decision documentation. I run 2-3 Claude Code terminals in parallel. Each terminal has no memory of what the others decided. So I write markdown docs that capture every architectural decision and load them into each session. Without that, the AI will happily undo work from another session.
The problem nobody tells you about
Building the product was the easy part. Distribution is where I'm stuck.
Here's what I've tried:

80+ cold DMs to protocol founders on Twitter, zero replies
40+ cold emails, zero replies
Daily Twitter posting, engagement but zero inbound leads
Discord community presence, got auto-muted for spam when I posted about TxDesk
Posting in protocol Discords, most block new members from posting links

The product works. I can demo it right now at txdesk.io. But nobody knows it exists, and cold outreach from an unknown 18-year-old solo founder looks identical to the 50 other pitches a protocol team gets every week.
What I'm doing differently now
I've stopped cold outreach entirely. New strategy:

Targeting crypto community management agencies instead of protocols directly. One agency manages 10-50 client communities, so one sale means multiple deployments.
Being helpful in protocol Discords without mentioning TxDesk. Answering on-chain questions manually to build reputation first.
Twitter engagement on trending crypto security events. Replying with smart analysis on exploit threads. One reply got 1,764 views from 13 followers because I was adding genuine insight, not promoting.
In-person events. Attending Ethereum London meetups. A 5-minute laptop demo beats 100 DMs.
Applying to CV Labs Accelerator in Zug. I grew up there, it's my home turf.

What I've learned so far

Nobody cares about your feature list. "46 chains and 30 tools" means nothing to a buyer. "Your moderators won't need to open Etherscan anymore" means everything.
Cold outreach doesn't work when you have zero brand. You need to be known before you pitch.
Building with AI tools is a legitimate superpower for shipping speed. But shipping speed doesn't matter if nobody uses what you ship.
The hardest transition is going from full-time builder (12 hours of coding) to full-time seller (2 hours of outreach and then waiting). The waiting feels like you're not working. You are.

If you're in a similar spot, zero customers, great product, no distribution, I'd genuinely love to hear what's working for you. And if you're building in the DeFi space and want to try TxDesk, the demo is live at txdesk.io.