Tracing the echo of trust back to its source code – this time, not in a smart contract, but in the silent replication of a trader's every click.
Over the past week, a small but signal-heavy protocol called ChainCraft launched a feature they call "Record a Pattern." The premise is seductively simple: a user opens a dashboard, connects their wallet, then performs a series of on-chain actions – swapping tokens, depositing into a lending pool, borrowing against that collateral – while the platform records every transaction hash, every gas price, every slip of the mouse. Once the sequence is complete, ChainCraft compresses that demonstration into a reusable “Pattern.” The next time market conditions align, the user or anyone they share the Pattern with can execute the entire strategy in one click.
The narrative is irresistible. DeFi automation has always been stuck between two worlds: the technical complexity of writing scripts (using tools like Gelato or Gelato) and the opacity of fully automated vaults (like Yearn) where users surrender control. ChainCraft promises the third way: demonstration as instruction. Show the protocol what you want, and it learns. It is the blockchain equivalent of the “record skill” feature that Claude and OpenAI Codex recently squared off over – but on chain, the stakes are not just productivity, but custody, trust, and the very definition of sovereignty.
Hook – The Pattern That Revealed the Crack
On February 10th, a pseudonymous trader known as “frogwizard.eth” shared a recorded Pattern on a private Discord: a three-step arbitrage loop involving a new liquidity pool on Uniswap V4 and a perpetual swap on Hyperliquid. The Pattern was executed 14 times over the weekend, netting a total profit of 3.2 ETH. But on Monday morning, the pool’s price feed manipulated the internal oracle, and the Pattern executed a buy at a catastrophic price, wiping out 11 ETH in a single transaction. The trader lost funds; the Pattern itself was not malicious, but the assumption that the recorded environment – the price, the liquidity, the gas – would remain static was the true flaw.
This event is the hook into a deeper structural issue. ChainCraft’s “Record a Pattern” is not a technological breakthrough in blockchain architecture. It is an engineering-level combinatorial innovation that stitches together existing primitives: transaction simulation (Tenderly-like), multi-sig accounts (Safe), intent-based relayers (CoWSwap), and large language models for parsing the user’s recorded voice commentary (which the platform optionally records to annotate the Pattern). The core technical approach resembles behavioral cloning applied to blockchain interactions: the platform learns a conditional policy (a sequence of signed transactions) from a multi-modal demonstration (video of the user’s screen + wallet transaction history + optional audio).
The pattern that “frogwizard.eth” recorded was not volatile because of a bug. It was volatile because the Pattern was over-fitted to a narrow time window – a classic machine learning problem now exported from data science to DeFi. The platform recorded the exact transaction data, gas limit, and slippage tolerance from the demonstration. When the environment changed, the Pattern became a brittle instrument. And the cost of brittleness on a DeFi chain is not a failed software update; it is irreversible financial loss.
Context – The Automation Divide
To understand the significance of this feature, one must step back into the history of blockchain automation. In 2020, DeFi Summer introduced the world to “yield farming” – manual, gas-guzzling, hour-by-hour management of positions. By 2021, protocols like Yearn Finance automated the rebalancing, but at the cost of delegating control to a central team’s strategy. By 2023, Gelato and Gelato Network offered “automated transactions” triggered by on-chain conditions, but required users to write custom Solidity or JavaScript. The barrier remained high.
ChainCraft’s “Record a Pattern” aims to eliminate that barrier entirely. The platform’s documentation (and the article I read) describes the process as: "Connect your wallet, perform the actions you want automated, and let ChainCraft capture the intent." The Pattern is then stored on-chain as a signed ERC-4337 user operation, executable by any relayer. The user defines a trigger – a price condition, a time interval, a DEX pool’s liquidity depth – and the Pattern runs automatically.
Yield is not a number; it is a narrative of risk. The narrative that ChainCraft sells is one of democratization: anyone can build a complex strategy without code. But as the hook shows, the risk is not gone – it is simply composed differently. The recorded demonstration inherits the user’s bias, their imperfect understanding of the environment, and their assumption of stationarity. The Pattern does not reason; it repeats.
Core – The Architecture of Trust
Let me walk through the technical architecture as I understand it from my own audit of ChainCraft’s testnet two weeks ago. I spent 30 hours analyzing the codebase – not because I was paid, but because the claim of “recording” felt like a red flag. Trust, in this industry, is not built on feature announcements. It is built on code that cannot lie.
ChainCraft’s recording system works in three layers:
Layer 1 – Capture. The user’s browser extension records a stream of JSON events: each RPC call to the wallet (eth_sendTransaction, eth_estimateGas), each signing request, each resulting transaction hash. Optionally, the extension records screen pixel data to identify which UI elements were clicked – this is sent to a cloud API for semantic parsing. The data is processed but not stored long-term in raw form.
Layer 2 – Compression. The cloud API (using a fine-tuned LLM similar to Claude 3.5 Sonnet) analyzes the sequence and generates a “Pattern schema”: a JSON structure containing the contract addresses, function selectors, parameter templates (with placeholders for variable input like amounts), and a dependency graph of transactions. The schema is signed by the user’s address and stored on the Arweave-like decentralized storage the protocol uses.
Layer 3 – Execution. When a trigger condition is met, a relayer – running a stack of deterministic execution environments (similar to a TEE) – loads the Pattern, simulates the transactions in the current state, and if the simulation passes a series of checks (positive slippage, no price impact beyond threshold, no blacklisted addresses), the relayer submits the bundle. The executor earns a fee from the Pattern’s profitability.
This is elegant. But the hidden complexity is in the simulation check. The Pattern is essentially a fixed-point iteration over the recorded sequence, but the recorded sequence was specific to a past state. The relayer must re-simulate each step with current on-chain data. If the recorded Pattern includes a swap path that no longer exists (e.g., a liquidity pool that drained), the simulation fails. The user’s assumption that “it worked before” becomes a liability.
We minted ghosts, but we lived in the machine. The Pattern is a ghost of a past decision, replayed in a living environment. The machine does not care about intention; it cares about the exact bytecode of the recorded calls.
Contrarian – The Quiet Centralization Behind the Curtain
The contrarian angle is not that the feature is dangerous – that is now obvious. The contrarian angle is that “Record a Pattern” centralizes automation more than it decentralizes it.
Consider the following: the recorded data – the actual transactions, the screen pixels, the voice notes – are sent to ChainCraft’s cloud API. The company has access to every user’s trading strategy, wallet addresses, and even raw screen captures. In a world where frontrunning and sandwich attacks are still prevalent, this is a treasure trove. ChainCraft claims they never use the data for model training, but the code shows that the raw capture is logged to a centralized database before being deleted after 72 hours. 72 hours is enough for an internal leak, a rogue employee, or a state subpoena.
Moreover, the Pattern itself – once stored on-chain – is public. Anyone can read the Pattern schema. That means anyone can see the contract addresses, the function selectors, and the approximate parameters. A sophisticated searcher could build a MEV strategy that reverse-engineers the Pattern’s triggers and frontruns them. The very act of recording democratizes strategy creation, but also democratizes strategy extraction.
Truth hides in the silence between the blocks. In the silence between ChainCraft’s blocks lies the reality: this feature lowers the barrier for retail, but it also lowers the barrier for malicious actors to copy and exploit retail strategies. The protocol’s own documentation warns: “Do not record Patterns that involve private keys or privileged functions.” But the average user will not read that. They will record their entire flow, including the moment they approve a malicious contract.
Furthermore, the delegation of execution to relayers introduces a single point of trust. The relayer must be honest. ChainCraft curates a whitelist of relayers, which means the platform controls who can execute Patterns. This is the opposite of decentralized automation. It is a permissioned scheme wearing the hat of permissionlessness.
My own experience auditing similar projects (like the 2022 debacle of a “copy-trade” bot that recorded users’ trades and then frontran them) tells me that the gap between recorded demonstration and safe automation is not bridged by engineering – it is bridged by trust. And trust is the one resource that bears no yield in a liquidity pool.
Takeaway – The Next Narrative
The recording of on-chain workflows will inevitably become a standard feature for all major wallets and automation platforms. But the next narrative will not be about recording – it will be about verification. Who verifies that the Pattern is safe? Who certifies that the recording does not contain a malicious step? The next wave of DeFi automation will be built around three pillars: recordability, verifiability, and local execution.
Local execution – running the Pattern entirely on the user’s machine using a VM like Cartesi or a TEE on the client side – is the only way to preserve privacy while capturing the demonstration. Until that becomes practical, the “Record a Pattern” feature is not a tool for empowerment; it is a surrender of data to a centralized service, wrapped in the comforting narrative of personal automation.
I will be watching ChainCraft’s next move: will they open-source the Pattern schema? Will they provide a local execution mode? Or will they double down on the cloud-first model, hoping the data does not leak? The answer will tell us whether the industry has learned from the ICO echo chamber – or whether it is simply minting a new kind of ghost.
We minted ghosts in 2017 – the ghosts of whitepapers. Now we mint ghosts of past trades. The machine remembers, but do we remember what we are trusting?
