Achilles

Demo

About

Achilles is a cross-chain structured-finance protocol that lets anyone build Senior and Junior tranche products from multiple sources of yield. Yield is fragmented across chains, protocols, and asset classes. LP positions, DeFi lending, tokenized stocks and ETFs, treasuries, private credit, and other yield-generating strategies may all live on completely different infrastructure. Achilles connects these opportunities through a modular adapter architecture. Each adapter represents a source of yield and can operate on any supported chain. Builders choose the adapters they want, combine multiple yield sources into a single portfolio, and structure that portfolio into Senior and Junior tranches. The Junior tranche takes first-loss risk in exchange for greater potential returns, while the Senior tranche receives priority in the yield waterfall and greater downside protection. This transforms a portfolio of heterogeneous yield sources into distinct, programmable risk-return profiles. For example, one Achilles product could combine an LP strategy on Base, lending on Ethereum, tokenized stock or ETF exposure, and another yield strategy on a different chain. Despite the underlying strategies operating across different networks, investors interact with them as one structured product with a Senior and Junior tranche. Achilles makes yield composable across chains and risk programmable through tranching. Instead of building a new protocol for every structured product, anyone can choose yield sources from across the ecosystem, combine them into a portfolio, configure how risk and returns are distributed between tranches, and launch their own onchain structured product.

How it's made

Achilles is built as a hub-and-spoke structured-finance protocol. The core idea is that yield can come from completely different chains, protocols, and asset classes, while investors interact with them as one Senior/Junior tranche product. On each supported spoke chain, a TrancheVault manages Senior and Junior shares. Both are ERC-1404 restricted tokens, so only eligible, allow-listed wallets can hold or transfer them. We use ERC-7540 asynchronous vault flows because not every yield source settles atomically. This is especially important for sovereign bonds, RWAs, cross-chain positions, and other strategies where settlement may happen asynchronously rather than within a single transaction. Each product has a CapitalAllocator that executes its strategy. A builder can define, for example, 30% LP yield on Ethereum, 25% lending on another chain, 20% tokenized equities, and 25% RWA yield. CapitalAllocator routes deposits and withdrawals to those sources in the configured proportions and triggers their settlement when required. The key abstraction making this possible is our YieldSource interface. Every external protocol or strategy is implemented as an adapter behind the same interface. The underlying source can be a Uniswap LP, lending protocol, tokenized stock or ETF, sovereign bond, private-credit strategy, or something entirely new. Each source can have different contracts, chains, settlement models, and internal logic without requiring changes to the tranche system itself. Uniswap is one of the first real YieldSource integrations we built. We integrate Uniswap v2/v3 liquidity pools on Ethereum Sepolia as LP yield sources. We also use Uniswap on Robinhood Chain Sepolia for tokenized-stock trading, demonstrating that the same underlying protocol stack can participate in very different Achilles strategies and asset classes. From the CapitalAllocator's perspective, these integrations are simply modular YieldSources that can be combined with other adapters into a single product. Cross-chain coordination happens through our private Hub chain. Each spoke connects through a VaultCoordinator, while the HubRouter manages cross-chain actions by product. The HubLedger stores canonical settlement data including NAV, tranche pricing, strategy configuration, requests, permissions, and approvals. Keeping this layer private lets builders protect proprietary strategy composition from unauthorized parties while maintaining a canonical data layer that can expose verified information to regulators and other permissioned participants. For blockchain data access on the application side, we integrated Curvegrid MultiBaas. MultiBaas provides the frontend with indexed blockchain data instead of requiring us to build and maintain a separate indexing stack for every spoke chain. This is particularly useful for Achilles because a single product may span multiple contracts, adapters, and chains. MultiBaas lets the interface surface onchain positions, transactions, vault activity, and other contract data while the protocol itself remains modular. At settlement, Achilles applies the tranche waterfall. Senior receives its configured fixed return first, while Junior takes the first-loss position and receives the remaining upside. We also integrate World IDKit Proof of Human for per-user tranche caps, allowing products to enforce allocation limits against unique humans rather than wallet addresses alone. The most unusual part of the architecture is that we deliberately do not force every yield source into the same execution model. Achilles normalizes them at the YieldSource interface and settlement layer instead. An instantly settling Uniswap LP, a tokenized equity position on another chain, and an asynchronously settling RWA can therefore become components of the same strategy. From the investor's perspective it is one structured product. Underneath, Achilles is coordinating multiple chains, settlement models, and financial primitives — and then applying one programmable Senior/Junior risk waterfall across the combined portfolio.