Stop guessing why it reverted. Clew remembers what worked.

The next time the same contract fails with a similar error, Clew surfaces the exact retry that succeeded before (the calldata change, the gas, the nonce) instead of a generic “transaction reverted”.

Try it on a failed transaction View the code

New failureEthereum0x5004…2adeExpired

Without Clew

Tx reverted (revert:expired)
No prior successful path on record. Check params and retry.

With Clew

Retry that worked0x5393…7565successful retry (opens Etherscan)block 26,283,279

reason: Expired (used 33669 of 500000 gas, not out of gas)
re-encode arg 2 → 0x6ae074ee

Recalled from encrypted Walrus blob7YJ-W7r8…jKG4 ↗

Try it

Paste a failed transaction. See what Clew says with and without its memory.

Clew reads the receipt through Tatum, then asks Walrus Memory what this wallet did the last time the same contract failed. Base, Ethereum, Polygon and Sui.

No hash handy? Try a real failure:

Featured: an Ethereum wallet (0xaffa…a793) with no automation signal (65 prior transactions, retried ~48s after failing, 4 calls to this contract in ~8 min). Its retry changed one calldata word, not just gas.

Honest note: most fast fail-and-retry wallets in the current set are bots (13 of the 16 remembered wallets are bot-like by Clew’s heuristic), so these examples show the mechanism, not typical users. Clew only remembers a wallet’s own earlier fix.

Same failure, twice

Without memory, a shrug. With memory, the path that worked.

Ethereumfailed tx 0x5004…2adewallet 0xaffa…a793human-likeExpired

Without memory

Tx 0x5004…2ade on ethereum reverted (revert:expired). No prior successful path on record for this wallet+contract. Check params and retry.

What Clew returns when the namespace is empty. Nothing to act on.

With memory

Prior successful retry0x5393…7565prior successful retry (opens Etherscan)block 26,283,279

Next action

Failure reason: Expired (used 33669 of 500000 gas, not out of gas)
→
Re-encode calldata like the retry
- word 20x6ae074ee0x6ae074b2

Copy includes the full values and the template tx.

Recalled from encrypted Walrus blob7YJ-W7r8…jKG4 ↗

How it works

One loop. Failure, the retry that worked, and the next failure that doesn’t start from zero.

01
Failure
Clew pulls the receipt through Tatum RPC (eth_getTransactionReceipt). Status 0x0 confirms the revert; the reason is decoded from a trace, or an eth_call replay, falling back to the function selector.
Tatum RPCcontract · wallet · error signature
02
Successful retry
When the same wallet lands a successful call to the same contract minutes later, Clew diffs it against the failure: gas used and limit, gas price, nonce, function, each calldata word, and writes that path to Walrus Memory on Mainnet.
Walrus Memory · remembernamespace "clew" · waitForRememberJob
03
Next failure
Same wallet, same contract, similar error: Clew recalls the memory and returns the retry that worked: the specific tx, what changed, and the next action, instead of a dead-end revert message.
Walrus Memory · recallprior success → next action

Tatum is load-bearing. Every receipt, transaction, block and revert reason comes from Tatum gateways: JSON-RPC for Base, Ethereum and Polygon, GraphQL for Sui. No receipt, no memory.

Walrus is load-bearing. The path that worked lives only in Walrus Memory (MemWal, relayer.memory.walrus.xyz). Empty namespace in, generic revert out.

Real example

Real failures, the retries that fixed them, and what recall returned.

Every pair below is a real on-chain failure and the same wallet’s successful retry to the same contract, read through Tatum and written to Walrus Memory on Mainnet. Nothing is seeded or mocked.

Mainnet memories on Walrus

Base 10 · Ethereum 2 · Polygon 2 · Sui 2

distinct contracts, one memory each

repeat failures → prior path recalled

16 memories · pick one

Basecontract 0x29be…9a7bwallet 0x5865…cb93bot-like

Wallet looks bot-like (heuristic): 106,219 prior transactions; 22 calls to this contract in ~5 min (10 failed).

Error

SPL1

signature revert:spln

Transaction: 0x987c…abcefailed transaction (opens Basescan); 0x82d2…8840successful retry (opens Basescan)
Gas used: 33,234; 133,536
Gas limit: 1,218,812; 1,150,576
Nonce: 106,219; 106,220
Function: 0x00000002; 0x00000011
Landed: status 0x0; 5 blocks later

Calldata words changed · 18

arg 00x23909cea00…fa2c4e0x20
arg 10x29011c2d38…0000000x100212f43fd6ec
arg 20x6000000000…0000000x1
+15 more words differ (summarised in the memory)

Without memory

Tx 0x9539b67dbf137f4972cf79c81faa659d80f2d828da7e8822c765678fbedbd7db on base reverted (revert:spln). No prior successful path on record for this wallet+contract. Check params and retry.

Repeat failure 0x9539…d7dbrepeat failure (opens Basescan)

With memory

Prior success0x82d2…8840prior success (opens Basescan)block 53,152,822

Next action

Failure reason: SPL1 (used 33234 of 1218812 gas, not out of gas)
call 0x00000011 instead of 0x00000002

Copy includes the full values and the template tx.

Returned by recall: npm run demo (Mainnet).

Walrus blobMfcU5wMO…aCz4 ↗job 3f25adc2…0c4anamespace clewMemory text

CLEW chain=base contract=0x29be31e7ef434a74d69da1cb6b51ad65c83e9a7b wallet=0x586574504712377b817df6091c75bb7c44cccb93 error=revert:spln selector=0x00000002 failed_tx=0x987c3e003ef5d797cecf170f2e5a2342658ac27608728a404f9ce8c6d127abce success_tx=0x82d2caf493467bf6c3e500237ecd35bc2631d96ca31d056df2709b6d9f458840 success_block=53152822. Contract 0x29be31e7ef434a74d69da1cb6b51ad65c83e9a7b on base failed with error revert:spln (SPL1) for wallet 0x586574504712377b817df6091c75bb7c44cccb93. Successful retry in tx 0x82d2caf493467bf6c3e500237ecd35bc2631d96ca31d056df2709b6d9f458840 at block 53152822, 5 blocks later. Change: gas used was 133536 vs 33234 on failure; gas limit 1150576 vs 1218812; nonce 106219 -> 106220; function 0x00000002 -> 0x00000011; calldata 18 arg word(s) changed (arg 0 0x23909cea00…fa2c4e -> 0x20, arg 1 0x29011c2d38…000000 -> 0x100212f43fd6ec, arg 2 0x6000000000…000000 -> 0x1). NEXT_ACTION: call 0x00000011 instead of 0x00000002; template tx 0x82d2caf493467bf6c3e500237ecd35bc2631d96ca31d056df2709b6d9f458840

Written Tue, 27 Oct 2026 10:08:17 UTC · job 3f25adc2-31d0-464b-9903-e998db9c0c4a. Shown from Clew’s local ledger: the blob on Walrus is SEAL-encrypted, so Walruscan confirms it exists but cannot display this text.

Honest note: most wallets that fail and retry within minutes are bots. By Clew’s heuristic, 13 of these 16 wallets are bot-like (huge nonce counts, retries within seconds, dozens of calls to one contract in a few minutes), 2 shows no automation signal, and 1 on Sui is unclassified because Sui has no account nonce to check, so “what changed” is often a fresh quote rather than a human fix. Each wallet tag lists its reasons. Clew shows a gas hint only when the failed attempt actually ran out of gas; otherwise it shows the revert reason. Clew records what actually differed and lets you decide.

The next revert should come with directions.

Run the recall on a real Base failure in under two minutes. Same contract, similar error, and Clew hands back the path that worked.

Get the code

Or sign in (optional)

Run it locally

$ git clone https://github.com/levithefirst/clew$ cd clew && npm install$ cp .env.example .env# MEMWAL_KEY, MEMWAL_ACCOUNT_ID, TATUM_API_KEY$ npm run check -- ethereum \0x5004b20f2851805165a8f7b8ffab993185820680e3a5278f26acc0c9a0a22ade

Stop guessing why it reverted. Clew remembers what worked.

Paste a failed transaction. See what Clew says with and without its memory.

Without memory, a shrug. With memory, the path that worked.

One loop. Failure, the retry that worked, and the next failure that doesn’t start from zero.

Failure

Successful retry

Next failure

Real failures, the retries that fixed them, and what recall returned.

The next revert should come with directions.