<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Abu Olumi</title>
        <link>https://paragraph.com/@olumi</link>
        <description>Weekly research and content covering Web3 protocols, DeFi ecosystems, and on-chain activity. Currently running active series on Dango.exchange and Jumper × LiFi — breaking down mechanics, updates, and ecosystem developments for builders, traders, and curious minds. 

By Abu Olumi · olumi.xyz</description>
        <lastBuildDate>Thu, 19 Nov 2026 12:23:32 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <image>
            <title>Abu Olumi</title>
            <url>https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/c0f0582a50c80382e3840a242efff57fa9648476c34b5a78a79906cf59b1ea78.jpg</url>
            <link>https://paragraph.com/@olumi</link>
        </image>
        <copyright>All rights reserved</copyright>
        <item>
            <title><![CDATA[LI.FI Composer: One Transaction
for Every DeFi Action]]></title>
            <link>https://paragraph.com/@olumi/lifi-composer-one-transaction-for-every-defi-action</link>
            <guid>bpMKZ72R0WlCOGDwtAkb</guid>
            <pubDate>Thu, 09 Jul 2026 12:13:26 GMT</pubDate>
            <content:encoded><![CDATA[<p>The standard cross-chain DeFi workflow is inefficient by design. Depositing 500 USDC from Arbitrum into an Aave vault on Ethereum requires at minimum: bridge the USDC, approve the token on arrival, swap if needed, approve the vault contract, deposit. Five separate transactions. Five separate gas payments. Five points of failure where the sequence can break and leave you holding an intermediate asset.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Composer launched February 17, 2026 as a direct solution to this problem. It is a transaction orchestration primitive that bundles any sequence of DeFi actions into a single self-custodial transaction.</p><h3 id="h-what-composer-actually-is" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>What Composer Actually Is</strong></h3><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Composer is a transaction orchestration primitive that introduces a native way for developers to compose multi-step, multi-chain DeFi workflows and execute them as a single transaction. In practice, swaps, bridging, deposits, staking, and other actions can be combined into a single transaction that executes end-to-end user flows in one go.</p><p>The user signs once. The Composer executes the entire sequence automatically. No manual handoffs between steps. No stuck intermediate states.</p><h3 id="h-the-two-component-architecture" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Two-Component Architecture</strong></h3><p>The core innovation behind Composer lies in its two-component architecture. An on-chain execution engine acts as a smart contract that can call other on-chain protocols in sequence, while an intent translation layer converts high-level user goals into optimal execution paths.</p><p>This is a meaningful architectural departure from traditional smart contracts. Most blockchain transactions execute and complete within a single block. Orchestration platforms enable multi-block execution and can maintain state across different stages of complex workflows, waiting for conditions to be met before proceeding to subsequent steps.</p><h3 id="h-dynamic-calldata-injection" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Dynamic Calldata Injection</strong></h3><p>Dynamic calldata injection represents another technical advantage. Composer automatically passes outputs from one operation into the next without requiring users to predict exact amounts. If a swap yields 0.5 ETH, that precise amount flows into the next step without manual intervention or failed transactions due to incorrect estimates. This is what makes complex multi-step flows reliable rather than brittle.</p><p><em>Pre-execution simulation provides certainty about outcomes before committing funds. Users can verify the complete execution path will succeed, preventing the common scenario where step three of a five-step process fails after earlier steps have already completed and locked funds in intermediate states.</em></p><h3 id="h-deposit-as-a-native-primitive" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Deposit as a Native Primitive</strong></h3><p>For the first time, deposits are a first-class transaction type, treated like swaps or bridging. Users can move assets into any deposit contract in a single transaction, from anywhere. By turning deposits into a native, composable primitive, <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Deposit unlocks entirely new possibilities: developers can build user-friendly products for modern finance, and users can onboard and deploy capital with one click, into any market, anywhere in DeFi.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Deposit is already live on Jumper Earn, the yield aggregation product built on top of Jumper Exchange.</p><h3 id="h-real-use-cases" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Real Use Cases</strong></h3><p>The product unlocks use cases including one-click cross-chain vault deposits, seamless liquidity migrations, bridge-and-stake flows, and automation-driven DeFi products. For builders, this means DeFi workflows that previously required custom multi-step contract logic can now be composed directly using the Composer API without rebuilding the execution layer.</p><h3 id="h-the-gas-efficiency-argument" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Gas Efficiency Argument</strong></h3><p>Bundling actions into one transaction reduces cumulative gas costs compared to executing each step separately. For smaller positions, the cumulative gas cost of five separate transactions can make a cross-chain DeFi flow economically unviable. Composer removes that constraint by consolidating the gas overhead into a single payment.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/e41ac68956dffdb1d9001f5b764e910b38ddb7f20874c8138206d90e2daa0b27.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA8AAAAgCAIAAABCTrX+AAAACXBIWXMAAAsTAAALEwEAmpwYAAAE90lEQVR4nHXO6W8UZRzA8eeV+h+IUV4J2AaB0qJU2moIhxFCYwuVpogEE0h8pSmxh6nGN4CAyuVbDbSgJIRAmgYpCgZaeiyUbctuZ7tn3dm5Z35zPMdcuzum8Nrk8+r76otWvt6ytnbXOw0fr639aOOG3StXtiD05v8aujR64/o/1/64N3T5z2tX710ZGj370+9nTg6eOTl46vjg6RODp45fOn3i8ouCsFG29aou+Qtzwny8FIsVns0LaU55+rTIcSrHKTPxIuihzyKGIyQ8WRQnE6UY9++DePHJYikHfM5IJvSJxOJEIjWe4B4+S2YLuixioWQhZlhMkZiq+bruAUS+S4H+et1UHUfEvEJU23cMZpKQ2YwiogIRRCoqVFYDiwQWccEReKbYkDcKPIhFEGRbtT0KmCCmARVFpmoeQJnQMqG+iRWR6tgqQFHCCjDL8mwcMpNSRHWTiRJTNF+HwMEhIR44ssB0bJdMQXZUhWi2S3DATEKen5RKRBA9gBDTEFPPxLLAFAfyUBBAFG1ZJqrp2hZhiOgOlVUiKVTRfJsEhDIgIk81xyqBKJqSRg2LYew//4YFHuZyVloyuZKVlixOMPMG6NWCZKRFOStqWVHLCGpeMiSFoLnp7OT9RGwsNT2Wio0vTo+lpsfTkxPZyYns1OSyyYlMbDr/OJafnxVQ1+Hv65sPNe344r1tRxtaDjftONq49UjT9qNbth3ZsvVQ4wcHm7d9vmFz52urdrbuPYZ2tX25uq61rrGjpqFt9frW+qb9tQ1tDU2d6xs71m1uX7OxtaahbcWq7eiVundbDqLe/l/2dfXs/7S/vbOn8+A3HQd6Ow707uvq29fV1/XZQPsnPXvau9s7e/fs7e7uuYgUMVSkSBYjXYl0dZkilTW1YkD4XFmHUNHcZaqL0lkznlAzeSjykC/ouSXdglBUrFiOS/KFnCALum5RCgQbFkX5gp7JyaIEJUEXJEjnJUx82/KeJZdEycjnJUUxbZthzMKgikwVLFXGAB7GPiE+IdSyQGcghiCHoAWghrYROhDaEKJiLs/Nx3KZTDLBlXieOGboE9Dxwpy4kOA5jk9xpUxaLPsRc0KkacwAhkmASeBg33a8IKg6ji+ppkOYgxnzfEzcSqXiuWWE7ZDR0KVl36t4XiXwqr5bAYMpEgGDgRFgJ6SkTJzAhgAV87RYoIpEZZHoChMlLKmOBaEFoa66mgi6BIbGLCMA1UNLSwaX4otLci4nuG6Y5AoPp+KSbIRh2fNCgZeymXwmw1Pq+l4FgcGw5TLHY8SvlKuSYBeyuiRYLin7bsWGQFeYBcyxPEZClM2yVGYZl14mCa4qB7LK0oqSFKUFQRIVrGpUNZisUBSPW+Pj2gtPZiyOcxY5nEipY/Hs2ExuYjafTKupnLGQUdM5A2UzLpcgqeSyXMYVSlWBry4JLJ2BhZTBLQKXhkKJlFRWkim6/zd34/rU8K3Hwzdnbo/M3rk9e2dkdmRk6ubwo5u3Hg3fnrpzN3b3r8cjo1MPxhJoU/2HCL284tX1tWuaat5qXlvT0rRl96b6nQ31O96ufb+2prlmTfMbr9Uh9NKGdTvRxfNXu786MdB37tv+871f/3jh7JVrV0cv/zY8eOnWxXNXBvrOfTdwob/n555jP5w/O4SoEzE7ok6EnYjYEYZIVyqaVLYhAr3qQPSCSyJqRv8Bx1plhCaNYVAAAAAASUVORK5CYII=" nextheight="3052" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Next week: Jumper chain coverage — 60+ networks, Solana, Sui, HyperEVM, and how Jumper handles the full multi-VM landscape.</em></p><br>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/f266cabcf29bf4d380ad5a63c20ef8163032424b0057e31ec51f87c103e52148.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Salvage: recovering what the EVM left behind]]></title>
            <link>https://paragraph.com/@olumi/salvage-recovering-what-the-evm-left-behind</link>
            <guid>3F1SgAFTK5mCkN1jhiLx</guid>
            <pubDate>Sat, 04 Jul 2026 17:33:40 GMT</pubDate>
            <description><![CDATA[The problem nobody built for Every month, billions of dollars in ERC-20 transfers move across Ethereum and Base. A fraction of them go wrong in the same quiet way: someone pastes a token's contract address into the recipient field instead of a wallet. The transfer succeeds. The tokens land inside a contract that has no idea they exist and no function to spend them. They're not burned, not lost to a bad key — they're just stuck, sitting at an address that will never move them. This happens con...]]></description>
            <content:encoded><![CDATA[<p><strong>The problem nobody built for</strong></p><p>Every month, billions of dollars in ERC-20 transfers move across Ethereum and Base. A fraction of them go wrong in the same quiet way: someone pastes a token's contract address into the recipient field instead of a wallet. The transfer succeeds. The tokens land inside a contract that has no idea they exist and no function to spend them. They're not burned, not lost to a bad key — they're just stuck, sitting at an address that will never move them.</p><p>This happens constantly, and the amounts are not small. The USDC contract on Ethereum alone holds over $220,000 in tokens people accidentally sent to it — USDT, WBTC, DAI, and a long tail of others. You can verify that yourself on Etherscan. Multiply that across every major token contract and you're looking at a systemic pool of value that everyone knows exists and nobody has built a standard way to recover.</p><p>I found this pattern the way auditors find most things: by reading contracts closely. While reviewing protocols, I kept noticing token contracts full of other people's tokens. Once you see it, you can't unsee it. Salvage is what I built in response.</p><p><strong>What Salvage does</strong></p><p>Salvage works in three movements: scan, triage, settle.</p><p><strong>Scan.</strong> Paste any ERC-20 contract, and Salvage sweeps every token balance it holds — paginated discovery so nothing hides past the first page, with a guaranteed pass over major tokens so USDT-scale balances can never be missed. It prices everything, filters spam, and shows you the real stranded value. Or paste your own wallet, and Salvage reads your transfer history to find tokens you sent directly to a contract by mistake — verified on-chain by decoding the actual transaction calldata, so normal DeFi activity never produces false positives.</p><p><strong>Triage.</strong> Finding stranded tokens is easy. Knowing whether they can come back is the hard part, and it's where an auditor's eye matters. For each contract Salvage asks: Is the source verified? Does the ABI expose a rescue function — rescueERC20() and its many cousins? Is it an upgradeable proxy where a rescue path could be added? Is there an owner or role that can actually act? The output is a verdict — Recoverable, Needs Action, or Unrecoverable — plus a ready-to-send outreach message for the contract's team.</p><p><strong>Settle.</strong> This is the part I care about most, and the part most people wouldn't bother to build correctly.</p><p><strong>The settlement problem</strong></p><p>Here's the trap. Once you've found recoverable tokens and reached the contract owner, how does recovery actually happen without anyone trusting anyone? The owner has to send funds somewhere. The victim wants their money. A finder who brokered the deal wants their cut. And none of these parties have any reason to trust the others.</p><p>The wrong answer is a custodial escrow — you'd be asking people to route their funds through a middleman, which is exactly the shape of every recovery scam in crypto. The right answer is a settlement contract that holds no discretionary power over anyone's money.</p><p>Salvage's SalvageRecoveryRouter is that contract. It's ~270 lines of Solidity, non-upgradeable, with no external dependencies and no delegatecall. Here's how it works:</p><p><strong>Per-claim deposit addresses.</strong> When a victim registers a recovery, the router assigns that claim its own deterministic CREATE2 receiver address. The owner rescues tokens to that specific address — never into a shared pool. This eliminates an entire class of bugs: claims can't be confused, funds can't be misattributed, and there's no communal pot to drain.</p><p><strong>Victim-signed claims.</strong> A claim is authorized by the victim's EIP-712 signature, binding the token, victim, finder, loss transaction, and a deadline. Anyone can submit the claim (it's relayer-friendly), but the signature freezes every economic parameter, so submission can't alter the outcome. Signatures are replay-proof across chains and reject malleability per EIP-2.</p><p><strong>Permissionless, front-run-safe settlement.</strong> Once tokens land at a claim's receiver, anyone can call settle(). It sweeps the receiver and splits the funds by a schedule frozen at registration. This is the design decision I'm proudest of: front-running settlement is harmless by construction. A bot that front-runs your settle() call doesn't steal anything — it just pays your gas. The payout addresses and splits were fixed when the claim was created; the caller has zero influence over where money goes. Most MEV defenses try to prevent front-running. This one makes it pointless.</p><p><strong>No admin access to funds.</strong> The router's owner can change exactly one thing: where future protocol fees are sent, via two-step ownership. No admin function can touch a claim's receiver or redirect a victim's funds — even a fully compromised owner key cannot reach anyone's money. The code you read is the code that runs, forever.</p><p>The fee schedule is enforced on-chain, frozen per claim: 95% victim / 5% protocol when someone recovers their own tokens, or 90% victim / 7% finder / 3% protocol when a finder brokered it. Balance-delta accounting means even fee-on-transfer tokens split correctly, and settlement is residual-safe — if more tokens arrive at a receiver later, settle() can run again.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/50d7b06b7e95d93a0963df71957ed2183245b82c6d759075676fceae868d19c5.png" blurdataurl="data:image/png;base64,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" nextheight="1260" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p><em>The full recovery flow: scan → claim → deposit → settle, with both fee paths.</em></p><p><strong>Proof, not promises</strong></p><p>I didn't want to publish another protocol that claims to work. So I ran a complete recovery on Base mainnet, and every step is independently verifiable:</p><ol><li><p>The loss — 1 DAI sent directly to the cbBTC token contract<br>basescan.org/tx/0x7da304788c1fd9b2f02e8a313ea9c0881e5d34d28cbdc9943b367139535ca4c1</p></li><li><p>Claim registered — victim signed an EIP-712 claim; router assigned the deposit address<br>basescan.org/tx/0xd20241abf6f4bdddd91dbd72190a9a5037cd92920689e677a7a0265118601ae9</p></li><li><p>Receiver funded — DAI rescued into the claim's deposit address<br>basescan.org/tx/0x4654e00d88dff48ab91b7a4b9388e75e5d61fc8121b82bd6ab889acb702b1531</p></li><li><p>Settlement — permissionless settle(), exact 95/5 split in one transaction<br>basescan.org/tx/0x7c6ba90f73bec7accf15ec8f92bbf92fbd0e509685d5aa819ca26aca7c05b51b</p></li></ol><p>The routers are deployed and verified on Etherscan, Basescan, Blockscout, and Sourcify — on Ethereum (0xD9A5f1Fcf39F99152d6443132B21C1D8f7fAAC25) and Base (0x2240792d1A9D964d238bD693fCb09586B10faEdf). The full test suite passes 10/10, covering both fee paths, deterministic receiver prediction, residual settlement, forged and expired and duplicate signatures, fee-on-transfer math, and ownership transfer.</p><p><strong>One honest limitation</strong></p><p>Salvage cannot force recovery. It never will be able to. Recovery always requires the contract owner to act — to call their rescue function and send the tokens. No tool can compel that. What Salvage guarantees is narrower and, I'd argue, more valuable: when an owner acts, the settlement is trustless, auditable, and non-custodial. Nobody ever holds anyone else's money.</p><p>This matters especially because "recovery" is a word scammers have poisoned. If anyone ever DMs you promising guaranteed fund recovery for an upfront fee, it's fraud — that exact pattern is what this protocol was built to make obsolete. Salvage never asks you to sign a transaction from a DM, never custodies your funds, and shows you every parameter and the raw calldata before you sign anything.</p><p><strong>Where this goes</strong></p><p>Right now Salvage is a scanner and a settlement router with a reference web app. But the interesting version is Salvage as infrastructure: wallets that warn you before you send tokens to a contract, explorer badges marking which contracts are recoverable, support portals for protocol teams drowning in "I sent tokens to your contract" tickets, and an SDK so any app can offer recovery natively. The goal is to make stranded-token recovery as standardized and trustless as token transfers themselves.</p><p>A single frontend is the beginning, not the ceiling.</p><hr><p><em>Try it: </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://usesalvage.xyz"><em>usesalvage.xyz</em></a><em> · Code: github.com/2TheMoom/Salvage · Follow: @Salvage_xy</em>z</p><p><strong><em>Built by Abu Olumi — builder, security researcher, on-chain contributor.</em></strong></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/3b29118975e19b3b10c938309068583a869b27bc2340dfa626c162b53f6bdc3c.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Jumper vs. The Competition:
A Real Comparison of Cross-Chain Aggregators]]></title>
            <link>https://paragraph.com/@olumi/jumper-vs-the-competition-a-real-comparison-of-cross-chain-aggregators</link>
            <guid>bPClapZGDR5Wes8624MN</guid>
            <pubDate>Thu, 02 Jul 2026 00:17:00 GMT</pubDate>
            <description><![CDATA[Before comparing, get the categories right. Stargate and Across are bridges. Jumper, Socket, and Squid are aggregators. Different layers, different jobs. Here is how the aggregators actually stack up. One of the most common confusions in cross-chain DeFi is treating bridges and aggregators as if they are the same category. They are not. A bridge is the underlying protocol that moves assets between chains — Stargate, Across, Hop, Connext, Relay, CCTP. An aggregator is the routing layer that si...]]></description>
            <content:encoded><![CDATA[<p><em>Before comparing, get the categories right. Stargate and Across are bridges. Jumper, Socket, and Squid are aggregators. Different layers, different jobs. Here is how the aggregators actually stack up.</em></p><p>One of the most common confusions in cross-chain DeFi is treating bridges and aggregators as if they are the same category. They are not. A bridge is the underlying protocol that moves assets between chains — Stargate, Across, Hop, Connext, Relay, CCTP. An aggregator is the routing layer that sits on top of bridges and picks the best one for your specific transfer — Jumper, Socket/Bungee, Squid, Rango.</p><p>Comparing Jumper to Stargate is like comparing a travel booking site to an airline. The booking site queries all airlines and picks the best route. The airline is one of the options it queries. The right question for a user is which aggregator to use, not which bridge.</p><h3 id="h-the-aggregator-landscape-in-2026" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Aggregator Landscape in 2026</strong></h3><p>The four aggregators worth understanding are <strong>Jumper</strong> (built on <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>), <strong>Socket/Bungee</strong>, <strong>Squid</strong> (built on Axelar), and <strong>Rango</strong>. Each has a structural advantage in a specific context, and none is universally best across all routes.</p><h3 id="h-where-jumper-wins-evm-to-evm" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Where Jumper Wins: EVM-to-EVM</strong></h3><p>On standard EVM transfers, Jumper consistently wins on price and speed. A March 2026 benchmark on a $1,000 USDC Ethereum-to-Arbitrum transfer shows Jumper at $0.94 via Across in 22 seconds, versus Squid at $1.20 via Stargate-Axelar in 42 seconds. The reason is structural: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> integrates Across</strong>, the cheapest L2 bridge for stablecoin movement between rollups. Squid does not route through Across directly. More bridge integrations means more route combinations, and more combinations means a higher probability of finding the cheapest path.</p><h3 id="h-where-squid-wins-cosmos-routes" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Where Squid Wins: Cosmos Routes</strong></h3><p>Squid is built on Axelar's General Message Passing, which gives it native access to Cosmos IBC routes that Jumper cannot serve. On an Ethereum-to-Cosmos Hub transfer, Squid quotes $1.40 in 90 seconds via a native IBC route. Jumper quotes $2.80 in 110 seconds — because it falls back to routing through Squid as an underlying provider, effectively double-layering the fees. For Cosmos transfers, Squid is the right tool. Cosmos represents roughly 6% of total bridge volume in early 2026.</p><p><em>There is no single best aggregator. There is a best aggregator for each route. For EVM transfers, use Jumper. For Cosmos, use Squid. For exotic non-EVM chains, use Rango. For custom routing logic, use Socket.</em></p><h3 id="h-socket-vs-jumper-a-different-kind-of-competitor" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Socket vs Jumper: A Different Kind of Competitor</strong></h3><p>Socket is the infrastructure behind Bungee Exchange — the same relationship <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> has with Jumper. One is the protocol, one is the consumer app. The key technical difference is that Socket returns raw route metadata to integrators, allowing them to implement their own routing logic on top of the bridge aggregation layer. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> selects the optimal route internally and returns the result. Socket is the better choice for developers who want to build custom cross-chain routing products. Jumper is the better choice for users who want the decision made for them.</p><h3 id="h-rango-widest-coverage-stacked-fees" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Rango: Widest Coverage, Stacked Fees</strong></h3><p>Rango operates as an aggregator-of-aggregators — it queries <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>, Socket, Squid, Symbiosis, and others simultaneously. This gives it the widest non-EVM coverage: Cosmos, NEAR, and native Bitcoin swaps via THORChain. The trade-off is fee stacking. Rango's layer on top of <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s layer can push effective fees to 0.35-0.40% on EVM routes where a direct Jumper route would cost less. For pure EVM and Solana work, Rango is structurally more expensive than going directly via Jumper.</p><h3 id="h-the-lifi-intents-edge" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The </strong><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Intents Edge</strong></h3><p>With the launch of <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents in May 2026, Jumper now routes compatible transfers through the OIF solver network, which competes fills down to basis-point spreads. No other consumer-facing aggregator has this baked in today. Jumper users on compatible routes get intent-based pricing without switching tools or interfaces. This is a structural advantage that compounds as more solvers join the OIF network.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/3c589ffbbee16dba90fdf62f67dac8d415df63564ffa7b2890117fcc11157a40.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAgCAIAAAB7KQSlAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEzElEQVR4nEWV+W8UNxTHHVSUVmnJQoEQkqiIHJCjh0ohIBJBf6zUvxQpipYeKqQhaaEClRLIwWazmz0y586M7ZmxZzxje47Km0Ckr55mnufj9/zGfga6CQ1Lqef6jhf2XP9YtnNqj/3Hn+kmBLoJbQfbDv7n1c5fL7bWN1//vvby6ca/L17urG389+zvrafrr9Y3X796vdtzsGkjw+ozmgk1AzZa1vsDvdYw6odKzbZZbxqNltU4NPabWqNt6qanmZ6KY1iw1kTbNXe3jlsaNW0KnQTbAtuJ73Efp23kdMNe2+/tu5qGXNNCoB/Oa7UM0/KKspRS6l2nXtOaDb3dMTgXHcva2a93dCsvcy6lcczgkEFEUi7KsuRchmHkYT8IIymlEBKTCKKQRqzsz3jChDQOScS5KIoiSTkhSUgiQpOyLI4ZSpNMFmWhZlSMbkJNw90u7HaRbYWmiXUL61Zg2L5mBrrp6z2oO67uuEc9JVU3y8FWk7nthDEZEcGYeN8gWzXy4k2g2XEcyy27uY/1iLFIJAGLP+RGkoCkMRNRxBkTAUmQzwLCCU1pxFEQQcyiSMpMJlx8qIEfW14YkAT7TCmMXEhJlKraYBaEzEORF0QHrmlj37KxYpAfu5AGhEGoMBQyB5KeF+80AhclQRi5iOKQ6QjaGJ8wAWEuJAFhqB8npImL1GvPU3xIEsej/fjM8Yl5zPiYQYeRIA2DlISJC5lmUYhVYtjnPd/XoItIBCmBhJzsg5iKJMwFy5M4kyILqYBY+jT3aZ6kBRWJJ4JQxKGMYp4qpqu7v/7xfGV1vVrdqD7eXFl9tlJ9tvrL5urjjZXq+qPVtZXqnyvVtZXq2qPVJ789ed7VXfBut1WZuA8G5sHZeQBm+rrRt9Pg7E0wOAvAZF9TAEycn7i3t98Bb3cOx6Yfjlxfqowvgs9ugqFZcGEejH53prIwNvXgyuSy8gzNDXz5NRhZGJv5cXuvDd7tHl6ZXP6k8s3Q6A9gaB4MzoHBuYHhBTA0/+nIrcHL358ZXgBnZwfU0I3RqYd7tTZ4u928Mrl8+dr9ketLYGBG5VCZA5cWwODs+PTDsakHA1/MK+elBXDuxqVrS9vv22Cv1pn59qfhq7cr44vDE3cqY4sXr90fnV6+MHG3Mn7386t3zo3dPj9x7+L1peGvFmdv/VyrH6lzWm/1OrqrGV7jwNFMr6O7b3bMnX3n4Mg4ODIMC7da9a5mdXU1qvabYSEa8TwvirwUaVGWZVGU6s/wIpUcpYE6ainOEpyJSAje36MWIjRhTEiRMSIzmeV5wXleliWT3GN+kskswYKhsiy4EB/jpHGfIZ5kQZYXRcxkWZRUxGbkyayQaSgVU3IhTxnGRCYL4mZxmKkTnmRlWaZSyEyWZZlJVhQqbXHKUMXkeR4hmYRqaT4RMZNcypgnMs8zEUkRF0VxypAo5VythEKZUhXHQ5zGORMpZkFeqNxSameSCZGd5pYkmcrNkxTKTBZJqmogMsmkKmUhWSaPe9UJA12PeJB4mLoOdXoEImo7ynooNCGCiECIIYTYjzAmqu987Pa6BTXDa3bcdtc5PHLaXaOjOe2u12g7Hd3TLaQZnmZ4Jz3esJBhoX4TRmb/4cT2PWrS/n2jf7hL/ge/OCTsndkbTwAAAABJRU5ErkJggg==" nextheight="1183" nextwidth="615" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Next week: </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><em>LI.FI</em></a><em> Composer — how bridge + swap + stake + deposit works atomically in one transaction, and why that matters for DeFi builders.</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/8de8f2a392a5c6b7fec36cf0cb32474e35776b477894af23c7c0ab959f29f0d9.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Week 4 on Arc — what the data reveals, and what we shipped to make the intelligence layer trustless]]></title>
            <link>https://paragraph.com/@olumi/week-4-on-arc-—-what-the-data-reveals-and-what-we-shipped-to-make-the-intelligence-layer-trustless</link>
            <guid>kAEpY11jmFBJROYIkpkX</guid>
            <pubDate>Sat, 20 Jun 2026 08:54:39 GMT</pubDate>
            <description><![CDATA[By Abu Olumi — Edition 3 of Building on Arc Six weeks ago, ArcSense launched on Arc Testnet with a simple premise: scan every block in real time, detect failing transactions, and sell that intelligence through a gated API. An autonomous agent would be the first customer. Every payment would be on-chain. Every decision would be logged. The numbers since then: 400,000+ blocks scanned, $500+ USDC spent autonomously by the agent, a peak failure rate of 8.9%, and three full data resets from Railwa...]]></description>
            <content:encoded><![CDATA[<p><em>By Abu Olumi — Edition 3 of Building on Arc</em></p><hr><p>Six weeks ago, ArcSense launched on Arc Testnet with a simple premise: scan every block in real time, detect failing transactions, and sell that intelligence through a gated API. An autonomous agent would be the first customer. Every payment would be on-chain. Every decision would be logged.</p><p>The numbers since then: 400,000+ blocks scanned, $500+ USDC spent autonomously by the agent, a peak failure rate of 8.9%, and three full data resets from Railway redeploys. The numbers that matter are in the data. This edition covers what Week 4 revealed, why the weekly report still didn't surface on the dashboard, and what the biggest infrastructure upgrade since launch means for the intelligence layer.</p><hr><p><strong>What Week 4 actually looked like</strong></p><p>Week 4 ran from June 5 to June 12. The engine processed 180,730 blocks and 2,857,988 transactions, detecting 122,175 failures at an average failure rate of 4.29%. The health score landed at 76 out of 100 — MODERATE territory, not degraded, but not healthy either. 29,364 blocks crossed the 10% warning threshold and 11,997 crossed the 15% critical threshold. The worst single block in the week was #45622530, which recorded a 100% failure rate — every transaction in it failed.</p><p>The average failure rate of 4.29% is a reasonable number on its own. It suggests a network under some stress but not in freefall. The number that changes the interpretation entirely is this: one contract accounted for 88,920 of the 122,175 total failures that week. That is 73% of every failed transaction on Arc Testnet traced back to a single address — <code>0xC5567a5E3370d4DBfB0540025078e283e36A363d</code>. It appeared across hundreds of blocks, was the top entry in ArcSense's contract intelligence panel every single day of the week, and was classified as a HIGH FREQUENCY FAILER from day one of the period. The remaining four contracts in the top five combined for approximately 13,700 failures — a fraction of what that one address produced.</p><p>This is exactly the kind of signal ArcSense is designed to surface. An average failure rate of 4.29% sounds manageable. A single contract responsible for nearly three quarters of all failures on the network is a fundamentally different story. The intelligence layer exists to tell the difference.</p><hr><p><strong>The weekly report saga, continued</strong></p><p>This is the third time the weekly report has come up in these editions, and the third time it has failed to reach the dashboard.</p><p>The first failure was on May 29 — the endpoint to serve the report didn't exist yet. The file was generated, saved to Railway's ephemeral filesystem, and sat there with no route to expose it.</p><p>The second failure was the redeploy after the endpoint fix was pushed. Railway wiped the filesystem. The file was gone before anyone could read it.</p><p>The third failure, on June 19, was a timing issue. The regex fix that would correctly distinguish the dated weekly report file from the raw snapshot accumulator (<code>weekly-store.json</code>) was pushed as part of the full rebrand. That push triggered a Railway redeploy. The weekly report had generated at 07:16 UTC — but the redeploy wiped the filesystem before the fixed endpoint was live long enough to serve it.</p><p>The pattern here is not that the report generator is broken. It has worked correctly every time. The pattern is that ephemeral infrastructure and manual deployments are an unreliable combination when you're trying to preserve time-sensitive output. The file generates. The deployment resets the environment. The file disappears.</p><p>The fix is in place. The regex now correctly filters for dated report files only. The next weekly report generates June 26. That one will surface correctly — the endpoint is stable, Railway's watchPatterns are scoped to <code>src/**</code> so dashboard-only pushes won't trigger redeployment, and the timing has been deliberately managed. Edition 4 will cover what the first successfully surfaced weekly intelligence report actually shows.</p><hr><p><strong>The rebrand</strong></p><p>ArcSense got a full visual overhaul this week.</p><p>The logo mark is now a gateway shape — two converging chrome strokes forming an open-apex "A," with a diamond core nested inside. The shape borrows directly from Arc's own brand language: a futuristic "A" representing a gateway to financial infrastructure. The chrome finish sits cleanly on Arc's real four-stop gradient (<code>#021A49</code> to <code>#5CAFB8</code>) without competing with it. The two green pulse dots — one at the apex, one at the diamond core — carry forward the only element from the original mark that was irreplaceable: the signal that something is live and watching.</p><p>The top bar now carries Arc's actual gradient instead of a flat ink-black background. The wordmark shifted from all-caps Barlow Condensed to title-case Space Grotesk — "ArcSense" rather than "ARCSENSE" — partly to give it a distinct visual identity from the rest of the portfolio, and partly because Space Grotesk pairs with JetBrains Mono in a way that Barlow Condensed doesn't. The line chart was replaced by a Network Pulse gauge — a radial dial showing the current failure rate plus a 15-block heat strip that color-codes each block by severity. The contract intelligence panel was expanded into a proper table with classification, block count, and failure count columns. At the size the panel now occupies, there's room to actually read what it contains.</p><p>None of this changes what ArcSense does. It changes whether ArcSense looks like it belongs in the ecosystem it's built on.</p><hr><p><strong>ArcSenseGate — the payment layer is now trustless</strong></p><p>The most significant change in this edition is not visible on the dashboard.</p><p>ArcSenseGate is now deployed on Arc Testnet at <code>0xd0aEAD5b90eD18bBe830cDA38789B60F4abbab4D</code>. It is an on-chain payment gate contract. When a developer or agent wants to purchase intelligence from ArcSense, they no longer send USDC directly to a service wallet and wait for off-chain verification. They call the contract.</p><p>The old flow required three steps after payment: copy the transaction hash, call <code>POST /api/intelligence/confirm/:queryId</code> with the wallet and hash, wait for Blockscout to confirm the transfer. The delay between payment and credit could be several seconds at best, longer if Blockscout was indexing slowly.</p><p>The new flow requires one step: call <code>purchaseNative(queryType)</code> on the contract with 0.1 USDC as the native value, or call <code>purchaseERC20(queryType)</code> after approving the contract for the ERC-20 interface. The contract emits a <code>QueryPurchased</code> event. The ArcSense engine listens for that event on-chain and credits the caller's wallet automatically. No hash. No confirmation endpoint. No polling.</p><p>The contract handles the free tier as well. The first five queries per wallet are free — tracked on-chain in the <code>freeQueriesUsed</code> mapping. Free query calls to the contract cost no USDC. The contract emits a <code>FreeQueryUsed</code> event. The engine credits the wallet the same way. The credit model is identical whether the query is free or paid — the contract enforces it.</p><p>Both the autonomous agent and external developers use the same contract. The agent calls <code>purchaseNative()</code> via Circle's contract execution API, using the same agent wallet it has always used. External developers call it from MetaMask, Rabby, or any EVM wallet on Arc. The intelligence they receive is identical. The contract they interact with is the same. There is no special agent bypass, no privileged path, no difference in treatment. The on-chain record of every paid query is public and verifiable on Arc Explorer by anyone.</p><p>The owner of the contract is <code>0x1d6038A425059545996eB14E34cFb8A3b7791Ec5</code>. Pricing can be updated via <code>setPrice()</code>. USDC can be withdrawn via <code>withdrawNative()</code> and <code>withdrawERC20()</code>. The contract accepts both native USDC (Arc's gas token, 18 decimals) and the ERC-20 USDC interface at <code>0x3600000000000000000000000000000000000000</code> (6 decimals). For a testnet context, manual price updates are sufficient. Mainnet deployment would integrate a Chainlink oracle.</p><hr><p><strong>Six weeks of data</strong></p><p>The cumulative picture across six weeks of operation is worth stating plainly.</p><p>400,000+ blocks scanned on Arc Testnet. $500+ USDC spent autonomously by an agent that was never manually instructed to make a single payment. A peak failure rate of 8.9%. Three data resets from deployment cycles. Three weekly reports generated and not surfaced. One contract responsible for nearly three quarters of all network failures in a single week.</p><p>The system has been running, failing, recovering, and producing real data the entire time. The infrastructure that exists today — on-chain payment gate, stable endpoint, scoped Railway watchPatterns, corrected weekly report filter — is materially better than what existed at launch. The data keeps accumulating and the next weekly report will be the first one to reach the dashboard end-to-end.</p><p>That is what Edition 4 will cover.</p><p>Dashboard: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://arcsense-lite.vercel.app">arcsense-lite.vercel.app</a> Contract: 0xd0aEAD5b90eD18bBe830cDA38789B60F4abbab4D GitHub: github.com/2TheMoom/arcsense-lite</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/bce585dbc49e8f2cf2c3018f9d22fe975dd1b1adc25432fe4f01a7abf1ad1cfa.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAXCAIAAADlZ9q2AAAACXBIWXMAAAsTAAALEwEAmpwYAAAD70lEQVR4nMWUTWsbRxjH99yjFIMLBl8CvtUFg12LwEK+g06+5ztYlz31nqtubdNCEQFjN01qO2FFFctra6VdSfs2u6td7fv7myXLrUUyRZLT2JWa0ELT3+nPzDPzn+d5ZgZBPgY6BfnvWMvnl5eX7937LJ/PLy0t5XK5/JRcLre2tvYvN71/H1lZ+WdLVhDk87+bgxBDEEQF3dDXk8iKPM2xeo6puE4vjswoNCxLmobBd/ET0Yos/sLnL7x2ZHUThwr63cgUhgGb2ieBiiAINt32/QLXVUfD8LdR3Fd4gaN6MiOBThbbEMIssecNpKtkDCG4io8NrmrLxyZf91UDjow3AzIzbsffoKoqAGcse8IwlCC0zs9/VZQuTVcF4ZxhzuYNDh2Z8IyfZO6lLf5IHD0D1AuNxXX5LNJwVV1UIhWEvplElmv39D5QFc7UxTiyotDy3f78iSqVCoTwLXwLISw/KeMMDqcwECJ/OftspWGIg8RJQlMCHUVmRdCWBNoxJQiv49C8bYBPBZ3YrdAgg37D185thXTVZqA3vD4VmoS3qEQ4jnMczfNtXeYkqU28rkaORpJ1hqFEsTVfIvfq6hLC9sBvZi43iqmB17xw25eBO74ysus7BjOlaVIaWZ6l6Jo4KZHMmrroWL00sgJPW3CLQo2/8F470lNA7oPGntj4jjklvD4/8Oo6WGDgKCCNbVuXWKYBBFrgKZZpKBID4e+Rv6AHt9nZ2cGwj712hqkAUPNSTwMdoUM+f37gOKomdjmOrtVqU4P37Z1kEGhcYjOZwWRe01S6kcZmFp/ZbGbhDr8gA9cQktDQ+oJrK5YGdJV37Z6pi6Gv+e60RDh+Oz4Zj8cQnqYGmblk5hKp3cxcahjEcGxk2QIDXe9FvsYypMBRPEPyXItnm22aGA2CKLhzK2bi3HFqtvRC6hxpwiFPHfCtI4U91tgzR+mkd3p2A0mSOgCAovhmk6aJ/f1vhsMhVa+bkhTwk5Q/wKNHRQx79zHMM7NSVTYKzMlFclStLxh9wdTFNLTi6ch8BkpCWRes7DXVgJZcUrDP5IDU466Zcl21uuAvsjU5jYxB6vRAt0sTPEex3abvaaNhGLrKvEF4Cd7AsKn+QuuvBK9OyM9OpQPBO4mvVTEkFpQIw7BKpVIqlXZ3dzEMe/z4awzDSqVSuVwmSXJBxh5+Cg4Pat/+XP/+6cvyq9beQe2HveoTWq3qeh35H4BwksQMeBcURbe3v3j4cGtrawtFNx48+HJ7e7tYLEIIZ1/ejJmuVCofavjq6ur6+vrm5ubGFBS90Si6PhuZanRjY6NY/KpQKPw5WygUUHQdRVc/aVU+BX8AfqqUrNt0cB0AAAAASUVORK5CYII=" nextheight="1040" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Edition 4 — Saturday July 4, 2026: "The first weekly report that actually surfaced — what the data shows"</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/1fd4bf79daafcfbca6f5d202a1f807be57052cb90220cad761947bfdad254bb3.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Solvers, Intents, and the OIF:
How LI.FI Rebuilt Cross-Chain Execution]]></title>
            <link>https://paragraph.com/@olumi/solvers-intents-and-the-oif-how-lifi-rebuilt-cross-chain-execution</link>
            <guid>Kd7ztC7iDBZphyDtRr8Y</guid>
            <pubDate>Thu, 18 Jun 2026 11:26:16 GMT</pubDate>
            <description><![CDATA[Most cross-chain infrastructure still asks users to think like routers. Pick a bridge. Approve a token. Execute a swap on arrival. If anything fails, retry manually. The complexity that belongs at the infrastructure layer sits squarely on the user. Intent-based execution is the architectural answer to this. And LI.FI Intents, launched May 26, 2026, is the most significant implementation of it in production today. What an Intent Actually Is An intent is a signed statement of the outcome you wa...]]></description>
            <content:encoded><![CDATA[<p>Most cross-chain infrastructure still asks users to think like routers. Pick a bridge. Approve a token. Execute a swap on arrival. If anything fails, retry manually. The complexity that belongs at the infrastructure layer sits squarely on the user.</p><p>Intent-based execution is the architectural answer to this. And <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents, launched May 26, 2026, is the most significant implementation of it in production today.</p><h3 id="h-what-an-intent-actually-is" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>What an Intent Actually Is</strong></h3><p>An intent is a signed statement of the outcome you want — not a sequence of transactions you want executed. The classic example: "Send 1,000 USDC from Arbitrum to Base. Minimum 999 USDC out." You do not specify the bridge, the DEX, the route, or the number of hops. You describe the result. The execution is delegated to a network of professional solvers who compete to fill it.</p><p>This is the same intent pattern used by Across, CoW Protocol, UniswapX, and Anoma. What makes <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s implementation distinct is the packaging: <strong>a hosted, modular execution engine</strong> that integrators can wire into existing wallet flows without rebuilding their entire stack.</p><h3 id="h-how-solvers-work" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>How Solvers Work</strong></h3><p>When you submit an intent through <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents, your funds lock in a Compact contract — a secure escrow. The intent is broadcast to a network of professional solvers who bid to fill the order. The winning solver fronts their own capital on the destination chain, delivering the assets to you immediately. The solver is then reimbursed from the escrow once settlement is confirmed on-chain.</p><p><em>The security model is escrow-based, not trust-based. You never need to trust an individual solver. If they fail to deliver, the escrow protects your funds. An intent engine's failure mode is a refund, not a stuck transaction.</em></p><h3 id="h-why-competition-changes-the-economics" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Why Competition Changes the Economics</strong></h3><p>Traditional bridges charge a fixed fee on every transfer. Intent-based systems run a continuous auction. Solvers compete down to a thin spread — often denominated in basis points rather than fixed dollar fees. The more solvers in the network, the tighter the spread.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> starts with a structural advantage here: <strong>1,000+ enterprise integrations</strong> generating orderflow from day one. Solvers who integrate <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents immediately tap into one of the largest orderflow sources in the ecosystem. That attracts more solvers, which tightens prices for every user.</p><h3 id="h-lifi-intents-and-the-open-intents-framework" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Intents and the Open Intents Framework</strong></h3><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents is built on the reference contracts of the <strong>Open Intents Framework (OIF)</strong> — a public-good initiative led by the Ethereum Foundation, with contributions from OpenZeppelin, Uniswap Labs, Hyperlane, and 30+ ecosystem teams. The OIF is not a separate product from <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents. They are the same stack.</p><p>The OIF solves a fragmentation problem. Without a shared standard, every protocol expresses intents differently. Solvers cannot efficiently cover all of them. The ecosystem splinters into isolated intent silos. The OIF defines open, modular standards for how intents are expressed, discovered, and executed — so any solver can fill any OIF-compatible intent on any protocol that implements the standard.</p><h3 id="h-erc-7683-the-technical-standard" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>ERC-7683: The Technical Standard</strong></h3><p>The underlying technical standard is <strong>ERC-7683</strong>. It standardises cross-chain intent expression. Any frontend, wallet, or protocol that implements ERC-7683 can describe what a user wants without prescribing how it should be fulfilled. Any solver supporting ERC-7683 can fill it. This is permissionless interoperability at the standard level — not the protocol level.</p><h3 id="h-intents-vs-traditional-bridges-the-core-difference" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Intents vs Traditional Bridges: The Core Difference</strong></h3><p>The simplest way to frame it: traditional bridges are route-based. You specify the exact path, and the infrastructure executes it step by step. Intent-based systems are outcome-based. You specify the result, and the infrastructure figures out how to get there.</p><p>The implications run deeper than UX. Route-based execution fails visibly when any step fails. Outcome-based execution has a built-in fallback: if no solver fills the intent, the escrow refunds you. The risk profile is fundamentally different.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/b3c0ea1451b541f434b60b45785d01095ccc8f88d78fae8c425e11007b728a6d.png" blurdataurl="data:image/png;base64,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" nextheight="2610" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Next week: Jumper vs competitors. How Jumper stacks up against Stargate, Socket, and Squid — a real comparison across price, speed, chain coverage, and UX.</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/18ff0352016cc44f334f4188014e578f134f035f522e5b19bbd4575eebe789c4.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Dango vs Cosmos Appchains and Celestia Rollups]]></title>
            <link>https://paragraph.com/@olumi/dango-vs-cosmos-appchains-and-celestia-rollups</link>
            <guid>4BnC0YRT14JnXQkbhiMc</guid>
            <pubDate>Mon, 15 Jun 2026 04:04:37 GMT</pubDate>
            <description><![CDATA[The Two Most Credible Alternatives By this point in the series, the case for why Dango needed to build its own chain is established. EVM constraints make a real CLOB impractical. AMMs have structural problems no upgrade can fix. Modular stacks leak sovereignty in ways that matter for a DeFi hub. Native smart accounts require a custom execution environment. But there are two architectural alternatives that share Dango's instinct for building sovereign infrastructure, and they deserve a direct ...]]></description>
            <content:encoded><![CDATA[<h2 id="h-the-two-most-credible-alternatives" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Two Most Credible Alternatives</h2><p>By this point in the series, the case for why Dango needed to build its own chain is established. EVM constraints make a real CLOB impractical. AMMs have structural problems no upgrade can fix. Modular stacks leak sovereignty in ways that matter for a DeFi hub. Native smart accounts require a custom execution environment.</p><p>But there are two architectural alternatives that share Dango's instinct for building sovereign infrastructure, and they deserve a direct comparison rather than a dismissal. The first is the Cosmos appchain model, best exemplified by dYdX's migration to its own Cosmos chain in late 2023. The second is the Celestia rollup model, which claims to offer sovereignty with better infrastructure economics.</p><p>Understanding where Dango differs from each of these matters both for evaluating Dango's technical choices and for understanding what the team believes it has built that others have not.</p><hr><h2 id="h-cosmos-appchains-the-most-direct-comparison" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Cosmos Appchains: The Most Direct Comparison</h2><h3 id="h-what-a-cosmos-appchain-actually-is" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What a Cosmos Appchain Actually Is</h3><p>A Cosmos appchain is a sovereign Layer 1 blockchain built using the Cosmos SDK. It runs CometBFT consensus, has its own validator set, and connects to other chains via IBC (Inter-Blockchain Communication). Teams building on Cosmos have full control over their execution logic, gas mechanisms, and governance without inheriting Ethereum's constraints.</p><p>This is genuinely the closest architectural category to what Dango is doing. Both Dango and Cosmos appchains are sovereign L1s. Both use CometBFT for consensus. Both have their own validator sets. Both can customize execution, gas, and governance without hard forking a shared chain.</p><p>dYdX is the most instructive Cosmos appchain to compare directly. It started as Ethereum smart contracts in 2017, moved to a StarkEx L2, and finally migrated to its own Cosmos appchain in late 2023 for exactly the same reasons that motivate Dango: control over execution, gas-free order management, and a trading experience that general-purpose chains cannot provide.</p><h3 id="h-where-dydx-and-dango-diverge" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Where dYdX and Dango Diverge</h3><p>The surface similarity between dYdX and Dango as Cosmos-adjacent sovereign L1s masks significant differences in the architecture of each product.</p><p><strong>Off-chain versus on-chain order matching.</strong> dYdX's order book lives in validator memory. Orders are collected by validators, matched off-chain, and only the resulting fills are settled on-chain. This is a hybrid model: the blockchain handles settlement and state, but the matching engine is an off-chain system that validators run as part of their node software.</p><p>Dango's CLOB is fully on-chain. The matching engine runs as part of the Grug execution environment at the end of every block via the EndBlock hook. There are no off-chain components involved in matching. This is a harder architectural choice that requires the execution environment to support protocol-native automation, which is exactly what Grug's cronjob system provides.</p><p>The practical difference is meaningful for MEV and censorship resistance. An off-chain matching engine can theoretically be manipulated by a sufficiently large validator coalition. A fully on-chain matching engine running deterministically at EndBlock cannot. The rules of matching are part of the protocol, verifiable by any node, and not subject to validator discretion.</p><p><strong>Execution environment: Cosmos SDK versus Grug.</strong> dYdX uses the Cosmos SDK for its execution layer. The Cosmos SDK is a mature, battle-tested framework that has powered Osmosis, Secret Network, Kava, and dozens of other chains. But it is a general framework, not one designed for DeFi specifically.</p><p>Dango uses Grug, a custom execution environment built from scratch with DeFi as the primary use case. Grug provides native smart accounts, a programmable gas mechanism via the taxman contract, protocol-native cronjobs, reentrancy prevention by design, and a unified token standard. None of these are features of the Cosmos SDK out of the box.</p><p>The Cosmos SDK gives dYdX a stable foundation with a large developer ecosystem. Grug gives Dango capabilities that the Cosmos SDK does not provide without significant custom development.</p><p><strong>Account model: seed phrases versus passkeys.</strong> dYdX uses the Cosmos SDK's standard account model, which means private keys and seed phrases. Users connecting to dYdX need a Cosmos-compatible wallet. There is no native smart account system, no Face ID authentication, no protocol-level gas abstraction in USDC.</p><p>Dango's native smart account system is the foundation of its user experience. No seed phrase. No wallet extension. Passkey authentication via Face ID. USDC for gas at the protocol level. This is a consequence of Grug's design, not a feature that can be added to a Cosmos SDK chain without building an entirely parallel account infrastructure.</p><p><strong>Product scope.</strong> dYdX launched as a perpetuals exchange and has been expanding to spot trading and prediction markets as separate product additions. The architecture reflects this: derivatives are the core, and other products are being grafted on.</p><p>Dango launched with unified margin across spot, perpetuals, and lending from the start. These are not separate products sharing infrastructure. They are a single unified margin account that treats all positions as part of one collateral pool. This is a product architecture difference that flows from the execution environment: Grug's ability to handle complex cross-product state in a single transaction is what makes unified margin possible.</p><h3 id="h-the-dydx-comparison-summary" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The dYdX Comparison Summary</h3><p>dYdX and Dango are the two most sophisticated DeFi-native L1 projects in the Cosmos-adjacent space. They share the insight that general-purpose chains cannot deliver a professional trading experience. But they made different choices about the execution environment, the order matching architecture, the account model, and the product scope.</p><p>dYdX chose the Cosmos SDK for maturity and ecosystem, off-chain matching for performance, and a derivatives-first product expansion. Dango chose a custom execution environment for DeFi-specific capabilities, fully on-chain matching for censorship resistance, and a unified DeFi hub from day one.</p><p>Neither choice is obviously wrong. dYdX has the advantage of years of production history, a battle-tested codebase, and a large user base. Dango has the advantage of building the execution environment around the product rather than the product around the execution environment.</p><hr><h2 id="h-celestia-rollups-the-infrastructure-economics-alternative" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Celestia Rollups: The Infrastructure Economics Alternative</h2><h3 id="h-what-celestia-rollups-promise" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What Celestia Rollups Promise</h3><p>Celestia's pitch to application developers is compelling: use Celestia as your data availability layer and you get the benefits of a sovereign chain at a fraction of the cost. You do not need to bootstrap your own data availability infrastructure. You do not need to build consensus from scratch. You focus on execution, and Celestia handles the rest.</p><p>The numbers are real. Celestia has achieved 21.33MB/s throughput with 128MB blocks in testing. Data availability costs on Celestia are dramatically lower than posting data to Ethereum. More than 20 rollups have launched on the Celestia mainnet since November 2023, and the ecosystem continues to grow.</p><p>For many application categories, this is a reasonable architectural choice. A gaming chain that needs cheap data availability and does not require atomic composability with other DeFi protocols can use Celestia effectively. A single-product DeFi application that does not need to interact atomically with other protocols can get real cost benefits from the Celestia model.</p><h3 id="h-where-the-celestia-model-falls-short-for-dangos-use-case" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Where the Celestia Model Falls Short for Dango's Use Case</h3><p>Thread 5 covered the sovereignty leaks in modular stacks in detail. Applied specifically to Dango's product requirements, the Celestia rollup model has three critical incompatibilities.</p><p><strong>Fragmentation breaks unified margin.</strong> Dango's unified margin account lets a single collateral pool back positions across spot, perpetuals, and lending simultaneously. This requires that all three products share the same execution environment, are secured by the same validator set, and can update their state atomically in a single transaction.</p><p>In a Celestia rollup architecture, each application or protocol is typically deployed on its own execution layer. The spot trading system, the perpetuals protocol, and the lending protocol would each be separate rollups or separate contracts on separate rollups. Moving collateral between them requires a bridge. Bridging takes time and introduces trust assumptions. Unified margin across rollups with bridge latency is not unified margin. It is a collateral management problem with significant user friction and liquidation risk during bridge delays.</p><p>Every new rollup or appchain creates another isolated liquidity pool. DeFi protocols must implement cross-chain bridges or aggregators to unify liquidity across multiple execution layers. On a monolithic chain, smart contracts can interact atomically in a single transaction. Across different rollups, achieving the same level of composability requires complex bridging and messaging infrastructure.</p><p>This is precisely the use case Dango's product depends on. Unified margin is not a convenience feature. It is the core product differentiation. A Celestia rollup architecture makes it structurally impractical.</p><p><strong>Fragmentation breaks liquidity.</strong> Liquidity fragmentation occurs when assets are spread across various L2 solutions, reducing capital efficiency for DeFi protocols. Users face higher slippage and inefficiencies when trading across different rollups.</p><p>Dango's CLOB depends on deep, unified liquidity. A CLOB with shallow liquidity has wide spreads. A CLOB with liquidity fragmented across multiple rollup instances has multiple separate order books, each with worse depth than a single unified book. The Celestia model's strength, enabling many specialized rollups, is a direct liability for a protocol that needs concentrated liquidity in a single venue.</p><p><strong>The execution environment cannot be customized.</strong> Celestia provides data availability and consensus. Execution is the rollup operator's responsibility. Most rollups use the EVM or CosmWasm as their execution layer, inheriting the constraints of those environments.</p><p>Grug's capabilities: native smart accounts, taxman gas contracts, protocol-native cronjobs, reentrancy prevention by design, unified token standard, all of these require a custom execution environment. A Celestia rollup running EVM or CosmWasm has none of these natively. Dango would be building on a Celestia rollup with a standard EVM and then retrofitting smart accounts via ERC-4337, building a bot network for automated matching, and implementing a custom gas mechanism that does not fit cleanly into the EVM model.</p><p>That is exactly the set of constraints that motivated building Grug in the first place.</p><hr><h2 id="h-the-positioning" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Positioning</h2><p>Dango, dYdX, and Celestia rollups all represent serious attempts to solve real problems with general-purpose chain architectures. They are not naive projects. They are the most technically sophisticated alternatives available.</p><p>But they make different bets about what matters most:</p><p>dYdX bet that the Cosmos SDK's maturity and the off-chain matching engine's performance would be sufficient to deliver a CEX-grade experience. That bet is paying off for a derivatives-focused exchange.</p><p>Celestia rollups bet that specialization via the modular stack would enable the best possible applications to be built on cheap, flexible infrastructure. That bet is paying off for applications that do not require cross-rollup atomic composability.</p><p>Dango bet that building a custom execution environment from scratch, specifically for a unified DeFi hub, would enable capabilities that neither Cosmos SDK appchains nor Celestia rollups can deliver. That bet produces native smart accounts with Face ID authentication, a fully on-chain CLOB with batch auctions eliminating MEV, unified margin across spot and perpetuals and lending in a single atomic transaction, and a gas mechanism that does not require users to hold a native token.</p><p>Whether that bet produces a sustainable competitive advantage depends on execution, market adoption, and whether the capabilities Grug unlocks are valued highly enough by traders to overcome the bootstrapping challenges of a new chain. But the technical reasoning is coherent. The choice was not made by default. It was made by a team that understood the alternatives and built something different on purpose.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/7747841c71c0809411d6c96f94a295b323c8bf8f315b957f55ba86880018c213.png" blurdataurl="data:image/png;base64,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" nextheight="2586" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Part 6 of a research series on Dango's technical architecture. Part 1 covered Hyperlane vs LayerZero, Wormhole, and Axelar. Part 2 covered ERC-4337 vs Dango Smart Accounts. Part 3 covered Grug vs EVM vs SVM. Part 4 covered CLOB vs AMM on a sovereign L1. Part 5 covered why modular stacks still leak sovereignty. Part 7 will cover Dango's tokenomics and economic security model, pending the DNG TGE.</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/b7d5f237835a1ff58b834335705cb1612f0570391a7be95986bfee0d275daaf8.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Same Engine, Different Cars:
LI.FI Infrastructure Meets Jumper UX]]></title>
            <link>https://paragraph.com/@olumi/same-engine-different-cars-lifi-infrastructure-meets-jumper-ux</link>
            <guid>JpAa9Dle8spiUnD44ynH</guid>
            <pubDate>Thu, 11 Jun 2026 08:20:29 GMT</pubDate>
            <description><![CDATA[LI.FI and Jumper are not the same product. But they run on the same engine. Here is why both exist, who each one is for, and why the distinction matters. Over the past four weeks I have covered LI.FI and Jumper separately — what each one is, how the product stack is structured, how the routing engine works. This week is the connector: the post that ties both together and explains the relationship between them. The short version is this: LI.FI is infrastructure. Jumper is the consumer product ...]]></description>
            <content:encoded><![CDATA[<p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><em>LI.FI</em></a><em> and Jumper are not the same product. But they run on the same engine. Here is why both exist, who each one is for, and why the distinction matters.</em></p><p>Over the past four weeks I have covered <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> and Jumper separately — what each one is, how the product stack is structured, how the routing engine works. This week is the connector: the post that ties both together and explains the relationship between them.</p><p>The short version is this: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> is infrastructure. Jumper is the consumer product built on that infrastructure.</strong> Same company, different audiences, different jobs, one engine powering both.</p><h3 id="h-the-analogy-that-makes-it-click" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Analogy That Makes It Click</strong></h3><p>Think of AWS and a SaaS product built on AWS. AWS is the plumbing — servers, databases, networking. You do not interact with AWS directly as a consumer. You use the product built on top of it. The SaaS product's reliability, speed, and capability is directly determined by the quality of the AWS infrastructure underneath.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> is the plumbing. Jumper is the product most users interact with. But builders — wallets, DeFi protocols, fintechs, AI agents — interact with <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> directly, either via the API, the SDK, the Widget, or the MCP server.</p><h3 id="h-who-each-one-is-for" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Who Each One Is For</strong></h3><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a> speaks to developers and enterprises. A wallet team embeds the Widget so their users can bridge without leaving the app. A DeFi protocol uses the Composer to build cross-chain zaps. A fintech integrates the REST API to power on/off-ramp flows. An AI agent calls the MCP server at <code>mcp.li.quest/mcp</code> to execute cross-chain transactions autonomously. An institution uses Pioneer to distribute a tokenised RWA.</p><p><strong>Jumper</strong> speaks to DeFi users. Traders moving assets across chains. Yield farmers zapping into positions. Wallet users tired of managing four different bridge interfaces. Anyone who wants the best available route without needing to understand how routing works. No integration required. Connect and go.</p><h3 id="h-what-they-share-under-the-hood" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>What They Share Under the Hood</strong></h3><p>Despite the different entry points and audiences, both Jumper and every <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> integrator run on the same underlying infrastructure. The same Diamond Contract coordinates on-chain execution. The same aggregation layer queries 29+ bridges and 33+ DEXs. The same <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents solver network fills trades. The same fallback logic handles provider failures. The same token normalization resolves USDC vs USDC.e vs bridged USDC automatically.</p><p><em>A trade executed through Jumper and a trade executed through a wallet that has integrated </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><em>LI.FI</em></a><em>'s API go through exactly the same infrastructure. The user interface is different. The execution layer is identical.</em></p><h3 id="h-why-both-exist" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Why Both Exist</strong></h3><p>The strategic reason to maintain both is that the integrator market is structurally larger than the consumer market. Every wallet that ships the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Widget exposes its user base — potentially millions of people — to the same routing engine. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> captures retail at scale through B2B integrations. Jumper captures retail directly for users who come without an intermediary.</p><p>The two are not competing. They are complementary distribution channels for the same infrastructure.</p><h3 id="h-the-network-effect" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Network Effect</strong></h3><p>Here is the part that compounds over time. Every new integrator that ships <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> adds orderflow to the solver network. More orderflow attracts more professional solvers. More solver competition tightens prices and improves execution speed. Better prices benefit every user of the infrastructure — including Jumper users who never thought about the solver network.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s B2B growth directly and measurably improves Jumper's consumer product. The two flywheels are the same flywheel.</p><h3 id="h-the-simplest-version" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Simplest Version</strong></h3><p>If you are building on <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>, you are building a car. You choose the body, the dashboard, the features, the audience. The engine is already there.</p><p>If you are using Jumper, you are driving one of those cars — the one <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> built for the general DeFi user.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/5e54302df22aa34d165aa4c768f925bf8395d7e5d86595af94d4c3d54435f50a.png" blurdataurl="data:image/png;base64,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" nextheight="2620" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p>Next week: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s smart contract architecture — how the Diamond Contract and Facet system works, and why modularity matters at the execution layer.</p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/dae841092905d05964cf92a0d42e061f5162720224c012e0b1b1f7404d743268.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Why Modular Stacks Still Leak Sovereignty]]></title>
            <link>https://paragraph.com/@olumi/why-modular-stacks-still-leak-sovereignty</link>
            <guid>nktTCjTCj6qrUoNBcmsj</guid>
            <pubDate>Mon, 08 Jun 2026 09:02:59 GMT</pubDate>
            <description><![CDATA[The Promise of ModularityThe modular blockchain thesis is one of the most compelling architectural ideas in crypto. Instead of building a single chain that handles everything, you separate the functions: execution on one layer, data availability on another, settlement on a third, consensus somewhere else. Each layer specializes. Each layer can be upgraded independently. Teams can mix and match components to build exactly the chain they need. Celestia made this argument forcefully and early. E...]]></description>
            <content:encoded><![CDATA[<h2 id="h-the-promise-of-modularity" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Promise of Modularity</h2><p>The modular blockchain thesis is one of the most compelling architectural ideas in crypto. Instead of building a single chain that handles everything, you separate the functions: execution on one layer, data availability on another, settlement on a third, consensus somewhere else. Each layer specializes. Each layer can be upgraded independently. Teams can mix and match components to build exactly the chain they need.</p><p>Celestia made this argument forcefully and early. Ethereum's rollup-centric roadmap validated it. EigenLayer extended it to restaking. By 2025, the modular stack had become the dominant framework for serious chain builders. Arbitrum Orbit, Polygon CDK, zkSync Hyperchains, Starknet Appchains: the tooling for spinning up a modular rollup in days became widely available.</p><p>The pitch to developers was sovereignty. Build your own chain. Control your own VM, your own gas token, your own execution environment. Make changes without asking permission from Ethereum's governance. Run your community's rules, not someone else's.</p><p>It is a genuinely good pitch. And it is partially true. But the sovereignty modular stacks deliver is narrower than it appears, and understanding where it leaks requires looking carefully at what those stacks actually depend on.</p><hr><h2 id="h-what-modular-actually-means" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Modular Actually Means</h2><p>A modular blockchain separates what a monolithic chain bundles together. Bitcoin and early Ethereum handle everything in one place: nodes execute transactions, reach consensus on their order, store all the data, and settle finality. This is simple and robust but creates bottlenecks. Execution congestion on Ethereum raises gas prices for every user of every application simultaneously, regardless of which application caused the congestion.</p><p>Modular architecture separates these concerns. A rollup handles execution. A data availability layer like Celestia or EigenDA stores transaction data cheaply and verifiably. A settlement layer like Ethereum provides finality and security. A sequencer orders transactions before they are executed.</p><p>The separation is real and the benefits are real. Transactions on modular rollups are typically 50 to 100 times cheaper than on Ethereum L1 or most L2s. Developers can make changes to the tech stack without permission from outside applications, such as implementing a more performant execution environment or changing how transaction processing works.</p><p>But each layer you outsource is a layer you depend on. And dependency is the opposite of sovereignty.</p><hr><h2 id="h-the-sequencer-problem" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Sequencer Problem</h2><p>Every modular rollup needs a sequencer. The sequencer is the entity that receives user transactions, decides their order, and produces blocks that get posted to the data availability layer.</p><p>In a monolithic blockchain, the consensus layer orders transactions. In a rollup, a sequencer makes ordering decisions. If the sequencer is a single entity, it can extract maximum extractable value by reordering transactions for profit.</p><p>In practice, almost every rollup launched to date runs a centralized sequencer operated by the team that built the rollup. Arbitrum's sequencer is run by Offchain Labs. Optimism's sequencer is run by OP Labs. Base's sequencer is run by Coinbase. zkSync's sequencer is run by Matter Labs.</p><p>This is not a temporary state that will be fixed eventually. It is a structural feature of how rollups are economically incentivized today. Running a sequencer is profitable: sequencers collect transaction fees and can extract MEV. Teams are not rushing to decentralize a profitable infrastructure component they control.</p><p>The consequences are real. A centralized sequencer can censor transactions, reorder them for profit, go offline and halt the chain, or change fee policies unilaterally. A centralized sequencer, if halted, could disrupt the entire system. With complete control over processing user transactions, a centralized sequencer could arbitrarily censor transactions, violating the principle of openness and fairness.</p><p>When you build on a modular rollup framework, you inherit the sequencer. You can customize the execution environment. You can choose your data availability layer. You cannot easily change who sequences your transactions without rebuilding the foundation of your chain.</p><hr><h2 id="h-the-data-availability-dependency" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Data Availability Dependency</h2><p>Choosing a data availability layer seems like a free choice. Celestia, EigenDA, Avail, or Ethereum calldata: pick whichever fits your cost and security requirements.</p><p>But this choice is not reversible without significant friction. Your state history is on the DA layer you chose at launch. Your users' funds are secured by it. Your fraud proofs or validity proofs reference it. Migrating a live chain to a different DA layer while maintaining continuity of state and user balances is an unsolved engineering problem that no major rollup has successfully completed.</p><p>The security of a typical modular architecture depends on all three layers functioning correctly. If Celestia withholds data, the rollup cannot prove what transactions occurred. If Ethereum's validator set gets corrupted, final settlement becomes unreliable.</p><p>This means the security of your chain is bounded by the weakest link in the stack you assembled. A rollup that uses Celestia for DA and Ethereum for settlement inherits the security assumptions of both. If either fails, the rollup fails. The security is not additive. It is multiplicative in a negative direction: more layers means more potential failure points.</p><p>Celestia acknowledges that the big problem in the modular stack is fragmentation. That fragmentation is not just a user experience problem. It is a security surface problem. Every bridge between layers is an attack vector. In a modular architecture, bridges shift from optional add-ons to load-bearing infrastructure. They carry significant locked value while often operating under governance models that lack the years of adversarial hardening seen in core layers.</p><hr><h2 id="h-the-settlement-layer-constraint" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Settlement Layer Constraint</h2><p>Smart contract rollups, which are the most common type, settle on Ethereum. This settlement is what gives them their security guarantee: fraud proofs or validity proofs submitted to Ethereum verify that execution on the rollup was correct.</p><p>But settlement on Ethereum means Ethereum's rules govern what you can prove. The EVM is the verification environment. If you want to run a custom execution environment that Ethereum's smart contracts cannot verify, you cannot use Ethereum for settlement. You need either a different settlement layer or a ZK proof system that can express your execution environment's semantics in a form Ethereum can verify.</p><p>Rollups are constrained by the capabilities and rules of the Ethereum network and the Ethereum Virtual Machine. They cannot execute transactions incompatible with EVM logic or undergo protocol upgrades independently of Ethereum's consensus process.</p><p>Sovereign rollups, like those built on Celestia, handle their own settlement rather than settling on Ethereum. Sovereign rollups are responsible for execution and settlement, while the DA layer handles consensus and data availability. DA layers do not verify whether sovereign rollup transactions are correct. Nodes verifying the sovereign rollup are responsible for verifying whether new transactions are correct.</p><p>This gives sovereign rollups more freedom over their execution environment. But it comes at a cost: without a settlement layer doing external verification, security depends entirely on your own validator set. If that validator set is small, your chain is less secure than if it settled on Ethereum. You traded external verification for internal control. Whether that trade makes sense depends on how credibly you can run a secure validator network.</p><hr><h2 id="h-what-real-sovereignty-requires" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Real Sovereignty Requires</h2><p>The pattern across all these dependencies is the same: every layer you outsource gives you efficiency and speed, and takes away a piece of control. The modular stack is not sovereignty. It is a toolkit for assembling a chain from other people's infrastructure with varying degrees of governance over each component.</p><p>Real sovereignty, in the sense that matters for a serious application chain, means:</p><p><strong>Control over execution.</strong> You decide how your smart contracts run, what they can do, and how they are priced. This requires your own execution environment, not a fork of the EVM that must maintain EVM compatibility to use the tooling your DA or settlement layer expects.</p><p><strong>Control over ordering.</strong> You decide how transactions are sequenced. This requires either your own validator set performing ordering as part of consensus, or a decentralized sequencer you control, not a shared sequencer operated by a third party whose incentives may diverge from yours.</p><p><strong>Control over finality.</strong> You decide when transactions are final and what the security model behind that finality is. This requires your own consensus mechanism, not a dependency on another chain's validators to provide economic security.</p><p><strong>Control over the fee mechanism.</strong> You decide how gas is priced, who receives fees, and under what conditions fees can change. This requires the fee mechanism to be customizable without a hard fork and without permission from another layer's governance.</p><p><strong>No load-bearing external bridges.</strong> Every bridge between layers is a security assumption. Minimizing the number of external bridges minimizes the attack surface. A chain that can be drained by exploiting a bridge to its DA layer has not achieved meaningful sovereignty.</p><hr><h2 id="h-why-dango-made-a-different-choice" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why Dango Made a Different Choice</h2><p>Dango could have been built as a modular rollup. The tooling exists. The path to launch would have been faster. The marketing narrative around sovereignty would have been easier to borrow.</p><p>Instead, Left Curve built a sovereign L1 from scratch. Custom execution environment in Rust. Custom account model. Custom gas mechanism. Custom consensus. The entire stack in a single repository under a single team's control.</p><p>The reason is that the product Dango is building requires the kind of sovereignty that modular stacks cannot fully deliver. A unified margin account that shares state across spot trading, perpetuals, and lending requires atomic composability: all three products must execute in the same block, with the same state, under the same security model. Splitting execution across layers breaks this guarantee.</p><p>An on-chain CLOB with batch auction settlement requires the matching engine to run at end-of-block as part of consensus. This is possible on Grug with EndBlock hooks. It is not possible on a rollup that depends on a third-party sequencer for ordering.</p><p>A native smart account system where every account defines its own authentication logic requires the account model to be protocol-level, not a smart contract layer built on top of an existing account model. This requires owning the execution environment.</p><p>None of these requirements are impossible in theory on a modular stack. Each one becomes significantly harder, more complex, or less secure when implemented across multiple external dependencies. The modular stack is excellent for applications that need cheap, fast execution and can accept the sovereignty trade-offs. Dango's product thesis requires trade-offs that go the other direction.</p><hr><h2 id="h-the-honest-case-for-modularity" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Honest Case for Modularity</h2><p>This is not an argument that modular is wrong. It is an argument that modular sovereignty is narrower than its proponents often claim, and that the right architectural choice depends entirely on what you are building.</p><p>For most applications, a well-designed rollup on a modular stack is the correct choice. The sequencer dependency is real but manageable for applications where censorship resistance is not critical. The DA dependency is real but acceptable when the DA layer has strong security. The settlement constraint is real but workable for applications that can stay within EVM semantics.</p><p>The specific combination of features Dango is building: an on-chain CLOB, native smart accounts, unified cross-product margin, protocol-level automation, and a custom fee mechanism sits at the edge of what modular stacks can accommodate cleanly. For that combination, building a sovereign L1 is not stubbornness. It is the only architecture that delivers the full product without fundamental compromises.</p><p>The modular stack leaks sovereignty in the places that mattered most for what Dango needed to build. Building from scratch was the answer to that specific problem. For most builders, it would not be.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/1f205456d2c48b9a1d832de3ba0b48c7daf11701c219f4fe64fee7af66a14f68.png" blurdataurl="data:image/png;base64,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" nextheight="2194" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Part 5 of a research series on Dango's technical architecture. Part 1 covered Hyperlane vs alternatives. Part 2 covered ERC-4337 vs Dango Smart Accounts. Part 3 covered Grug vs EVM vs SVM. Part 4 covered CLOB vs AMM on a sovereign L1. Part 6 will cover Dango vs Cosmos appchains and Celestia rollups directly.</em></p><br>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/dd6b840b94581f4f5b8af735b3bf190d456b6e9cdf2371a261b9f1236301a485.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[CeloSense — I Built an Autonomous On-Chain Intelligence Agent for Celo in Under 2 Weeks]]></title>
            <link>https://paragraph.com/@olumi/celosense-—-i-built-an-autonomous-on-chain-intelligence-agent-for-celo-in-under-3-weeks</link>
            <guid>N87y2TljXhiwgJqFozln</guid>
            <pubDate>Mon, 08 Jun 2026 06:30:00 GMT</pubDate>
            <description><![CDATA[When I saw Celo's Proof of Ship program, I didn't want to build something generic. I wanted to build something that actually reflected how I think about on-chain ecosystems — as living, breathing networks of activity that most people have no visibility into. That's what CeloSense is. What it does CeloSense is an autonomous on-chain intelligence agent for the Celo ecosystem. You connect your wallet, enter any Celo address, and the agent returns a full intelligence report — live CELO, USDC, and...]]></description>
            <content:encoded><![CDATA[<p>When I saw Celo's Proof of Ship program, I didn't want to build something generic. I wanted to build something that actually reflected how I think about on-chain ecosystems — as living, breathing networks of activity that most people have no visibility into.</p><p>That's what CeloSense is.</p><p><strong>What it does</strong></p><p>CeloSense is an autonomous on-chain intelligence agent for the Celo ecosystem. You connect your wallet, enter any Celo address, and the agent returns a full intelligence report — live CELO, USDC, and USDT balances, recent transfer history, whale activity flags for transactions over 10,000 USDC, and an activity score from 0 to 100 based on on-chain behavior.</p><p>Every query costs $0.01 USDC, paid directly from your connected wallet on Celo mainnet. Payment is settled on-chain — the API verifies the USDC transfer receipt on Celo mainnet before returning any data. No payment, no data. No subscriptions. No API keys. No intermediaries. Just on-chain data, gated by on-chain payment.</p><p>Inside MiniPay, the experience is even smoother — CeloSense detects the wallet automatically and connects without any user action. No connect button. No friction. You land on the app and it just works.</p><p><strong>The registry</strong></p><p>Beyond querying, users can register their wallet in the CeloSenseRegistry smart contract on Celo mainnet. Registration creates a public on-chain credential — a permanent, verifiable record that your wallet has opted into active monitoring.</p><p>This is v1 infrastructure. The contract is live, non-upgradeable, and has no admin keys. Right now registration is the foundation — wallets that register today are early adopters whose addresses will be the first to benefit when the background monitoring agent ships. Think of it as getting on the allowlist before the intelligence layer is fully autonomous.</p><p>The registry timestamp is permanent and verifiable on-chain. That matters for future airdrop eligibility, reputation systems, and protocol integrations that reward early on-chain participation.</p><p> Verified on Celoscan. Source code fully public.</p><p><strong>How I built it</strong></p><p>The stack is Next.js 14, wagmi v2, viem, and a custom x402 payment layer. The backend polls Celo mainnet via viem, scanning recent blocks for USDC Transfer events, computing balances, and flagging anomalies. The contract was written in Solidity 0.8.20, deployed and verified using Hardhat.</p><p>The payment flow works in three steps. First, clicking Analyze triggers a real $0.01 USDC transfer from the user's wallet to the fee recipient address on Celo mainnet. Second, the transaction hash is passed to the API as proof of payment. Third, the API reads the transaction receipt on-chain, verifies that the correct amount was sent to the correct address, and only then returns the intelligence data. The entire flow is trustless — no centralized payment processor, no escrow, no off-chain settlement.</p><p>The MiniPay integration required one hook — detecting <code>window.ethereum.isMiniPay</code> and auto-connecting the injected wallet. That single hook is what makes CeloSense a qualifying Mini App for the Proof of Ship program.</p><p>The design system uses my brand palette — parchment backgrounds, navy primary, crimson for alerts, green for Celo-native elements. Barlow Condensed for headlines, JetBrains Mono for on-chain data. Every detail is intentional.</p><p><strong>Why I built it this way</strong></p><p>I've been building across ecosystems — Arc, Base, Injective — and the pattern I keep seeing is that most intelligence tools are either too complex, too expensive, or locked behind paywalls. CeloSense is the opposite. It's open, minimal, pay-per-use, and fully on-chain. The $0.01 per query isn't a fee — it's proof of participation. Every query is an on-chain event.</p><p>This is also the third time I've built this pattern. ArcSense for Arc Network. Now CeloSense for Celo. Each one teaches me something new about how on-chain intelligence should work.</p><p><strong>What's next</strong></p><p>The background monitoring agent is the next build phase — a server-side process that continuously watches registered wallets, detects whale movements in real time, and eventually publishes alerts on-chain. The registry contract is already deployed and ready to feed it wallet addresses the moment it ships.</p><p>Beyond that: extending the intelligence window beyond 500 blocks, historical trend analysis, and a free daily self-query for registered wallets so registration has immediate utility.</p><p>For now, the core is working. Queries pay $0.01 USDC on-chain. The registry is live. The foundation is solid.</p><p>Try it at <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://celosense.vercel.app">celosense.vercel.app</a>. Register your wallet. Analyze someone else's. See what the chain knows.</p><hr><p><em>Built by Abu Olumi — Builder · Researcher · On-chain Contributor</em> <em>@olumi441 on X</em> <em>Submitted to Celo Proof of Ship — June 2026</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/e155a7c5af85ff12f83e48081f6d7cb5eb8b7565e7518d52e0229af3a0ef5de0.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[The state of programmable payments on Arc — what the data says
]]></title>
            <link>https://paragraph.com/@olumi/the-state-of-programmable-payments-on-arc-—-what-the-data-says</link>
            <guid>I7JB5MLCs7QJDLcxG9IS</guid>
            <pubDate>Sat, 06 Jun 2026 08:23:09 GMT</pubDate>
            <description><![CDATA[Edition 1 ended on May 23 with a crash, a fix, and a summary of the first seven days: 200k+ blocks scanned, 2k+ autonomous agent cycles, $30+ USDC spent. Two weeks have passed since then. The numbers have grown significantly. A weekly intelligence report generated successfully but never made it to the dashboard. And the agent's spending pattern across three weeks of live operation has produced a dataset worth examining closely. Since ArcSense launched publicly on May 7, the autonomous agent h...]]></description>
            <content:encoded><![CDATA[<p>Edition 1 ended on May 23 with a crash, a fix, and a summary of the first seven days: 200k+ blocks scanned, 2k+ autonomous agent cycles, $30+ USDC spent. Two weeks have passed since then. The numbers have grown significantly. A weekly intelligence report generated successfully but never made it to the dashboard. And the agent's spending pattern across three weeks of live operation has produced a dataset worth examining closely.</p><p>Since ArcSense launched publicly on May 7, the autonomous agent has spent $370.20+ USDC on intelligence — every payment a real on-chain transfer, every decision logged, every transaction verifiable on Arc Explorer. This is what the data says about programmable payments on Arc.</p><p>Week 2: the data</p><p>Week 2 ran from May 22 to May 30 — eight days following the redeploy that fixed the Math.max crash. The agent completed 2,329 cycles and spent $225.80 USDC on intelligence.</p><p>The headline number masks what was actually happening. By May 27 — just five days into the week — the agent had already spent $66.20. That figure was shared publicly at the time. The full week ended at $225.80, more than three times the May 27 figure, because the failure rate spike that began on May 27 continued driving autonomous spending for the remainder of the week.</p><p>On May 27, Arc Testnet failure rate climbed from 1.9% to 3.92% over the course of a single day. The agent crossed its 3% payment threshold and kept buying block intelligence and contract risk scans continuously for the duration. $47.40 USDC in 24 hours alone. Every payment was a real on-chain transfer from the agent wallet to the service wallet. Every decision logged with the reasoning, the urgency level, and a clickable Arc Explorer transaction link. The agent was not spending blindly — it was responding to a specific on-chain condition, escalating spending in proportion to the severity of that condition, and de-escalating when it passed.</p><p>The weekly report that generated but never surfaced</p><p>On May 29 at 17:27 UTC, the ArcSense weekly report generator fired after eight days of accumulated block data. It computed the health score, aggregated failure rates across every block scanned that week, identified the most volatile block, ranked the top failing contracts, and generated a plain-English insight. It wrote the output to a JSON file on Railway's filesystem and logged the confirmation to the terminal.</p><p>Then nothing happened on the dashboard. The Weekly Reports modal showed "NO REPORT YET."</p><p>The reason was straightforward: I had built the report generator but never built the API endpoint to serve the generated file. The JSON was sitting on Railway's ephemeral filesystem with no route to expose it. A fully functional piece of infrastructure with no way to observe its output.</p><p>The fix was ten lines of code — a GET /reports/weekly endpoint in index.ts that reads the latest weekly JSON file from disk and returns it. But by the time the fix was pushed, Railway redeployed, the ephemeral filesystem reset, and the report was gone.</p><p>This pattern shows up repeatedly in production systems. The generation side gets built because it is the interesting engineering problem. The serving side — the endpoint, the dashboard integration, the observability — gets deferred because it feels like plumbing. The consequence is infrastructure that works but cannot be seen. A report that proves the system ran correctly, accumulated real data for eight days, and produced a meaningful output — and was completely invisible to anyone using the product.</p><p>The lesson is simple: every artifact a system generates needs a corresponding way to surface it, built at the same time. The generator is not complete until its output is reachable.</p><p>Week 3: the data</p><p>Week 3 ran from May 30 to June 5. The agent completed approximately 1,185 cycles and spent $48.20 USDC before a forced reset today. That is significantly less than Week 2's $225.80 — and the reason is straightforward. The failure rate spike that drove Week 2 spending had passed. The network stabilized in the days following May 30, failure rates dropped back below the 3% threshold, and the agent responded accordingly. Fewer conditions met. Less intelligence purchased. Less USDC spent.</p><p>This is the property of demand-driven payments that fixed subscription models do not have. A subscription service charges the same amount regardless of what the network is doing. A demand-driven system concentrates spending around periods of elevated activity and scales back when those periods pass. The Week 2 to Week 3 spending ratio — $225.80 to $48.20 — is a direct reflection of network conditions, not a billing cycle.</p><p>The payment architecture decision</p><p>When I built the verification layer for external payments, I had two options for confirming that a developer had sent USDC to the service wallet.</p><p>The first option was Circle's transaction indexing API. Managed, well-documented, and purpose-built for this use case. The problem was latency. On Arc Testnet, Circle's indexing endpoint had a delay of several minutes between a successful on-chain transfer and the transaction appearing in the API response. For a pay-per-query system where a developer sends 0.1 USDC and waits for their credit to unlock, several minutes is an unacceptable experience.</p><p>The second option was Blockscout. Arc Testnet's explorer provides a transaction API that returns confirmation data almost immediately after a transaction is included in a block. The tradeoff is that Blockscout is a third-party dependency rather than Circle's managed infrastructure, but for the current state of Arc Testnet it delivers a substantially better developer experience.</p><p>The result is a two-track verification system. For agent-to-service transfers where both wallets are Circle-managed, the Circle API handles verification cleanly. For any external wallet — MetaMask, Rabby, or programmatic — Blockscout handles verification immediately. Send 0.1 USDC, call the confirm endpoint with the wallet address and transaction hash, receive the credit within seconds. No Circle account required. No SDK. Any EVM wallet on Arc works.</p><p>The friction that still exists</p><p>Two issues in the Circle Developer Wallet setup cost significant debugging time and are worth documenting for any builder attempting the same integration on Arc.</p><p>The first is the feeLevel parameter. Arc Testnet transactions require an explicit fee level — MEDIUM works reliably — but this is not documented specifically for Arc. The Circle API returns a generic parameter validation error with no indication of which parameter is wrong. Debugging from first principles without chain-specific documentation took most of a day.</p><p>The second is the entity public key required for Circle API request signing. The official documentation assumes this key lives in a local file. In a cloud deployment like Railway where the filesystem is ephemeral, storing a multi-line PEM key as a file that gets read on startup is unreliable. The correct approach is storing it as an environment variable with proper newline handling — undocumented in the official Circle guides and another day of debugging to discover.</p><p>Both issues are solvable. Neither represents a fundamental limitation of the payment infrastructure. But for a developer building on Arc for the first time, these are the exact friction points that turn a two-day integration into a four-day one. The payment infrastructure is ahead of the documentation that explains how to use it on Arc specifically.</p><p>What three weeks of spending data reveals</p><p>The pattern across three weeks is the clearest evidence that ArcSense's payment model works as intended.</p><p>Week 1 ($30+): Early operation, network relatively stable, agent learning the rhythm of Arc Testnet activity.</p><p>Week 2 ($225.80): A significant failure rate spike drove heavy autonomous spending. The agent calibrated its response — buying more intelligence as conditions worsened, spending $47.40 in a single 24-hour period at the peak, then continuing at elevated levels until the spike subsided.</p><p>Week 3 ($48.20): Network stabilized. Agent spending dropped back accordingly.</p><p>The $370.20+ total is not a fixed charge. It is the accumulated output of an agent making 3,500+ individual spending decisions across three weeks in response to real on-chain conditions. That is what programmable payments look like when they are working.</p><p>The state of programmable payments on Arc</p><p>Three weeks of real data produces a clear picture. The primitives for programmable payments on Arc are functional. USDC transfers work reliably. On-chain verification via Blockscout is fast enough for real use cases. Autonomous agents can hold wallets, make decisions, and execute payments without human input across thousands of cycles. The payment confirmation flow works from any EVM wallet with no additional infrastructure required.</p><p>What is missing is documentation and observability. The Circle Developer Wallet integration needs a guide covering Arc-specific requirements. The infrastructure for generating artifacts needs equal attention paid to the infrastructure for surfacing them — the weekly report that disappeared into an unreachable filesystem is the clearest illustration of that gap.</p><p>The infrastructure is ahead of the guides. That will change.</p><p>ArcSense will keep running. The agent will keep spending. Edition 3 covers what the first weekly intelligence report that actually makes it to the dashboard reveals about Arc Testnet activity patterns.</p><p>Dashboard: arcsense-lite.vercel.app</p><p>API: arcsense-lite-production.up.railway.app</p><p>GitHub: github.com/2TheMoom/arcsense-lite</p><p>Edition 3 — Saturday June 20, 2026: "Week 4 on Arc — what the first surfaced weekly intelligence report reveals"</p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/d93e8fc57ce184831022bd428f26cb9671e3f4c5e06265449ca00b030a3f6faa.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How Jumper Routes Your Trades:
From Intent to Execution]]></title>
            <link>https://paragraph.com/@olumi/how-jumper-routes-your-trades-from-intent-to-execution</link>
            <guid>8tdceN7JiqrYIaKWcqrp</guid>
            <pubDate>Thu, 04 Jun 2026 08:19:37 GMT</pubDate>
            <description><![CDATA[You pick source and destination. Jumper does everything else. Here is the exact sequence that happens between those two moments. Most DeFi users treat Jumper as a convenience layer — you put in what you have, you get out what you want, and somewhere in between a lot of routing magic happens. This post is about what that magic actually is, because understanding it is how you use the tool better and understand why it produces different results from just picking a bridge manually.Step 1: Definin...]]></description>
            <content:encoded><![CDATA[<p><em>You pick source and destination. Jumper does everything else. Here is the exact sequence that happens between those two moments.</em></p><p>Most DeFi users treat Jumper as a convenience layer — you put in what you have, you get out what you want, and somewhere in between a lot of routing magic happens. This post is about what that magic actually is, because understanding it is how you use the tool better and understand why it produces different results from just picking a bridge manually.</p><h3 id="h-step-1-defining-the-intent" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Step 1: Defining the Intent</strong></h3><p>Everything starts when you specify the source chain and token and the destination chain and token. That is your intent: "I have X on chain A, I want Y on chain B." The routing engine takes it from there. You do not need to know which bridge supports that chain pair, whether a DEX swap is needed before or after bridging, or how to handle token standard differences. The engine resolves all of that.</p><h3 id="h-step-2-simultaneous-querying" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Step 2: Simultaneous Querying</strong></h3><p>The moment you define your intent, the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> routing engine fires simultaneous queries across its full provider set — <strong>30+ bridge protocols</strong> and <strong>40+ DEX aggregators</strong>, plus the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents solver network. This happens in parallel using live on-chain data, oracle feeds, and historical analytics. The result is a complete picture of available routes in milliseconds, not the sequential lookups that made manual bridging so slow.</p><h3 id="h-step-3-route-simulation" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Step 3: Route Simulation</strong></h3><p>The engine does not just collect quotes. It simulates combinations. Bridge A paired with DEX 1. Bridge B with DEX 2. A solver fill that skips the DEX entirely. Multi-hop paths where no direct route is optimal — for example, Polygon to Ethereum via Synapse, then Ethereum to Avalanche via Across, stitched together if that produces a better effective rate than any single bridge.</p><p><em>The routing engine continuously scans integrated bridges and DEXs, simulating multiple combinations of pools and routes before a transaction is submitted on-chain. The quote you see already reflects live network conditions.</em></p><h3 id="h-step-4-scoring-each-route" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Step 4: Scoring Each Route</strong></h3><p>Every simulated route gets scored across four dimensions. <strong>Effective price</strong> — the output amount after all fees and slippage. <strong>Execution time</strong> — bridge finality time plus DEX execution speed. <strong>Gas cost</strong> — on both source and destination chains. <strong>Risk</strong> — protocol uptime history and track record. Jumper surfaces two options from this scoring: best return and fastest. You choose which matters more.</p><h3 id="h-step-5-full-transparency-before-you-confirm" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Step 5: Full Transparency Before You Confirm</strong></h3><p>Before you sign anything, Jumper shows you the full picture: which bridge and DEX will execute, the expected output amount, gas on both chains, bridge finality time, and a per-step fee breakdown. This is the core product. If you are not reading this information, you are not using the aggregator — you are just clicking through it.</p><h3 id="h-step-6-atomic-execution" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Step 6: Atomic Execution</strong></h3><p>Once you confirm, everything executes atomically. Source chain approval, assets locked and routed via the chosen bridge, DEX swap on the destination chain if needed, output token in your wallet. The <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Diamond Contract coordinates all of this. You sign once.</p><h3 id="h-fallback-logic" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Fallback Logic</strong></h3><p>If a provider fails mid-execution, <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s built-in fallback logic automatically re-routes to the next best available path. You do not retry manually. You do not lose funds. This is what "battle-tested infrastructure" means in practice — not that nothing fails, but that failures are handled without user intervention.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/58377a50d517c44e9acfa2e1e9ac9fa2968d36874d931932358872520edb66d7.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABcAAAAgCAIAAAB2N3TiAAAACXBIWXMAAAsTAAALEwEAmpwYAAAHx0lEQVR4nD2Ue2xT1x3HDxTaQelolwySEBKgXQKBhHccCFmICUlaWqquLR2V2jGq0m3SpKnS/p8K0lZtFV2RVqpEha2TIhmMSTAJoZRFUVw7dp3YxI/Yvtc3vu/39eM+fH0TznSDVOmjn47u+d6vztHve36gZrOj69i7u3YOHOs803Xsnc6OM+3tbx7peHtP6ynH4V+1tZ5aC3Y+s3rX+qf2rF/b9iMb1rZtWNNqV5tW8OL2nnfO/PH11z76ZdfZ37z/59OnLvQ639vV3L+9sXvXzoF9B07v2OF86cXeutrO6hfaq6tsNlW1V1c7flbteKHKrtVV7cA/nQ772WiI901mQ/6sf5rw+6jJh4jfj18fvPf7s5f+9MFnH57763+vf+cPI1OBhalgYnI6PjOd+OHhXGQqGpmMBKYTgMppE945rycoclZBhkF/9uawLxImdRVe/afnXOfvPnz944bGnqtXbqcSgss1FZsnZcliSSMwtRDyLRCopIiPQQ4pTj2YfzAe4UhN4q3ZYHZibPbBxByGKFc+v3mw/a2+gfNVVYe/uHwjnRC+9c5+NzG/iOazGeWOJ/hgIpKI0SxlAian03hF5pdFzmKpMomVOcqSWAta8NNL3wCwc+OGQwDs+Pwzl65AnjQLMpQli8hqyaiEZUoMabCkAaicjiSLWEZlSFNgTBzVaNygcd0y4D/+NrzumQNb63tWgeYvLt+QeZhO5EXOkniLxnWOqsjCkiwsM4QBaEJnKZMmjJWzGDiq5RANQ4qmAT+9+J8q0NL4fCcAjZf/PqyIEEkVBMYSOZPEtGy6ROGGLFo0oQOBMa0ytAwbtQD1EjR1qJceQwivXrld96yjaXvvxp+2fz04BiFUC49NHRoqzEtQ5qAm22KBMUEyxoy4/aO3Ah63z+Pyedy+Ebff4/bd8QSuDY1/8sm/L1385uJfrl0fuu/1BH/c9djV7/UERtz+ZIwBg1+OArCtre2N/r4L/X0XnD3nOxzvOp0fnLA539b6xtGO9868/XF39zmH49enXvmDs+d8z/HfdnW+39/3UVPTawBsG7w6CoYG764B+2tre2prT9TWnqirc9bU9GytP7ltW/+WuhObNjvr6nrrt/RurT/Z0NDX0ND3RFZT07Ol7kRNjXMN2D80eBd89a/bADQ8BfYC0AJAy2qwd2utc9PPu1aDvTWbu59b175+1cGG+t7nnnU8DQ7U1zqrq46tAnueiFf+arQdYlHaNTzpcfvcLt9N19RN15TXExy9FXC7pse9oRGP7+bw1Lg37FnZHfOGvaNhtzvgcvncrmm3y+canoxFaSDSZZGFHLUs87Ag220qa1ArQpmHDLHMksuKZHfEUKFpQIXWRUSWEV5nCnnZVi6ZUGJNkMtqE5Ol8YfFSb/KM5Ys2nBUZSqd9iZmaVK3o7XyURSWqThJ+YKsPyBG4gxlMoQhcyt5IXNaJllCUmoqXrTzli4JjMnRJork02kph5ZyqIZlSjxVlgUrh2qJ+XwqUULSWjqej8dFlikzpGGnDk2U0EQpL0IiW16YLyqinT0qW07OFe0nxi2n54uKYAdMEWF6vogmVfvuMmSlsqZBkTNBOsHd8QTGvaFx78wdz/ejbt+4d2ZsNOD1fD/i9k2Mhe6O+kdv+ca8gXvemXHvzMR4aGIseM87c/9e6H/fzt2/90MqwYGvvrwBwPPr1m5vPzTQ63yro/2V5qZjA/1nHe0vO1bWPd1vHj3yaofj1NEjr3YePX3oYL/j8MsHD/Qd2HdyzaoGADYOfnkDXBsaeXp14+ZNbS3Nx1t3O3c1dbU0dx0+OLCn5Xjr7uNNvzi2f+/Jluauva09rbuP72t17muzaWnufmlHx+ZNbT9Zs+3a0AjIZpRIiHgUJv3TGf90OuhHIrOL0TAeDeOPZoloGJ8NovMRMhrGY3ZdnA2ikfDio1kiFiXTCTYepRbRPKBwPR7hIiGSIc2CBHUFYplSJEQtxMRIiBJpSxaWIyEqGRMS8zRNqHoRZpJyNExHw3Q8SlM5VWAsgGdLDydiY6PhdFzKIRpNGEhSiQSpeIR9NMcIjMGQRjRMJaN8NEwuonlZWMrEpUcrLrNBEs8WWapsTykc1aisLtJ22GRhicYrFFahMZPJ2cHhaDOHlnNomSGXBG5Z4JaIXIXETI6uSKylSJC2JyauZZJiNqNkMwqSklJxPpMUF2JCIsqiKZmlLZ6QFSRZwJA8miphqSKGFDKJIoGrklwSxJIg8oRknyWTEBZiQnKeT0TZRJRFUtIiKiNpgcDyigwLvGQQ8RK2oGKJYiZWwhYKqUhFWIRWHpYluKTIFAtYskxjBpooYmk1m1KpnMGuDPonSAIs8HKBo7kcKxA2RVFUJbFSlGBZfqzL0JRligcMaTCEPbSJrCbSpiwsSYKlSI+fIIu2iy7RBY7LM4wqsrrEWSURVhRoyrAsQ0uWSd6+EYUbBKLhqEZiusRb9iPmLZGzkfglmZaLNKHQtEJRCkVJJJVnmEpeMBXeVPhKnhdIAbBUmSZ0hrI7iiHqIlpMp+VsukjmNDqrZOIKjmosoSIpGcsUcKRAE1oOyWPpPI2rNK5SuMpSBlhEJda20BhSo3CNJjQ8W8ohtgtLqItogcRUitAxpJhDSwSmUrhO5tSVha2ncB1DpP8D7R8UimetHcQAAAAASUVORK5CYII=" nextheight="2084" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p>In February 2026, Jumper shipped an upgraded routing engine that now continuously scans providers and pre-simulates route combinations before you confirm. The quote you see already reflects live network conditions at the moment of execution. This closed the gap between what the quote shows and what actually executes — a meaningful improvement for larger trades where slippage on the quote matters.</p><p>Next week: the connector post — <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> is the engine, Jumper is the car, and why that distinction matters for everyone building or using cross-chain infrastructure.</p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/c6784060ecd7f18f9bf15907b8ccaf3065d9e4b7ff3a28f347a6e12418564efa.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[CLOB vs AMM: Why Dango Chose the Harder Path]]></title>
            <link>https://paragraph.com/@olumi/clob-vs-amm-why-dango-chose-the-harder-path</link>
            <guid>Mwe31qLfBpW8BZO9w5dI</guid>
            <pubDate>Mon, 01 Jun 2026 07:46:45 GMT</pubDate>
            <description><![CDATA[The Default Choice and Why It ExistsEvery DeFi protocol launched in the last five years has started with an AMM. Not because the AMM is the best trading mechanism for every use case, but because it is the most practical one for a chain where you have no control over block times, no protocol-level automation, and no guarantee that your contract will execute at the end of every block. AMMs are the rational response to the EVM's constraints. You cannot run a real-time matching engine on a chain ...]]></description>
            <content:encoded><![CDATA[<h2 id="h-the-default-choice-and-why-it-exists" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Default Choice and Why It Exists</h2><p>Every DeFi protocol launched in the last five years has started with an AMM. Not because the AMM is the best trading mechanism for every use case, but because it is the most practical one for a chain where you have no control over block times, no protocol-level automation, and no guarantee that your contract will execute at the end of every block.</p><p>AMMs are the rational response to the EVM's constraints. You cannot run a real-time matching engine on a chain with 12-second block times and unpredictable gas costs. You cannot guarantee that orders will be matched at specific prices when MEV bots can reorder transactions in a mempool. The constant product formula, x times y equals k, is not elegant because it is mathematically beautiful. It is dominant because it works within the limits of the environment it was built for.</p><p>Dango chose not to build in that environment. It built its own chain with its own execution environment specifically so it could make a different choice: a fully on-chain Central Limit Order Book with periodic batch auctions. Understanding why that choice is significant requires understanding what is actually wrong with AMMs, what a CLOB offers, and what it takes to run one on-chain.</p><hr><h2 id="h-what-amms-get-right-and-what-they-get-fundamentally-wrong" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What AMMs Get Right and What They Get Fundamentally Wrong</h2><p>The AMM innovation deserves genuine credit. Before Uniswap, on-chain trading on Ethereum was essentially unusable. Order books on EVM chains required gas fees for every order placement and cancellation, making market making economically irrational. The constant product formula solved this by eliminating the order book entirely: liquidity is deposited into a pool, prices are determined algorithmically, and trades execute against the pool rather than against other traders. No order management. No matching engine. No gas cost for passive liquidity.</p><p>This worked well enough that Uniswap became one of the most used protocols in crypto. But the same architecture that made AMMs viable on EVM creates three problems that are structural, not incidental.</p><h3 id="h-impermanent-loss-is-a-tax-on-liquidity-providers" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Impermanent Loss is a Tax on Liquidity Providers</h3><p>When a liquidity provider deposits tokens into an AMM pool, they receive a proportional share of the pool. If the price of one token changes relative to the other, the pool's constant product formula automatically rebalances. This rebalancing means that when a token's price rises, the pool sells some of it to maintain the formula. When prices fall, the pool buys more.</p><p>The result is that liquidity providers systematically end up holding more of the underperforming token and less of the outperforming one. This divergence between the value of the LP position and the value of simply holding the tokens is impermanent loss. It is called impermanent because if prices return to their original ratio the loss disappears, but in practice prices rarely return exactly, and LPs who exit after significant price movement often find their fees earned were more than offset by the structural loss.</p><p>Research published in 2022 found that more than 50% of Uniswap v3 LPs were losing money after accounting for impermanent loss. The concentrated liquidity mechanism in v3 improved capital efficiency but made impermanent loss more severe for LPs caught outside their range. Curve's stablecoin AMM reduced impermanent loss by focusing on assets that should trade at parity, but this trades off the flexibility to handle volatile asset pairs.</p><p>No version of the constant product formula eliminates impermanent loss. It is a mathematical consequence of how AMMs price assets. The only way to eliminate it is to not use an AMM.</p><h3 id="h-slippage-increases-nonlinearly-with-trade-size" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Slippage Increases Nonlinearly with Trade Size</h3><p>AMMs price assets based on the ratio of tokens in the pool. Every trade moves the ratio and therefore moves the price. The larger the trade relative to pool depth, the more the price moves per unit of asset traded. This slippage is not a quirk that better implementation can fix. It is the mechanism by which the AMM prices liquidity provision: if large trades were costless, there would be no incentive for LPs to provide deep liquidity.</p><p>For small retail trades, slippage on well-capitalized pools is negligible. For large traders, institutional users, or protocols routing significant volume, slippage becomes a meaningful cost. A $10 million swap on a $50 million Uniswap pool will move the price by approximately 16.7% before fees. No professional trading desk would accept that execution quality.</p><p>This is why most serious trading volume in DeFi does not happen on AMMs directly. It happens through aggregators that route across multiple pools, split orders, and find the path of least slippage resistance. The aggregator layer exists precisely because individual AMMs cannot handle large orders efficiently.</p><h3 id="h-mev-attacks-are-enabled-by-design" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">MEV Attacks Are Enabled by Design</h3><p>The AMM's predictable pricing formula, combined with the EVM's public mempool, creates a systematic extraction mechanism for MEV bots. Because every AMM trade's price impact is calculable from the pool state, bots can observe pending transactions in the mempool and execute sandwich attacks: place a buy order before a large pending buy to push the price up, let the victim trade at the inflated price, then sell immediately after for a profit.</p><p>The victim pays more than they should. The MEV bot extracts the difference. The liquidity provider receives fees but also absorbs some of the adverse selection. Every participant in the AMM system except the MEV bot is made worse off by this dynamic.</p><p>MEV extraction on Ethereum alone has exceeded $1 billion in cumulative value since 2020. Various solutions have been proposed: private mempools, MEV auctions, intent-based trading. None of them eliminate the fundamental issue, which is that AMM pricing is deterministic and observable before execution.</p><hr><h2 id="h-what-a-clob-actually-provides" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What a CLOB Actually Provides</h2><p>A Central Limit Order Book is how every major financial exchange in the world operates. The New York Stock Exchange, Nasdaq, Binance, Coinbase: all of them use CLOBs. The mechanism is straightforward: buyers submit bids at specific prices, sellers submit asks at specific prices, and the matching engine pairs overlapping orders on a price-time priority basis.</p><p>The key properties that make a CLOB preferable for serious trading:</p><p><strong>Traders set their own prices.</strong> In an AMM, the price you receive is determined by the pool formula and the size of your trade. In a CLOB, you submit a limit order at the exact price you want. If the market moves to your price, you get it. If it does not, your order sits in the book. You have explicit price control, not statistical exposure to slippage.</p><p><strong>Market makers earn the spread without impermanent loss.</strong> In an AMM, providing liquidity exposes you to the constant product formula's rebalancing. In a CLOB, a market maker places buy orders slightly below the market price and sell orders slightly above it, earning the spread on matched trades. There is no automatic rebalancing, no impermanent loss, and no algorithmic selling of appreciating assets.</p><p><strong>Transparent price discovery.</strong> The order book shows you the full depth of supply and demand at every price level. You can see exactly where liquidity exists, how large orders are, and what the market believes the fair price is. This information is not available in an AMM, where you can only calculate the effective price from the pool ratio and your trade size.</p><p><strong>Precise execution for large orders.</strong> A large limit order in a CLOB sits at a specific price until it is filled. It does not create slippage by moving through the price curve. It waits for matching supply or demand at the stated price. This is how institutional trading works in every other market.</p><hr><h2 id="h-why-on-chain-clobs-were-previously-impossible" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why On-Chain CLOBs Were Previously Impossible</h2><p>If CLOBs are superior for trading, why did DeFi default to AMMs? Because building a CLOB on Ethereum or most other general-purpose chains is impractical.</p><p>A real-time CLOB requires the ability to place, cancel, and modify orders continuously at near-zero cost. On Ethereum, every state change costs gas. Placing an order costs gas. Cancelling it costs gas. Matching it costs gas. A market maker actively managing a book of hundreds of orders would spend more on gas fees than they could ever earn from spreads.</p><p>A CLOB also requires fast, predictable execution. Traders need to know their orders will be matched within a defined time window. Ethereum's 12-second block times and variable gas pricing make this impossible. An order submitted at a specific price might sit in the mempool for minutes, during which the market has moved and the order is now at a disadvantaged price.</p><p>Finally, a CLOB is vulnerable to MEV on chains with public mempools. Front-running order book trades is simpler than sandwich attacking AMM swaps: observe a large buy order in the mempool and insert a buy ahead of it. This problem does not exist on chains with instant finality and no mempool in the traditional sense.</p><hr><h2 id="h-how-dango-solves-each-of-these-problems" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How Dango Solves Each of These Problems</h2><p>Dango's CLOB is built on its own sovereign chain specifically to address each limitation:</p><h3 id="h-batch-auctions-eliminate-mev" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Batch Auctions Eliminate MEV</h3><p>Rather than matching orders continuously and individually, Dango's CLOB processes orders in periodic batch auctions every 0.2 to 0.5 seconds. All orders submitted within a batch are collected, and the matching engine finds the single clearing price that maximizes the volume of trades executed.</p><p>This design eliminates front-running and sandwich attacks entirely. Since all orders in a batch execute at the same price, there is nothing to front-run. An MEV bot that observes orders in a batch cannot profit by inserting its own order to move the price ahead of them: all orders in the same batch clear at the same clearing price. The batch mechanism means that submitting an order slightly ahead of another does not give any price advantage.</p><p>Dango's on-chain CLOB with periodic batch auctions eliminates both slippage and MEV.</p><h3 id="h-protocol-native-cronjobs-enable-real-time-matching" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Protocol-Native Cronjobs Enable Real-Time Matching</h3><p>Dango's Grug execution environment includes BeginBlock and EndBlock hooks. The order matching engine runs at the end of every block, automatically, without any external trigger. There are no bot networks, no off-chain relayers, no infrastructure that needs to stay online for the matching to work. The chain itself runs the matching engine as part of consensus.</p><p>This is only possible on a chain that was designed for it. On EVM, there is no mechanism for a contract to trigger its own execution at end of block. On Dango, this is a core feature of the execution environment.</p><h3 id="h-unified-margin-across-all-products" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Unified Margin Across All Products</h3><p>Dango's CLOB is not just a spot order book. It is integrated with perpetuals trading and lending under a single unified margin account. A trader can use the same collateral to simultaneously hold a spot position, an open perp, and a lending position. When a spot order fills, the collateral accounting updates instantly across all positions.</p><p>This is impossible to build cleanly on EVM without coordinating state across multiple separate protocols, each with their own risk models and liquidation logic. On Dango, the unified margin account is a protocol-level primitive, not a complex integration built on top of independently deployed contracts.</p><h3 id="h-passive-vaults-for-non-traders" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Passive Vaults for Non-Traders</h3><p>Recognizing that not every user wants to actively manage a CLOB order book, Dango also offers passive market-making vaults. Users who prefer the AMM experience of depositing and earning fees can do so through vaults that algorithmically place and manage CLOB orders on their behalf. The vault earns trading fees and shares them with depositors.</p><p>This gives retail users the simplicity of AMM liquidity provision while the underlying mechanism is still a CLOB. The slippage, impermanent loss, and MEV problems are handled at the protocol level rather than being passed to passive users.</p><hr><h2 id="h-the-honest-trade-offs" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Honest Trade-offs</h2><p>Dango's CLOB is significantly more complex to build and maintain than an AMM. Smart contract order books require careful gas optimization, complex matching logic, and robust handling of edge cases around partial fills, order expiry, and liquidations. The unified margin system adds substantial additional complexity around collateral accounting.</p><p>The CLOB also depends on market makers. AMMs work without any active participation beyond initial liquidity deposits. A CLOB with no market makers is just a list of unmatched orders with wide spreads. Dango needs to attract professional market makers to provide competitive two-sided liquidity, which requires both the tooling for them to operate efficiently and economic incentives sufficient to attract them over existing venues.</p><p>Dango's fully on-chain CLOB launched in Testnet 2 on July 28, 2025, inviting daily trades with a $1M daily trading volume goal and with trades settling via periodic auctions every 0.2 to 0.5 seconds.</p><p>The passive vaults partially address the market maker dependency by algorithmically providing liquidity, but a deep and efficient CLOB ultimately depends on professional participation.</p><hr><h2 id="h-why-this-matters-for-dangos-thesis" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why This Matters for Dango's Thesis</h2><p>Dango's core product claim is that it can deliver a trading experience comparable to a centralized exchange while remaining fully on-chain. That claim is impossible to fulfill with an AMM. Centralized exchanges use CLOBs. Professional traders use CLOBs. Price discovery happens on CLOBs.</p><p>The AMM was DeFi's workaround for the EVM's limitations. Dango removed those limitations by building its own chain. Having done so, defaulting to an AMM would be the equivalent of building a custom racetrack and then running a bus on it.</p><p>The CLOB is not the harder choice for Dango. Given what they built, it is the only choice that makes the rest of their product thesis coherent.</p><br><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/17cfe1fb7d3fd71aa1210746eda42ce65a0f7fdeb82c3b9b574384b9fccff5b8.png" blurdataurl="data:image/png;base64,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" nextheight="2398" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><hr><p><em>Part 4 of a research series on Dango's technical architecture. Part 1 covered Hyperlane vs LayerZero, Wormhole, and Axelar. Part 2 covered ERC-4337 vs Dango Smart Accounts. Part 3 covered Grug vs EVM vs SVM. Part 5 will cover why modular stacks still leak sovereignty.</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/01221e6bdf97f849c2c802d357c3b758de0bab14e3e235d6e0fbc8892e7ab726.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[The LI.FI Product Stack:
Seven Layers, One Integration]]></title>
            <link>https://paragraph.com/@olumi/the-lifi-product-stack-seven-layers-one-integration</link>
            <guid>ylMPMF9QtM6X2WtqOPjO</guid>
            <pubDate>Thu, 28 May 2026 09:34:11 GMT</pubDate>
            <description><![CDATA[Just Shipped · May 26, 2026 LI.FI launched LI.FI Intents two days ago — a modular full-stack execution engine built on the Open Intents Framework (OIF), led by the Ethereum Foundation. This post has been updated to reflect it. When most people encounter LI.FI, they see a swap interface or a bridge aggregator. That is the top of the stack. What sits underneath is a seven-layer architecture, each layer doing a distinct job, and together making it possible to move, swap, stake, and deploy assets...]]></description>
            <content:encoded><![CDATA[<p><strong>Just Shipped &nbsp;·&nbsp; May 26, 2026</strong></p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> launched <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Intents</strong> two days ago — a modular full-stack execution engine built on the Open Intents Framework (OIF), led by the Ethereum Foundation. This post has been updated to reflect it.</p><p>When most people encounter <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>, they see a swap interface or a bridge aggregator. That is the top of the stack. What sits underneath is a seven-layer architecture, each layer doing a distinct job, and together making it possible to move, swap, stake, and deploy assets across any chain in a single step.</p><p>Understanding each layer is how you understand why <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> is structurally difficult to compete with. You cannot replicate one layer and call it done.</p><h3 id="h-layer-1-the-embeddable-widget" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Layer 1: The Embeddable Widget</strong></h3><p>The Widget is the surface layer — a plug-and-play swap and bridge interface any application can embed. Works with React, Next.js, Vue, and Svelte. Fully customisable: layout, branding, wallet handling, and feature flags. Most users who interact with <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>-powered infrastructure are using the Widget without knowing it. The infrastructure is invisible. That is by design.</p><h3 id="h-layer-2-the-orchestration-layer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Layer 2: The Orchestration Layer</strong></h3><p>The Orchestration Layer is the brain. It knows where assets are across every supported chain, what they cost, and what yields are available. When a request comes in, it finds the optimal route and combines multiple steps into a single transaction where possible. This is what makes one-click cross-chain actions work at scale.</p><h3 id="h-layer-3-lifi-composer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Layer 3: </strong><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Composer</strong></h3><p><strong>Composer</strong> goes beyond bridging and swapping. It enables programmable multi-step flows: bridge into a yield vault, stake into a protocol, chain multiple cross-chain actions — all in one transaction. Bridge → swap → stake → deposit. One confirm. Cross-chain composability at the infrastructure level, not the application level.</p><p><em>The </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><em>LI.FI</em></a><em> Composer turns multi-step DeFi workflows into single transactions. The complexity lives at the infrastructure layer. The user sees one confirm.</em></p><h3 id="h-layer-4-the-aggregation-layer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Layer 4: The Aggregation Layer</strong></h3><p>The most comprehensive meta-level aggregation in the market. Connects to 29+ bridges and 33+ DEXs across 60+ networks. Users get the best price without knowing which protocol executes. Wrapped token variants, non-EVM differences, canonical token mapping — handled automatically in the background.</p><h3 id="h-layer-5-lifi-intents-live-may-26" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Layer 5: </strong><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Intents &nbsp;LIVE MAY 26</strong></h3><p>This is the layer that just shipped. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Intents</strong> is a modular, full-stack execution engine that fulfills orders through a network of professional solvers competing to provide the best execution. It is built on the reference contracts of the <strong>Open Intents Framework (OIF)</strong> — a public-good initiative led by the Ethereum Foundation, with contributors including <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>, OpenZeppelin, Uniswap Labs, Hyperlane, and 30+ other teams.</p><p>The core problem it solves: intent stacks have historically been too rigid, forcing every application into a single shared execution model. Real-world assets are a clear example — RWA flows need permissioned solvers who can market-make those tokens directly. Generic solver sets cannot fill them. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents fixes this by making the stack modular and configurable at every layer.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><em>LI.FI</em></a><em> Intents is the OIF in production, at scale. Over $80B in volume, 100M+ transfers, and 1000+ integrations available to OIF-compatible solvers from day one.</em></p><p>What makes this significant beyond the technology: it is the orderflow. A solver who integrates the OIF integrates one of the largest orderflow sources in crypto immediately. The flywheel — orderflow attracts solvers, solver competition tightens prices, better prices attract more orderflow — now starts spinning at scale for an open standard.</p><h3 id="h-layers-6-and-7-lifis-own-products" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Layers 6 and 7: </strong><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong>'s Own Products</strong></h3><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Pioneer</strong> is <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s own solver. It guarantees execution even when third-party solvers cannot fill, and helps institutions launch and distribute tokenised assets — RWAs and stablecoins — across <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s network. With <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents now live, Pioneer is one of the first production solvers operating on the OIF stack.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Fly</strong> is a DEX aggregator built specifically for new and emerging chains. Day-one best-price swaps, instant access to competitive liquidity including private market makers.</p><h3 id="h-why-the-architecture-matters" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Why the Architecture Matters</strong></h3><p>The layered design means each component is independently useful. Together they create a full infrastructure stack from UI to execution that no single protocol can replicate by adding one feature. And with <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> Intents now live on an open standard, the stack is no longer just <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s to build on — it is the industry's.</p><br><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/6e2edd47e19ef91134efc67504eaea4350c9160aeaa980069a8a6c48d6a6b7bc.png" blurdataurl="data:image/png;base64,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" nextheight="1038" nextwidth="1223" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><br><p><s><u>Next week: Jumper's routing engine — how the consumer-facing product uses this stack to route your trades from the moment you hit swap.</u></s></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/4f3b9d03ca848d53241977d9b5422494c611396950c0d51b294dc998c1b61488.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Grug vs EVM vs SVM: Why Dango Built Its Own Execution Environment]]></title>
            <link>https://paragraph.com/@olumi/grug-vs-evm-vs-svm-why-dango-built-its-own-execution-environment</link>
            <guid>z3tphrIKJ5fduWAE2UdM</guid>
            <pubDate>Mon, 25 May 2026 08:17:48 GMT</pubDate>
            <description><![CDATA[The Question Nobody Was AskingEvery major blockchain argument in the last five years has been about speed. Ethereum is too slow. Solana is fast but centralized. Move is fast and safe. The benchmark war is real, the TPS numbers get bigger every year, and the underlying question is always the same: who is fastest? Dango did not join that race. Instead, Left Curve Software built an entirely new execution environment called Grug, and their stated competitive advantage is not speed. It is features...]]></description>
            <content:encoded><![CDATA[<figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/7a0801b4b5fb5498a483fe4fb98ce51c6be3016ad367929f6a426e1cd2c61ada.png" blurdataurl="data:image/png;base64,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" nextheight="2064" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><h1 id="h-" class="text-4xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"></h1><h2 id="h-the-question-nobody-was-asking" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Question Nobody Was Asking</h2><p>Every major blockchain argument in the last five years has been about speed. Ethereum is too slow. Solana is fast but centralized. Move is fast and safe. The benchmark war is real, the TPS numbers get bigger every year, and the underlying question is always the same: who is fastest?</p><p>Dango did not join that race. Instead, Left Curve Software built an entirely new execution environment called Grug, and their stated competitive advantage is not speed. It is features.</p><p>That is a genuinely unusual position to take. To understand why it makes sense, you have to understand what the existing execution environments actually get wrong, and what features they are missing that make certain classes of DeFi applications difficult or impossible to build cleanly on top of them.</p><hr><h2 id="h-what-an-execution-environment-actually-does" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What an Execution Environment Actually Does</h2><p>Before comparing them, it helps to be precise about what an execution environment is. It is the layer of a blockchain that determines how smart contracts are written, how they are executed, what they can and cannot do, how gas is calculated, how tokens are represented, and how state is stored and accessed.</p><p>The execution environment is not the consensus layer. It does not decide which transactions get included in a block or how validators are selected. It decides what happens once a transaction is included: what code runs, how it runs, and what the result is.</p><p>This distinction matters because most blockchain debates conflate the two. When people say Solana is fast, they mean its consensus architecture processes transactions in parallel at high throughput. The SVM itself, as an execution environment, is a different question. When people say EVM is slow, they largely mean Ethereum's single-threaded processing model and gas pricing, not just the EVM spec itself.</p><p>Grug sits at this execution layer. It is an alternative to the EVM, SVM, Move VM, and CosmWasm for what happens when a transaction runs. It uses CometBFT for consensus, the same battle-tested BFT consensus used across the Cosmos ecosystem.</p><hr><h2 id="h-the-evm-battle-tested-but-carrying-decade-old-debt" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The EVM: Battle-Tested, But Carrying Decade-Old Debt</h2><p>The EVM is the most deployed execution environment in existence. Ethereum, Arbitrum, Base, Optimism, Polygon, Avalanche, BSC, and dozens of other chains all run the EVM or close variants of it. This network effect is genuine and not trivial. Every security audit, every dev tool, every library written for the EVM is available to any chain that runs it.</p><p>But the EVM was designed in 2014 and 2015 for a world that did not yet have DeFi. It has accumulated a decade of design debt that cannot be fixed without breaking every application built on top of it. The most consequential problems:</p><h3 id="h-reentrancy-is-structurally-possible" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Reentrancy is structurally possible</h3><p>The EVM is single-threaded. When a contract makes an external call to another contract, execution flow transfers entirely to the callee before returning. If the callee is malicious or calls back into the original contract before its state updates have been committed, it can manipulate the original contract's state in ways the developer did not intend.</p><p>This is not a theoretical problem. The DAO hack in 2016 drained $60 million through a reentrancy attack. Since then, reentrancy has been responsible for hundreds of millions in additional losses across DeFi. Developers must manually guard against it using patterns like Checks-Effects-Interactions and OpenZeppelin's ReentrancyGuard. The EVM itself does nothing to prevent it. It is a structural property of how external calls work, and it cannot be removed without rewriting the EVM from scratch.</p><h3 id="h-erc-20-is-a-genuinely-terrible-token-standard" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">ERC-20 is a genuinely terrible token standard</h3><p>This is not a matter of opinion. Larry0x's whitepaper on Grug dedicates substantial space to this point, and the criticisms are specific and technical. You can only transfer one token per transaction. You cannot send tokens to a contract and atomically call a method on that contract in the same operation without workarounds. The approval mechanism, invented to solve the previous problem, creates massive security risks: infinite approvals mean a single protocol exploit can drain every user who ever approved that protocol. If you send tokens to a contract that does not support them, they are lost forever. Given any account, you cannot enumerate the ERC-20 tokens it holds without parsing the entire contract deployment history from an archive node.</p><p>Every major DeFi application has built workarounds for one or more of these limitations. Those workarounds add complexity, gas cost, and attack surface. The EVM cannot fix ERC-20 without breaking thousands of deployed contracts.</p><h3 id="h-gas-is-a-hard-fork-problem" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Gas is a hard fork problem</h3><p>If you want to change how gas is priced on an EVM chain, you need to modify the core protocol and coordinate a hard fork with all validators. This is not a fast or flexible process. The EIP-1559 transition, which changed Ethereum's gas mechanism from a first-price auction to a base fee model, took years of debate, multiple EIPs, and a coordinated upgrade involving the entire Ethereum ecosystem.</p><p>If a developer wants to build a chain where gas is priced differently for different transaction types, or where gas fees are waived for users who hold certain tokens, or where fees go to a protocol treasury rather than being burned, they have to fork the EVM at the protocol level. Most teams do not have the resources or risk tolerance to do that.</p><h3 id="h-calldata-is-solidity-abi-encoded-and-opaque" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Calldata is Solidity ABI-encoded and opaque</h3><p>When you call a contract on the EVM, the arguments are encoded in Solidity's ABI format. This is compact and efficient but not human-readable. Debugging a failed transaction means decoding binary calldata. Building tooling on top of it means implementing ABI decoding in every language and framework you want to support.</p><hr><h2 id="h-the-svm-fast-but-evms-problems-run-deeper-than-speed" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The SVM: Fast, but EVM's Problems Run Deeper Than Speed</h2><p>Solana's Virtual Machine takes a completely different architectural approach to the EVM. Rather than single-threaded execution, Sealevel, Solana's runtime, processes transactions in parallel across multiple cores. Transactions that do not touch the same accounts can execute simultaneously, which is why Solana's throughput numbers are so dramatically higher than Ethereum's.</p><p>This is a genuine and important innovation. For applications that need to process enormous volumes of transactions quickly, like high-frequency trading or real-time gaming, the SVM's parallel execution model is compelling. Solana has proven it can sustain real load at scale, something no EVM chain has matched without rollups.</p><p>But the SVM inherits or creates its own set of limitations for DeFi builders:</p><p><strong>Account model complexity.</strong> Solana's account model, where programs and state are stored in separate accounts, is genuinely difficult to reason about. Developers must pre-declare every account a transaction will touch, which makes certain patterns of dynamic interaction between contracts significantly more complex to implement correctly. The bugs in early Solana DeFi protocols were frequently account model errors, not logic errors.</p><p><strong>Rust is required but the programming model is constrained.</strong> Solana programs are written in Rust but target a non-standard runtime with specific restrictions. The Solana programming model is not the same as writing general Rust. Developers accustomed to standard Rust often find the constraints of the SVM's execution context unintuitive.</p><p><strong>No smart accounts natively.</strong> Like the EVM, the SVM does not have a native smart account system. Authentication is handled by keypairs. Account abstraction on Solana requires workarounds that are not as clean as a protocol-level solution.</p><p><strong>Cronjobs require off-chain bots.</strong> Just like the EVM, programs on Solana cannot trigger their own execution. Actions must be initiated by transactions. For applications that need recurring, automated execution, like a perpetuals protocol that updates funding rates each block, developers must maintain an off-chain bot network.</p><hr><h2 id="h-grug-not-fastest-but-most-features" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Grug: Not Fastest, but Most Features</h2><p>The Grug whitepaper opens with unusual candor: Grug is much faster than single-threaded EVM, but probably not as fast as SVM or Move. Left Curve does not attempt to claim the speed crown. Instead, the thesis is that there are DeFi applications that are difficult to build on EVM, SVM, or Move because those environments lack features those applications need.</p><p>Here is what Grug actually provides that the other environments do not:</p><h3 id="h-smart-accounts-are-native-not-a-workaround" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Smart accounts are native, not a workaround</h3><p>Grug ships with a complete smart account system from launch. Any account on Grug can be a smart contract that defines its own authentication logic: Passkeys, one-time passwords, two-factor authentication, multisig, whatever the developer implements. This is not ERC-4337 bolted onto an existing account model. It is the account model.</p><p>This is the foundation for everything Dango's UX promises: no seed phrases, no browser extensions, Face ID authentication, key rotation. None of it would be possible without a native smart account system at the execution environment level.</p><p>Larry0x built the first smart account implementation in the Cosmos ecosystem, used by Xion to onboard 100,000 users processing 1,100 TPS. Grug's version is a direct evolution of that work.</p><h3 id="h-gas-is-a-smart-contract-not-a-protocol-constant" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Gas is a smart contract, not a protocol constant</h3><p>In Grug, gas fees are managed by a smart contract called the taxman. After every transaction, taxman is called with a report of what the transaction did and how much gas it consumed. Developers can implement any logic: burn the fee, distribute to stakers, discount for holders of a certain NFT, hold the fee for a limit order and refund if the order is cancelled.</p><p>Changing the fee mechanism requires migrating a contract, not hard forking the chain. This is the design principle that runs through all of Grug: if developers might want to customize something, abstract it into a smart contract. If they will never want to customize it, make it native Rust code.</p><h3 id="h-cronjobs-are-protocol-native" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Cronjobs are protocol-native</h3><p>Grug gives smart contracts access to BeginBlock and EndBlock hooks, borrowed from Cosmos SDK. Code in these hooks runs automatically at the start or end of every block without any transaction being submitted.</p><p>For a DeFi chain, this is not an academic feature. A perpetuals protocol needs to update funding rates regularly. An order book DEX needs to match orders at the end of each block. A DCA service needs to execute user orders on schedule. On EVM and SVM, all of these require bot networks: off-chain infrastructure that monitors the chain, submits transactions at the right time, competes with other bots, and fails under network congestion. On Grug, the protocol itself handles it.</p><h3 id="h-reentrancy-is-impossible-by-design" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Reentrancy is impossible by design</h3><p>Grug follows CosmWasm's message-passing model for cross-contract calls. Rather than transferring execution control directly from one contract to another mid-execution, contracts communicate by dispatching messages. The calling contract's execution completes before the callee's execution begins. This makes the classic reentrancy attack structurally impossible without any developer intervention.</p><p>This is not a guard or a pattern that developers must remember to apply. It is a consequence of how the execution model works. Developers building on Grug cannot accidentally create reentrancy vulnerabilities the way EVM developers can.</p><h3 id="h-a-unified-token-standard" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">A unified token standard</h3><p>Grug's native token standard fixes the core problems with ERC-20. You can transfer multiple tokens in a single transaction. You can send tokens to a contract and atomically call a method in the same operation. There is no approval mechanism with its associated security risks. Tokens sent to contracts that do not support them are not silently lost. Fungible tokens and NFTs share a single unified standard.</p><p>None of this requires a new language. Grug contracts are written in standard Rust and compiled to WebAssembly. Developers get the Rust ecosystem, Rust's type system, the WebAssembly performance benefits, and a Wasmer JIT runtime that benchmarks at 10-100x cheaper computation than single-threaded EVM.</p><h3 id="h-human-readable-calldata" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Human-readable calldata</h3><p>Contract calls in Grug use JSON for calldata. This is not as compact as Solidity ABI encoding, but it is human-readable. Debugging a failed transaction means reading a JSON object. Building tooling means parsing JSON, which every language and framework already does well.</p><hr><h2 id="h-the-real-comparison" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Real Comparison</h2><p>The honest framing of Grug versus EVM versus SVM is not about raw performance. It is about what class of applications each execution environment makes easy to build versus what it forces developers to work around.</p><p>EVM makes it easy to deploy on any of dozens of chains and reach the largest developer community in crypto. It makes it hard to build secure token standards, native smart accounts, protocol-level automation, and customizable fee mechanisms without significant workarounds or hard forks.</p><p>SVM makes it easy to build high-throughput applications where parallel execution matters. It makes it harder to reason about the account model and does not provide native smart accounts or cronjobs.</p><p>Grug makes it easy to build DeFi applications that need native smart accounts, automated on-chain execution, customizable fees, a clean token standard, and structural reentrancy safety. It gives up the network effects of EVM and the raw throughput ceiling of SVM. Whether that trade is worth it depends entirely on what you are building.</p><p>For a chain whose core product is a DeFi hub with margin accounts, a unified account identity system, and an order book, the Grug trade looks like the right one.</p><hr><h2 id="h-the-trade-offs" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Trade-offs</h2><p>Grug is young. The EVM has a decade of audits, tooling, and developer familiarity behind it. The SVM has years of performance optimization and a large developer community. Grug's Rust-and-Wasm stack is new enough that the developer tooling, documentation, and third-party library ecosystem are still maturing.</p><p>The security of Grug's design has also not been tested at the scale or over the time horizon that EVM security has. Structural reentrancy prevention and message-passing semantics are strong arguments, but they are arguments from design, not from a ten-year adversarial track record.</p><p>These are real costs. They are the expected costs of being early. The question is whether the features Grug unlocks are important enough to justify building on something new rather than inheriting the network effects of something established.</p><p>For Dango, which is building something that literally cannot be built cleanly on EVM or SVM without fundamental compromises to the user experience they are targeting, the answer is clearly yes.</p><hr><p><em>Part 3 of a research series on Dango's technical architecture. Part 1 covered why Dango chose Hyperlane over LayerZero, Wormhole, and Axelar. Part 2 covered why ERC-4337 is a patch job and what Dango's account model does differently. Part 4 will cover Dango's CLOB versus AMM design on a sovereign L1.</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/4accfe9ba7b8358ce3775ab252c55e80f03f4880465e2b687f5167a159be1050.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How I built an autonomous agent that pays for intelligence on Arc Testnet]]></title>
            <link>https://paragraph.com/@olumi/how-i-built-an-autonomous-agent-that-pays-for-intelligence-on-arc-testnet</link>
            <guid>UqWnkCnK60U7eZ2TT4xY</guid>
            <pubDate>Sat, 23 May 2026 12:44:23 GMT</pubDate>
            <description><![CDATA[How I built an autonomous agent that pays for intelligence on Arc Testnet By Abu Olumi — Edition 1 of Building on ArcIt started as a simple monitor. I wanted to know which contracts were failing on Arc Testnet, how often, and whether the failure patterns were random or systemic. So I built a block scanner in TypeScript using ethers.js v6 that connected to Arc's RPC, scanned every block in real time, detected failed transactions, and classified contract behavior across multiple blocks; not jus...]]></description>
            <content:encoded><![CDATA[<p><strong>How I built an autonomous agent that pays for intelligence on Arc Testnet</strong></p><p><em>By Abu Olumi — Edition 1 of Building on Arc</em></p><hr><p>It started as a simple monitor. I wanted to know which contracts were failing on Arc Testnet, how often, and whether the failure patterns were random or systemic. So I built a block scanner in TypeScript using ethers.js v6 that connected to Arc's RPC, scanned every block in real time, detected failed transactions, and classified contract behavior across multiple blocks; not just within a single block. A contract that fails once is noise. A contract that appears in 50 consecutive blocks with a 6% failure rate is a signal. That distinction became the foundation of ArcSense.</p><p>The dashboard came first. A live block feed, a failure rate chart covering the last 30 blocks, a contract intelligence panel that ranked failing contracts by accumulated failures and classified them as HIGH FREQUENCY FAILER, REPEAT OFFENDER, RECURRING PATTERN, NEW FAILURE, or OCCASIONAL FAILURE; all derived purely from on-chain data. It worked. It was useful. But it wasn't interesting enough.</p><p>The question that changed the direction was simple: what if the intelligence this system generates could be sold? Not displayed on a dashboard for humans to read, but priced as a service that developers and autonomous agents could purchase programmatically on-chain. That reframing turned a monitoring tool into infrastructure.</p><p>Building the pay-per-query API was straightforward in concept but required careful design in practice. I needed a gate that was permissive enough to be accessible to any developer but strict enough to enforce payment after the free tier. The solution was a wallet-level credit system tracked in a JSON store on disk. Every wallet gets 5 free queries. After that, a confirmed USDC payment adds 1 credit consumed automatically on the next request. The gate checks for free queries first, then paid credits, then requests payment if neither is available. The API returns step-by-step payment instructions in the response body when payment is required; so the flow is self-explanatory even without reading the documentation.</p><p>Payment verification was the most interesting architectural decision. I originally planned to use Circle's transaction indexing endpoint to verify external payments after the transfer was made. In testing, Circle's API on Arc Testnet had a delay of several minutes after a successful on-chain transfer before the transaction appeared in the indexing endpoint. That's too slow for a pay-per-query system where the developer is actively waiting for their credit to be added. I switched to Blockscout's transaction API instead. Blockscout returns transaction data immediately after confirmation, works for any EVM wallet, and requires no Circle account from the paying party. The Circle API is still used for agent-to-service transfers where both wallets are Circle-managed — that flow is fast and reliable. Blockscout handles everything else.</p><p>The autonomous agent was the most complex piece to get right. The agent runs on a 5-minute scheduler and operates entirely without human input. Every cycle it fetches live Arc network health directly from the engine; bypassing the payment gate so it never consumes free queries or paid credits on its own health checks. The decision engine evaluates three conditions: if the health score drops below 85, it buys a contract risk scan for the top failing contract. If the failure rate crosses 3%, it buys a block analysis. If the failure rate crosses 10%, it escalates to a deep contract scan. When a condition is met, the agent sends 0.1 USDC from its Circle Developer Wallet to the ArcSense service wallet, receives the intelligence, and logs the full decision — including the reasoning, the urgency level, and a clickable Arc Explorer link to the on-chain transaction.</p><p>The architecture uses two separate Circle wallets deliberately. The agent wallet is the buyer. The service wallet is the seller. Separating them makes the commerce layer explicit and auditable. Every payment from agent to service is a real on-chain transfer between two distinct wallets ; not an internal accounting entry. Anyone can verify the agent's spending history by looking at the agent wallet address on Arc Explorer. That transparency is the point.</p><p>Setting up Circle Developer Wallets on Arc Testnet was the most frustrating part of the build. Two issues cost significant time. First, the feeLevel parameter is required for Arc Testnet transactions but this isn't documented anywhere specific to Arc; the API returns a generic parameter invalid error with no indication of what's wrong. Second, Circle requires an entity public key for request signing. The documentation assumes this key lives in a local file, but that breaks in cloud deployments like Railway where the filesystem is ephemeral. The fix is storing the public key as an environment variable with proper newline handling; something that should be in the official documentation but isn't. Both issues are solvable but they each took most of a day to debug from first principles.</p><p>In the first 7 days of continuous operation, ArcSense scanned approximately 200,000 blocks on Arc Testnet, completed over 2,000 autonomous agent cycles, and spent more than $30 USDC purchasing intelligence; all verifiable on-chain. On day 7 the weekly report generator crashed because Math.max() with a spread operator fails when the array has tens of thousands of entries; it exceeds JavaScript's call stack argument limit. The fix was replacing the spread with a reduce call. It was identified, pushed, and redeployed in minutes. That crash was actually useful information; it only happened because the system ran long enough to accumulate real data at scale. That's the kind of failure that means you're building something real.</p><p>What I've learned building ArcSense is that most agentic economy discussions happen at the level of concept rather than implementation. The interesting questions are the ones that only appear when you try to actually build it. How do you design a payment gate that works for both human developers and autonomous agents without special-casing either? How do you verify payments from any EVM wallet without requiring Circle infrastructure on the payer's side? How do you build a decision engine that fires often enough to demonstrate real autonomous commerce but not so often that it drains the wallet before anyone can observe the behavior? These are practical engineering problems, not theoretical ones. ArcSense is my attempt to answer them on Arc Testnet with real USDC and real on-chain data.</p><p>ArcSense is live at <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://arcsense-lite.vercel.app">arcsense-lite.vercel.app</a>. The API is open with 5 free queries per wallet. The GitHub is public at github.com/2TheMoom/arcsense-lite. Follow @ArcSense_ on X for weekly Arc Testnet intelligence reports.</p><p><em>Edition 2 — Saturday June 6, 2026: "The state of programmable payments on Arc — what the data says"</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/3dd0eaf8e5af311bde39d5edfcd82561e80ab81d5c0e28e1e8b98c1167503a64.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Jumper: The Best Swap/Bridge UI You Are Not Using.]]></title>
            <link>https://paragraph.com/@olumi/jumper-the-best-swapbridge-ui-you-are-not-using</link>
            <guid>zC2hGixQYxX0YUMeFnuV</guid>
            <pubDate>Thu, 21 May 2026 08:46:46 GMT</pubDate>
            <description><![CDATA[What Is Jumper? The Consumer Layer That Makes Cross-Chain Simple.60+ networks. 29 bridges. 33 DEXs. One interface. Here is what Jumper actually does and why it is worth understanding. If you have spent any time in DeFi, you know the routine. You have assets on one chain, an opportunity on another, and a mental checklist of steps: find a bridge that supports your token pair, figure out if you need to swap first or after, approve both protocols, pay gas twice, and then wait. Sometimes it works....]]></description>
            <content:encoded><![CDATA[<h2 id="h-what-is-jumper-the-consumer-layer-that-makes-cross-chain-simple" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>What Is Jumper? The Consumer Layer That Makes Cross-Chain Simple.</strong></h2><p><em>60+ networks. 29 bridges. 33 DEXs. One interface. Here is what Jumper actually does and why it is worth understanding.</em></p><p>If you have spent any time in DeFi, you know the routine. You have assets on one chain, an opportunity on another, and a mental checklist of steps: find a bridge that supports your token pair, figure out if you need to swap first or after, approve both protocols, pay gas twice, and then wait. Sometimes it works. Sometimes you end up with a wrapped token nobody wants.</p><p>Jumper was built to collapse that entire process into a single interface.</p><h3 id="h-what-jumper-is" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>What Jumper Is</strong></h3><p>Jumper is the consumer-facing product built on top of <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s infrastructure. Where <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> is the routing engine, smart contracts, and aggregation layer, Jumper is the interface that makes all of it usable for everyday DeFi users. Think of it as the app that runs on the engine.</p><p>It covers <strong>60+ networks</strong>, integrates <strong>29 bridge protocols</strong> and <strong>33+ DEXs</strong>, and handles both cross-chain and same-chain swaps from one screen. You do not need to know which bridge to use, which DEX has the best rate, or how to handle token standard differences. Jumper figures that out automatically.</p><p><em>Jumper is not just a bridge. It is a route discovery and execution layer for users who want one interface across many chains, bridges, and DEXs.</em></p><h3 id="h-route-comparison-is-the-core-product" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Route Comparison Is the Core Product</strong></h3><p>The most important thing to understand about Jumper is that route comparison is the actual feature, not just a nice-to-have. Every quote surfaces multiple options ranked by return, speed, and cost. You see the full fee breakdown before you confirm: bridge fee, DEX swap fee, gas on both source and destination chains, and expected slippage.</p><p>You then choose what matters to you. If speed is critical, take the fastest route. If you are moving a large amount and want to preserve capital, take the best return route. Jumper shows you the difference so you can decide with real information.</p><h3 id="h-bridge-and-swap-in-one-transaction" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Bridge and Swap in One Transaction</strong></h3><p>What Jumper calls a "Zap" is a cross-chain bridge and token swap executed atomically in a single transaction. To understand why that matters, consider a real example: 1,000 USDC on Arbitrum routed to HYPE on Hyperliquid via Relay completes in 3 seconds for less than $0.01 in gas, at 99.89% capital efficiency. No separate bridge step. No manual swap on arrival.</p><p>This is powered by <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a>'s Diamond Contract and Facet architecture under the hood, but from the user's perspective it is just one confirmation.</p><h3 id="h-chain-coverage-and-interop-standards" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Chain Coverage and Interop Standards</strong></h3><p>Jumper covers the full spectrum of modern DeFi chains: all major EVM networks, Solana (with Jupiter and Dflow integrated for native DEX aggregation), Sui, Bitcoin-adjacent infrastructure, and Hyperliquid's HyperEVM. It is also the first platform to support all three major interoperability token standards simultaneously: LayerZero OFTs, Chainlink CCTs, and Wormhole NTTs. That means assets built on any of these standards can be routed through Jumper without fragmentation.</p><h3 id="h-portfolio-view-and-gasless-routes" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Portfolio View and Gasless Routes</strong></h3><p>Jumper includes a portfolio abstraction mode that gives you a unified view of all your assets across 50+ chains in one dashboard. Connect once, see everything. It also supports gasless transactions on select routes, which removes one of the most common friction points in cross-chain DeFi: needing to hold native tokens on every destination chain just to pay gas on arrival.</p><p>Next week: the full routing flow explained, from the moment you hit swap to when your assets land on the destination chain.</p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/7ecbbd611a8e8c1ff2487441b026fb9fe4147049fff47914ac19a9486e1023c6.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Why ERC-4337 Is a Patch Job and Dango's Account Model Is the Real Fix]]></title>
            <link>https://paragraph.com/@olumi/why-erc-4337-is-a-patch-job-and-dangos-account-model-is-the-real-fix</link>
            <guid>2p00cfCmJXri1v2IVlSZ</guid>
            <pubDate>Tue, 19 May 2026 12:07:56 GMT</pubDate>
            <description><![CDATA[The Seed Phrase Problem Nobody Wants to Talk AboutEvery year, DeFi loses hundreds of millions of dollars not to smart contract exploits, not to bridge hacks, but to people losing access to their own wallets. A forgotten seed phrase. A stolen private key. A hardware failure with no backup. The number is impossible to track precisely because there is no one to report it to. The funds just sit in addresses nobody can reach anymore. This is not a user education problem. It is a design problem. Th...]]></description>
            <content:encoded><![CDATA[<figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/0a0ab20ec21eeaf9bd008c5bf49b62d965573f0b6f8e26c40cab65c133825cc0.png" blurdataurl="data:image/png;base64,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" nextheight="2016" nextwidth="1472" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><h2 id="h-the-seed-phrase-problem-nobody-wants-to-talk-about" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Seed Phrase Problem Nobody Wants to Talk About</h2><p>Every year, DeFi loses hundreds of millions of dollars not to smart contract exploits, not to bridge hacks, but to people losing access to their own wallets. A forgotten seed phrase. A stolen private key. A hardware failure with no backup. The number is impossible to track precisely because there is no one to report it to. The funds just sit in addresses nobody can reach anymore.</p><p>This is not a user education problem. It is a design problem. The 12-word seed phrase was never built for mass adoption. It was built for a world where crypto was a niche technical hobby and users were expected to understand public key cryptography. That world ended a long time ago. The infrastructure did not catch up.</p><p>ERC-4337 is the Ethereum community's most serious attempt to fix this. It is thoughtful, widely deployed, and a genuine improvement over the status quo. But it is also, fundamentally, a patch applied on top of a system that was never designed to support it. Understanding why requires looking at what ERC-4337 actually does, and what it cannot do.</p><hr><h2 id="h-what-erc-4337-actually-is" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What ERC-4337 Actually Is</h2><p>The core insight behind ERC-4337 is simple: instead of requiring every account to be an Externally Owned Account authenticated by a fixed private key, let accounts be smart contracts that define their own rules for signing, paying gas, and recovering access.</p><p>This unlocks a genuinely impressive set of features. Accounts can accept gas payments in any token, not just ETH. They can batch multiple transactions into a single operation. They can implement social recovery, meaning a set of trusted contacts can restore access to a lost account. They can set spending limits, whitelist specific addresses for large transfers, and automate recurring payments with a single authorization.</p><p>ERC-4337 does all of this without requiring any changes to Ethereum's consensus layer. It operates through a separate mempool of UserOperations, a new transaction type that gets bundled and submitted to the chain by infrastructure providers called Bundlers and processed by smart contracts called Paymasters. This is genuinely clever engineering. It extends Ethereum's capabilities without touching the protocol itself.</p><p>EIP-7702, introduced with Ethereum's Pectra upgrade in May 2025, took this further by letting existing EOA addresses temporarily execute smart contract code, which means legacy wallets can access account abstraction features without migrating to a new address. ERC-7579 and ERC-6900 add modular plugin standards on top. The stack is maturing.</p><p>So why call it a patch job?</p><hr><h2 id="h-the-structural-problems-erc-4337-cannot-solve" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Structural Problems ERC-4337 Cannot Solve</h2><h3 id="h-it-requires-a-parallel-infrastructure-layer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">It Requires a Parallel Infrastructure Layer</h3><p>ERC-4337 does not modify Ethereum's transaction processing. It adds a separate system on top of it. Every UserOperation flows through Bundlers, which are third-party infrastructure providers that aggregate operations and submit them to the chain. The security and liveness of your smart account depends on Bundlers being available, honest, and censorship-resistant.</p><p>In practice, the Bundler market is highly concentrated. A handful of providers, including Alchemy, Pimlico, and Stackup, handle the overwhelming majority of UserOperation volume. If those providers experience downtime, implement censorship, or change their fee structures, users of ERC-4337 wallets are directly affected. This is not a theoretical risk: it is the predictable outcome of building critical infrastructure on top of centralized middleware rather than into the protocol itself.</p><h3 id="h-the-ux-improvement-is-partial" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The UX Improvement Is Partial</h3><p>ERC-4337 can eliminate the seed phrase experience for new accounts, but it cannot eliminate it for the 600 million existing EOA holders on Ethereum. Users with existing EOA accounts cannot convert to ERC-4337 smart wallets without creating new addresses and transferring all their assets. EIP-7702 softens this by letting EOAs temporarily delegate to contract code, but it does not give them persistent smart account functionality. The full ERC-4337 experience requires a new account.</p><p>Gas abstraction is also only partial. While Paymasters can sponsor gas or accept payment in alternative tokens, configuring and funding Paymasters is still the responsibility of application developers. Most DeFi applications have not implemented Paymaster support, which means most users still need ETH to interact with most protocols even when using an ERC-4337 wallet.</p><h3 id="h-private-keys-still-exist-somewhere" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Private Keys Still Exist Somewhere</h3><p>ERC-4337 abstracts away the seed phrase from the user experience. It does not eliminate the underlying cryptographic key. That key still has to be stored somewhere: in the device's secure enclave, in a browser extension, in a cloud backup. If that storage is compromised, the account is compromised. The UX improved; the attack surface did not fundamentally shrink.</p><p>What most ERC-4337 implementations actually do is hide the key management complexity from the user and distribute the risk across multiple recovery mechanisms. That is a meaningful improvement. But it is not the same as eliminating the private key dependency at the account layer.</p><hr><h2 id="h-what-dango-does-instead" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Dango Does Instead</h2><p>Dango's account model starts from a different premise: rather than retrofitting account abstraction onto an existing system, build the account layer from scratch with the target UX in mind. This is only possible because Dango controls its entire execution environment through Grug, its custom smart contract engine.</p><h3 id="h-no-seed-phrases-no-wallets-no-extensions" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">No Seed Phrases, No Wallets, No Extensions</h3><p>When you create a Dango account, you choose a human-readable username, like @larry, the same way you would sign up for any web2 application. There is no seed phrase generated. There is no browser extension to install. There is no wallet to configure.</p><p>Authentication is handled through Passkeys, the same FIDO2 standard used by Apple, Google, and Microsoft for passwordless login across their platforms. Your Passkey is stored in your device's secure enclave, backed by biometric authentication: Face ID, Touch ID, or device PIN. It syncs across your devices through your platform's keychain (iCloud Keychain for Apple devices, Google Password Manager for Android). Signing a transaction on Dango looks like approving an Apple Pay purchase.</p><p>For users who want more control, Dango supports legacy wallets (MetaMask, Phantom, Backpack, Keplr), hardware keys (Ledger, YubiKey), and any number of additional authentication methods attached to the same username. The Passkey-first approach is the default for 99% of users. The flexibility is there for the remaining 1%.</p><h3 id="h-the-username-as-identity-layer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Username as Identity Layer</h3><p>On Ethereum, your account is your address: a 42-character hex string that serves simultaneously as your identity, your authentication credential, and your asset custody address. Lose access to the private key behind that address, and you lose everything.</p><p>Dango separates these concepts. Your username is your identity. Under that username, you can open multiple account types: spot accounts, margin accounts, multisigs. To any of those accounts, you can attach any number of authentication methods. A transaction from any of your accounts can be signed by any of the authenticators associated with your username.</p><p>This means key rotation is native, not bolted on. If your phone is stolen, you remove that Passkey from your username and add a new one from another device. Your username persists. Your accounts persist. Your history persists. Nothing needs to be migrated.</p><h3 id="h-gas-in-usdc-not-native-tokens" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Gas in USDC, Not Native Tokens</h3><p>Dango charges gas in USDC. There is no native token to acquire before you can interact with the chain. This is not a Paymaster workaround implemented at the application layer. It is protocol-level behavior built into Grug's execution environment.</p><p>On ERC-4337, gas abstraction requires a developer to configure and fund a Paymaster for each application. On Dango, it is the default for every transaction on the chain. The difference is not cosmetic: it means a new user can fund a Dango account with a USDC transfer from Coinbase and start trading immediately, with no intermediate steps.</p><h3 id="h-a-single-interface-for-everything" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">A Single Interface for Everything</h3><p>One of the consistent pain points in DeFi today is fragmentation. Swap on Uniswap, borrow on Aave, trade perps on dYdX or Hyperliquid, bridge on Stargate. Each application has its own interface, its own wallet connection flow, its own gas management. A power user might interact with a dozen different frontends in a single trading session.</p><p>Dango runs everything through a single interface: the Dango Portal. Spot trading, margin accounts, lending, vaults, all accessible from one login, under one username, with one gas token. The account model is what makes this possible. Because authentication and asset custody are separated at the protocol level, the portal can present all account types under a unified identity without requiring the user to manage separate wallets for separate applications.</p><hr><h2 id="h-the-core-difference" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Core Difference</h2><p>ERC-4337 asks: how do we give Ethereum's existing account model more flexibility without changing the protocol? It is a good question with a good answer. The result is a system that is battle-tested, widely deployed, and genuinely better than raw EOAs.</p><p>Dango asks a different question: if we are building a new chain from scratch and we control the execution environment, what is the best possible account model for a DeFi application? The answer looks nothing like ERC-4337.</p><p>The comparison is not really ERC-4337 vs Dango. It is the difference between improving a constraint and removing it. ERC-4337 improves the constraints imposed by Ethereum's EOA model. Dango removes them by controlling the full stack.</p><p>For a chain built around the idea that every infrastructure decision should serve the trader first, building the account model into the execution environment rather than layering it on top is not just a design choice. It is the only way to deliver the UX that the promise of DeFi has always implied.</p><hr><h2 id="h-the-trade-offs" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Trade-offs</h2><p>Dango's account model is newer and less battle-tested than ERC-4337. The smart account contracts, Passkey integration, and username system are all novel components with limited production history. ERC-4337 has been live since March 2023, has processed tens of millions of UserOperations, and has been audited by multiple independent security firms.</p><p>Passkey synchronization also introduces a dependency on platform keychain providers, specifically Apple and Google. A user who stores their Passkey in iCloud Keychain is partially dependent on Apple's infrastructure for cross-device access. This is a different trust model than a hardware wallet, not necessarily worse, but worth understanding.</p><p>And Dango's account model, like Grug itself, is only available on Dango. ERC-4337 works across Ethereum, Arbitrum, Base, Optimism, and dozens of other chains. The breadth of ERC-4337's deployment is a genuine advantage for a user who wants their smart account experience to be portable.</p><p>These trade-offs are real. They are also, in large part, the expected cost of building something new. The question is whether the target experience is worth building toward. For a DeFi-native L1 targeting serious traders and mainstream users simultaneously, the answer appears to be yes.</p><hr><p><em>Part 2 of a research series on Dango's technical architecture. Part 1 covered why Dango chose Hyperlane over LayerZero, Wormhole, and Axelar. Part 3 will cover the Grug execution environment and what it unlocks vs EVM and SVM.</em></p>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/64230cd0a59b9f6aa5b3e3f758a3bd4437a863921fc5446faf48fa8a2233029a.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[LI.FI: One Integration.
Every Chain.]]></title>
            <link>https://paragraph.com/@olumi/lifi-one-integration-every-chain</link>
            <guid>L5N6eAhM2BgS1OW7RJL4</guid>
            <pubDate>Thu, 14 May 2026 06:13:23 GMT</pubDate>
            <description><![CDATA[LI.FI and the Abstraction Thesis: Why Cross-Chain Infrastructure Needs a Single Source of TruthOne integration. Every chain. Every asset. Every liquidity source. Here is what that actually means. There is a quiet assumption baked into most DeFi apps: that integrating a bridge, a DEX, and a few chains is a one-time task. You do it once, ship the feature, and move on. That assumption breaks the moment a new rollup gains traction, a bridge gets exploited, a token standard forks, or a solver netw...]]></description>
            <content:encoded><![CDATA[<h2 id="h-lifi-and-the-abstraction-thesis-why-cross-chain-infrastructure-needs-a-single-source-of-truth" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> and the Abstraction Thesis: Why Cross-Chain Infrastructure Needs a Single Source of Truth</strong></h2><p><em>One integration. Every chain. Every asset. Every liquidity source. Here is what that actually means.</em></p><p>There is a quiet assumption baked into most DeFi apps: that integrating a bridge, a DEX, and a few chains is a one-time task. You do it once, ship the feature, and move on.</p><p>That assumption breaks the moment a new rollup gains traction, a bridge gets exploited, a token standard forks, or a solver network offers better prices than your existing aggregator. Suddenly the "one-time task" is a full-time maintenance burden.</p><p><strong>This is the problem li.fi was built to solve.</strong></p><h3 id="h-what-lifi-actually-is" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>What </strong><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI"><strong>LI.FI</strong></a><strong> Actually Is</strong></h3><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> is a routing and execution layer. It sits between your application and the fragmented liquidity landscape of modern blockchains: dozens of chains, multiple bridge protocols, separate DEX aggregators per ecosystem, conflicting token standards, and an emerging layer of intent-based solver networks.</p><p>The core thesis is simple: integrating all of that individually is expensive, brittle, and impossible to maintain at scale. li.fi abstracts the complexity behind a single API and SDK. You call one endpoint. li.fi figures out the rest.</p><p><em>"You integrate once. li.fi handles the routing logic and infrastructure maintenance." — li.fi Documentation</em></p><h3 id="h-the-token-standard-problem-nobody-talks-about" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>The Token Standard Problem Nobody Talks About</strong></h3><p>One of the most underrated things li.fi does is canonical token mapping. This sounds boring until you realize how often it silently kills cross-chain transactions.</p><p>USDC on Ethereum is not the same contract as USDC.e on Avalanche, or bridged USDC on Arbitrum. If your app does not handle this distinction, it either fails, or it wraps the wrong token and leaves users stuck. li.fi resolves token variants automatically so your app never has to.</p><h3 id="h-how-the-execution-flow-works" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>How the Execution Flow Works</strong></h3><p>When a user initiates a trade through a li.fi-integrated app, here is what happens:</p><p>1. The app sends a quote request to the li.fi API.<br>2. The API queries bridges, DEX aggregators, and solvers simultaneously to find the optimal route based on price, gas, and execution reliability.<br>3. The optimal route is returned to the app. The user confirms.<br>4. The transaction is submitted to the li.fi Diamond Contract on-chain.<br>5. The Diamond Contract routes it to the appropriate Facet Contract, which executes with the selected bridge, DEX, or solver.<br>6. Assets arrive at the destination. The user sees the result.</p><p>If a provider fails mid-execution, li.fi's fallback logic automatically re-routes. You do not build that logic. It is already there.</p><h3 id="h-why-this-is-a-different-kind-of-infrastructure-play" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Why This Is a Different Kind of Infrastructure Play</strong></h3><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://LI.FI">LI.FI</a> recently launched an MCP server and an agentic commerce API. This is worth paying attention to. AI agents executing on-chain transactions are not a hypothetical. They are a live use case, and li.fi is positioning itself as the execution layer for that entire category.</p><p>The same API that powers a wallet widget also powers an autonomous agent bridging assets across chains to fulfill a DeFi strategy. That abstraction is what makes li.fi infrastructure rather than a feature.</p><p>Next week: the full product stack broken down layer by layer, from the embeddable widget all the way down to the solver network.</p><br>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/61d383cb2d7b3e0e8920832b5836d9a282c43554536d061ea53c8d2a79cda562.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Why Dango Chose Hyperlane: A Cross-Chain Messaging Deep Dive]]></title>
            <link>https://paragraph.com/@olumi/why-dango-chose-hyperlane-a-cross-chain-messaging-deep-dive</link>
            <guid>OGKVLi8gplrqbCD9Sa34</guid>
            <pubDate>Mon, 11 May 2026 12:59:25 GMT</pubDate>
            <description><![CDATA[The Problem Every App-Chain Has to SolveBuilding a purpose-built blockchain for DeFi is a powerful architectural choice. It lets you control execution, gas mechanics, account logic, and settlement in ways that general-purpose chains cannot. But it comes with a cost: isolation. A sovereign chain with no bridge to the outside world is a walled garden. Liquidity cannot flow in, users on Ethereum or Arbitrum have no natural path to participate, and the chain's assets have no reach beyond its own ...]]></description>
            <content:encoded><![CDATA[<h2 id="h-the-problem-every-app-chain-has-to-solve" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Problem Every App-Chain Has to Solve</h2><p>Building a purpose-built blockchain for DeFi is a powerful architectural choice. It lets you control execution, gas mechanics, account logic, and settlement in ways that general-purpose chains cannot. But it comes with a cost: isolation. A sovereign chain with no bridge to the outside world is a walled garden. Liquidity cannot flow in, users on Ethereum or Arbitrum have no natural path to participate, and the chain's assets have no reach beyond its own ecosystem.</p><p>This is the cross-chain messaging problem, and every app-chain has to pick a solution for it. Dango chose Hyperlane. Understanding why requires looking honestly at what the alternatives actually offer, and what trade-offs each one forces on a team building from scratch.</p><hr><h2 id="h-the-four-contenders" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Four Contenders</h2><h3 id="h-layerzero-speed-and-simplicity-with-centralization-trade-offs" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">LayerZero: Speed and Simplicity, With Centralization Trade-offs</h3><p>LayerZero describes itself as an "omnichain" messaging layer. Its architecture is deliberately minimal: two independent off-chain actors, an Oracle and a Relayer, work together to verify and deliver messages between chains. The Oracle fetches block headers from the source chain; the Relayer provides transaction proofs. If both agree, the message is accepted on the destination chain.</p><p>The appeal for developers is real. Integration is straightforward: implement a <code>send</code> and a <code>receive</code> function and you are done. LayerZero supports over 50 chains and has seen significant adoption, including PayPal's PYUSD stablecoin expansion and its $120 million acquisition of Stargate DAO in August 2025.</p><p>The catch is in the trust model, and it stopped being theoretical on April 18, 2026.</p><p>KelpDAO's rsETH bridge was running a 1-of-1 DVN (Decentralized Verifier Network) configuration, meaning LayerZero Labs itself was the sole entity verifying cross-chain messages. Attackers attributed to North Korea's Lazarus Group compromised LayerZero's internal RPC nodes and DDoS'd the external fallback nodes simultaneously, feeding false data to the single verifier. With no second DVN to catch the discrepancy, the Ethereum contract released funds against a burn that never happened on the source chain. The attack drained roughly $292 million in rsETH.</p><p>What made the aftermath significant was the dispute over whose fault it was. KelpDAO pointed out that LayerZero's own V2 OApp Quickstart guide and default GitHub configuration use the exact same 1-of-1 structure, and that 47% of LayerZero OApp contracts were running the same setup at the time of the exploit. LayerZero initially blamed KelpDAO's configuration choices. It later issued a public apology, admitted it should not have allowed its DVN to operate as the sole verifier for high-value transactions, and ended support for 1-of-1 configurations entirely. KelpDAO migrated to Chainlink CCIP afterward.</p><p>The lesson is not that LayerZero is broken. Multi-DVN setups on LayerZero were unaffected. The lesson is that the default path, the one most teams take without reading the docs closely, was dangerous, and it took a $292 million exploit to force a change. For a protocol building financial infrastructure from scratch, accepting that the default configuration of your bridge provider is a single point of failure is a risk that compounds with every dollar of TVL you attract.</p><p>There is also a governance gate. Adding a new chain or VM to LayerZero requires involvement from the core team. For Dango, which runs a custom execution environment (Grug) that is neither EVM nor standard CosmWasm, this would mean waiting on an external team to build and approve support. That timeline is incompatible with building fast.</p><h3 id="h-wormhole-broad-adoption-guardian-centralization" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Wormhole: Broad Adoption, Guardian Centralization</h3><p>Wormhole is arguably the most widely deployed cross-chain messaging protocol in production. It powers bridges across Ethereum, Solana, Avalanche, and many others, and its volume figures are substantial. Its security model is built around 19 Guardian nodes, large and reputable entities like Jump Crypto and Certus One, who collectively sign off on cross-chain messages using a supermajority threshold (13 of 19).</p><p>This Guardian model has a proven track record of catching and preventing attacks. But it is also its primary weakness. 19 entities is a small validator set, and the identities of those validators are publicly known. The $325 million exploit in 2022 is worth acknowledging even if Wormhole's security has improved substantially since then. More fundamentally, Wormhole is a permissioned system: adding new chains or changing validator sets requires governance approval from the core team and the Guardian network. For a novel app-chain running a custom VM, that path is slow and uncertain.</p><h3 id="h-axelar-most-decentralized-but-a-hub-you-depend-on" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Axelar: Most Decentralized, But a Hub You Depend On</h3><p>Axelar takes the most structurally decentralized approach of the three. It is itself a Layer 1 blockchain, built with the Cosmos SDK and secured by a Delegated Proof-of-Stake validator set of over 75 nodes. Cross-chain messages are routed through Axelar's hub and verified by its validator network before being delivered to the destination chain.</p><p>This hub-and-spoke model offers meaningful advantages in security and decentralization. Axelar has processed over $8.66 billion in cross-chain transfers across 64 blockchains with no major exploit. Its General Message Passing (GMP) system supports arbitrary data transfer, not just tokens. And its validator penalties create genuine economic disincentives for malicious behavior.</p><p>The trade-off is structural dependency. Every message Dango sends or receives passes through Axelar's hub. If Axelar experiences congestion, goes offline, or makes a governance decision that changes routing behavior, Dango is affected. The hub is also a single point of integration, which means connecting to non-EVM chains beyond Axelar's current support requires waiting on Axelar's own expansion roadmap. For Dango, which is building a chain that needs to connect to Ethereum, Arbitrum, and eventually Bitcoin, that dependency is a constraint that compounds over time.</p><hr><h2 id="h-why-hyperlane-fits-dango" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why Hyperlane Fits Dango</h2><h3 id="h-permissionless-by-design" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Permissionless by Design</h3><p>The most important property Hyperlane has for Dango is one word: permissionless. Any team can deploy Hyperlane contracts on any chain without asking the Hyperlane core team, without going through governance, and without waiting for approval. As of April 2026, Hyperlane spans more than 140 chains, the largest footprint of any messaging protocol, because anyone can extend it.</p><p>For Dango, this means connecting to Arbitrum (already in progress in PR #1669 by larry0x), Ethereum, and future chains is entirely within the team's own hands. No external dependency, no approval process, no timeline controlled by another organization.</p><h3 id="h-modular-security-through-isms" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Modular Security Through ISMs</h3><p>Hyperlane's core architectural innovation is the Interchain Security Module (ISM). Each application built on Hyperlane chooses its own verification logic for incoming messages. That logic lives in a dedicated smart contract that the application controls. A team could choose a multisig committee of their own validators, an optimistic verification model with a challenge window, a zero-knowledge proof system, or even route verification through another protocol like Wormhole as a second layer.</p><p>This is meaningfully different from the alternatives. LayerZero gives you Oracle and Relayer selection but defaults to centralized operators. Wormhole and Axelar give you their respective validator sets with no customization. Hyperlane gives you a blank canvas where the security model is something Dango owns, configures, and can upgrade independently.</p><p>For a chain that has already built its own execution environment rather than inheriting EVM defaults, this philosophy of sovereign control over infrastructure is a natural fit.</p><h3 id="h-cosmwasm-and-multi-vm-support" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">CosmWasm and Multi-VM Support</h3><p>Dango's Grug execution environment is built in Rust and shares architectural DNA with the CosmWasm world. Hyperlane already has a live CosmWasm implementation powering interoperability across Osmosis, Neutron, Injective, Sei, and Stride. More recently, Hyperlane shipped a Cosmos SDK module that allows chains without CosmWasm to integrate directly, covering the broader Cosmos ecosystem.</p><p>LayerZero and Wormhole have EVM-first architectures. Adding a custom Rust execution environment to either would require significant work from the respective core teams. With Hyperlane, Dango's team can build and own the integration themselves, and the existing CosmWasm work provides a strong reference point.</p><h3 id="h-open-source-no-governance-gate" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Open Source, No Governance Gate</h3><p>Hyperlane's entire protocol is open source. The Dango team has already built their own Hyperlane implementation directly in the left-curve repository. That code is visible in the repo today. No licensing conversation, no partnership agreement, no negotiation about API access.</p><p>This is a practical consideration that gets underweighted in protocol comparisons. Building on Hyperlane means the bridge code lives in the same repository as the rest of Dango's stack. The team can read it, modify it, audit it, and extend it on their own schedule.</p><hr><h2 id="h-the-trade-offs-dango-accepts" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Trade-offs Dango Accepts</h2><p>No choice is free of trade-offs, and intellectual honesty requires naming them.</p><p>Hyperlane's permissionless model means there is no canonical "Hyperlane validator set" securing all messages by default. Security is application-specific, which means it is also developer-responsibility. A team that misconfigures their ISM or uses an insecure validation setup could expose users to bridge risk in a way that a Wormhole integration, with its institutional Guardian network, would not. The KelpDAO exploit is instructive here too: the attack succeeded not because of a smart contract bug but because a single verifier's infrastructure was compromised. A poorly configured Hyperlane ISM, one that routes verification through a single validator or an understaffed set, creates the exact same class of risk. The tool is only as secure as the configuration.</p><p>Hyperlane also has lower raw TVL and fewer institutional integrations than Wormhole or LayerZero today. Its network effects are growing but younger. For a protocol like Dango that is targeting serious traders and DeFi power users, the bridge they use needs to be trustworthy in practice, not just sound in theory.</p><p>These are real considerations. They suggest Dango's team needs to invest carefully in their ISM configuration, run meaningful validator sets for their Warp Routes, and communicate their security model clearly to users. The architecture enables it; execution is the team's responsibility.</p><hr><h2 id="h-the-core-insight" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Core Insight</h2><p>The three alternatives, LayerZero, Wormhole, and Axelar, were all designed for a world where your chain is an EVM chain, your launch timeline is negotiable, and you are willing to share control of critical infrastructure with another protocol's governance. Dango is none of those things.</p><p>Hyperlane is the only major messaging protocol that was designed from first principles around the idea that any team should be able to connect any chain, with any security model, on any timeline, without asking permission. For a team that built their own blockchain and their own execution environment precisely because they wanted full control over the product, that philosophy is not incidental. It is the reason the choice makes sense.</p><hr><p><em>Written as part of a research series on Dango's technical architecture. For questions or discussion, find Dango on Discord or follow @dango_exchange on X.</em></p><br>]]></content:encoded>
            <author>olumi@newsletter.paragraph.com (Abu Olumi)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/1953755dde52025833aac3fa7a43a5387e154ec6b293eb8c9619c14a386f5fcb.jpg" length="0" type="image/jpg"/>
        </item>
    </channel>
</rss>