Clew : Remembering the retry that worked

Tatum × Walrus Memory “Total Recall” hackathon. Live at clew-eight.vercel.app.

A transaction reverts. The wallet says “execution reverted”, maybe with a reason string. Someone tweaks a number, resubmits, and it goes through. A week later the same wallet hits the same contract with the same error and starts from zero, because nothing kept the fix.

If you build agents that send transactions, that loop burns retries and leaves you guessing which change actually landed. Wallet users hit the same wall: they pay gas twice and still walk away without knowing whether a slippage limit or a deadline was the thing that moved. Hackathon judges can check a concrete claim on real Mainnet data: a stored memory changes what you do on the next failure.

Clew watches that loop and stores it.

What Clew does

1. A transaction fails. Clew reads the receipt and decodes why.
2. The same wallet retries the same contract and succeeds. Clew diffs the two attempts and writes what changed to Walrus Memory on Mainnet.
3. The next time that wallet fails on that contract with a similar error, Clew recalls the memory and returns the prior successful transaction plus a concrete next action.

With an empty memory it can only say the transaction reverted. Once a memory exists, it can name which words in the call changed, and point at the retry that landed.

The public website never writes. Both the Try it box and the agent endpoint only read.

If you run an agent that retries failed swaps, send the failed hash to /v1/recall and you get the last path that worked for that wallet and contract.

How Tatum is used

Every chain read goes through Tatum, so a pasted failure is decoded from a live receipt.

On Base, Ethereum and Polygon that means the JSON-RPC gateways:

• eth_getTransactionReceipt for status. Clew treats 0x0 as a failure and only accepts a later 0x1 transaction as the retry.
• eth_getTransactionByHash for calldata, gas limit, gas price, value and nonce. eth_getBlockByNumber for the timestamp.
• Revert decoding via debug_traceTransaction with callTracer, falling back to an eth_call replay at block - 1. Clew decodes Error(string) (0x08c379a0), Panic(uint256) (0x4e487b71) and custom error selectors, then normalizes them into a signature such as revert:too_little_received.
• eth_getBlockReceipts to find the successful retry from the same wallet to the same contract after the failure.

The free plan allows 3 requests a second. Clew spaces its calls about 360 ms apart and backs off on HTTP 429.

Sui uses a different door on the same provider. Tatum’s Sui gateway serves GraphQL only (POST https://sui-mainnet.gateway.tatum.io/graphql). A first attempt at sui_* JSON-RPC came back HTTP 404, so the adapter was rewritten against GraphQL. One transaction query returns the sender, gas budget and price, status, checkpoint, Move calls, Pure inputs, and executionError (the module, function and abort code where it died). That becomes a signature like moveabort:errors::err_amount_out_slippage_check_failed:1. Finding the retry is supposed to take one filtered query: same sender, same package::module, after the failure’s checkpoint.

That GraphQL path was verified on Sui Mainnet on 31 October 2026: the gateway answered at checkpoint 340173364, recent programmable transactions decoded, and two real fail → success pairs were written to Walrus. On 7 November 2026, single-transaction reads still worked and the live /v1/recall endpoint answered two digests with the same structured shape as Base. The list query (transactions) returned “Failed to list transactions” that day, so a new pair could not be discovered then.

How Walrus Memory is used

Memories go to the Walrus Memory Mainnet relayer (https://relayer.memory.walrus.xyz) in namespace clew, through @mysten-incubation/memwal. Later failures from the same wallet can pick up the retry that already worked because that write lives there.

A write is remember(text, { idempotencyKey: "chain:failedTx:successTx" }), then waitForRememberJob until a blob_id comes back. If that confirmation never arrives, the pair is not treated as stored. A read is recall with a query built from the new failure’s chain, contract, wallet, error and selector. Recall is semantic, so Clew then applies a strict filter: exact chain, exact contract, exact wallet, and a similar error. Another wallet’s path is never reused.

The memory text is plain and factual, tags first so both recall and the filter have something to hold on to: