1inch Aqua — Protocol Blueprint

RESEARCH BRIEF · Prepared by Unblock the Chain · 28 July 2026

Subject: 1inch Aqua, the shared liquidity layer, and its execution engine SwapVM. Purpose: Working reference for protocol analysis, integration design, and security review scoping. Status: Public sources only. No code review performed. Figures are as published by 1inch unless marked otherwise.

1. Executive summary

Aqua inverts the AMM deposit model. Instead of moving tokens into a pool contract, a liquidity provider keeps tokens in their own wallet, grants a revocable ERC-20 allowance to the Aqua registry, and publishes positions — immutable, hash-addressed configurations that quote against that wallet balance. Tokens move only in the atomic transaction where a swap fills.

The consequence that matters: one balance can back many positions at once. A $100k wallet can quote $300k across three positions, because the positions are accounting entries, not custody. 1inch calls this "shared liquidity." The whitepaper formalizes it as a Shared Liquidity Amplification Coefficient (SLAC) — provisioned liquidity divided by real equity.

This is not leverage and not borrowing. There is no debt, no LP token, no liquidation of the position itself. The failure mode of over-provisioning is not insolvency; it is non-execution: if the wallet cannot cover a fill, pull() reverts and the position silently stops filling until it is topped up.

Two contracts carry the design:

Timeline: developer release 17 November 2025 (Devconnect, Argentina); public launch 28 July 2026 across 13 EVM chains, alongside an incentive program of 10M 1INCH (Foundation) and 500k USDC (DAO, via Merkl).

2. Mental model

Three framings, in increasing precision.

For an LP. You are writing standing quotes backed by tokens you never hand over. You choose a pair, a shape (range or peg width), and a fee tier. You keep custody. You keep any other yield those tokens already earn. You can kill everything by revoking one allowance.

For a market structure analyst. Aqua is a permissioned pull market: makers pre-authorize a bounded claim on their wallet, takers (verified resolvers) exercise that claim just-in-time. Compare Uniswap (pre-funded pooled custody) and RFQ/intent systems such as CoW or 1inch Fusion (per-trade signed commitments, no standing on-chain state). Aqua sits between: standing on-chain state, but no custody.

For an auditor. Aqua is a four-level nested balance ledger with an external settlement callback, and SwapVM is a deterministic bytecode interpreter whose programs price the settlement. The trust boundary is the ERC-20 allowance; the invariant that carries the system is that pull() reverts against real balance, atomically, inside the swap.

3. Architecture

3.1 The Aqua registry

Balances are tracked in a four-level mapping:

maker address → app address → strategy hash → token address → virtual balance

Reading it in plain terms: one maker may authorize many applications; each application may run many strategies; each strategy tracks many tokens. A strategy is an ABI-encoded struct — opaque bytes from Aqua's perspective — hashed with keccak256(abi.encode(strategy)). That hash is the position's identity.

Core functions:

push() is what makes fees auto-compound: proceeds land in the wallet and immediately expand the strategy's usable balance without any user action.

Immutability. Once shipped, a strategy's parameters are fixed. "Editing" a position is dock() then ship() with new parameters — cheap, because no tokens ever move in either direction. This is a deliberate security property: the config a maker signs is the config that executes, forever, and it is verifiable by hash before signing.

3.2 SwapVM

SwapVM is a swap-specific virtual machine. Strategies are bytecode programs composed from a library of instructions, not bespoke deployed contracts. This is the single most important architectural fact for anyone assessing the system: strategy logic is data, and the attack surface is the interpreter plus the instruction set, not N unaudited pool contracts.

Execution model. Five mutable registers (SwapRegisters) carry state through a program:

• balanceIn — maker's available input-token balance
• balanceOut — maker's available output-token balance
• amountIn — input amount
• amountOut — output amount
• amountNetPulled — net pulled, for fee accounting

The taker specifies exactly one side of the trade; the VM computes the other. Instructions receive a Context holding VM state (program counter, bytecode pointer, taker-data pointer), an immutable SwapQuery (maker, taker, tokens, direction), and the registers.

Instruction families.

Two balance backends. Dynamic strategies can store reserves either inside SwapVM (isolated per maker, authorized by EIP-712 signature) or in Aqua (shared, requires a prior ship()). Identical bytecode runs against either. The Aqua backend is what enables one balance to back many strategies.

Router variants. SwapVMRouter (full instruction set), LimitSwapVMRouter (limit-order subset), AquaSwapVMRouter (Aqua-shipped strategies), plus custom routers that override _instructions().

3.3 Declared core invariants

SwapVM's repository documents seven invariants, with a reusable CoreInvariants test base. These are the natural spine of any security review:

1. Exact in/out symmetry — no internal arbitrage between exact-in and exact-out paths.
2. Swap additivity — splitting an order yields no advantage.
3. Quote/swap consistency — quote() matches swap().
4. Price monotonicity — larger trades never receive a better price.
5. Rounding favors the maker — input rounds up, output rounds down.
6. Balance sufficiency — a swap cannot exceed available liquidity.
7. Strategy liveness — a depleted reserve still permits reverse-direction recovery.

Supporting controls: EIP-712 typed signatures, transient-storage reentrancy locks, Solidity 0.8+ overflow checks, deterministic execution.

4. Position lifecycle

[1] LP configures a position (pair, shape, range/width, fee tier)
        │
        ▼
[2] One-time ERC-20 approval per token per chain (revocable)
        │
        ▼
[3] ship() — on-chain tx registers an immutable, hash-addressed config
        │   (costs gas; NO tokens move)
        ▼
[4] 1inch routing indexes the position as a liquidity source
        │
        ▼
[5] A verified 1inch Resolver finds a matching swap
        │
        ▼
[6] ATOMIC FILL: pull() takes output tokens from the wallet,
    push() credits input tokens + fees back, in one transaction
        │
        ▼
[7] All other positions immediately re-quote against the new balance
        │
        ▼
[8] dock() — one tx closes the position; nothing to withdraw

Operational states an LP sees in the dApp: Coverage (how much of the position's quote the current wallet backing supports) and Pullable (the maximum a single fill can actually take — the true exposure number, not the approval). There is no "paused" state. An underfunded position simply stops filling and resumes automatically when the wallet is topped up.

Kill switches, in order of bluntness: top up (restore), dock() (close one position), revoke allowance (stop all new fills instantly, no further transaction needed per position).

5. Position shapes

The dApp exposes three shapes; on-chain they are SwapVM instruction compositions. "Position" and "strategy" denote the same object — the UI says position, the contracts and APIs say strategy.

6. Capital efficiency — the core claim

The problem, as 1inch frames it. Roughly 84–95% of capital in top AMMs is idle in any given block. In early 2026, ~85% of concentrated liquidity in top pools was unused; out-of-range concentrated positions accounted for ~29.5% of measured liquidity; classic constant-product pools keep ~98.7% of liquidity outside the bands where swaps actually happen. Separately, close to 50% of stablecoin supply sits idle in EOAs.

The mechanism. Because utilization per strategy is low (~10–15%), the same capital can be provisioned to several strategies and, in practice, rarely be called on by more than one at a time. Aqua's own example: three positions quoting $300k from one $100k balance.

SLAC.

SLAC = Σ(liquidity provisioned across all strategies) / Σ(actual wallet equity)

The whitepaper's worked example stacks two multipliers: $1,000 equity → 3x leverage via Aave → $3,000 collateral → provisioned to 3 strategies → 9x notional exposure.

Read this carefully. Amplification is asynchronous reuse, not simultaneous availability. Aqua's own documentation is explicit that a swap can only access tokens physically present in the wallet, and that if backing runs short, positions stop filling. The upside is fee income on capital that would otherwise be idle. The cost is that quoted depth is, in the aggregate, partly fictitious under correlated demand — the exact condition (a market-wide move) under which every position wants to fill at once.

7. Economics

Fee sources. Swap fees are paid in the swapped tokens, directly into the LP's wallet, where they immediately back positions again as fresh liquidity. Compounding is automatic; there is no claim step.

Fee selection. Auto (suggested per pair), Presets (common tiers), or Custom. The tradeoff is standard: higher fee, more per fill, fewer fills. 1inch cites the observed pattern that premium-tier pools held 58% of liquidity while doing only 21% of volume.

Protocol fee (to the 1inch DAO treasury).

The DAO's cut comes out of the LP's earned fee — the price paid by the counterparty is unchanged. Rates are governable.

APR. Annualized fee income against the value backing a position, computed from a recent activity window. 1inch's own framing: "treat APR as a rear-view mirror."

Costs. Gas on ship() and dock() only. No deposit/withdraw cycle.

Launch incentives (July 2026).

• 10,000,000 1INCH from the 1inch Foundation.
• Up to 500,000 USDC from the 1inch DAO (≈492,600 net of Merkl's 1.5% fee), over three months.
• Six Merkl campaigns (five 1INCH, one USDC umbrella), ~80 markets, five token groups: ETH & LSTs 35%, stablecoins 30%, BTC wrappers 15%, DeFi majors 15%, RWA 5%.
• Release: 50% / 30% / 20% by month, with performance gates at day 30 and day 60; underperforming groups can have weight cut to zero.
• Rewards track processed volume, not parked TVL. Blacklists (router, resolvers, treasury, team, sanctioned addresses), taker–maker exclusion, per-wallet caps, and wash-trade filters apply.

8. Security model

8.1 What changes versus a pooled AMM

8.2 Three declared pillars

1. Maker-controlled custody. The protocol manages virtual accounting only; assets stay in maker wallets. No honeypot, no rug vector on pooled TVL.
2. Allowance boundaries. A strategy can access tokens only up to its authorized virtual balance, which cannot exceed the maker's ERC-20 approval to Aqua.
3. Atomic settlement. Every pull() checks the real wallet balance and reverts if insufficient. Trades complete fully or fail cleanly.

8.3 JIT protection

Just-in-time liquidity sniping — mint a tight position immediately before a large swap, capture the fee, burn immediately after — is structurally impossible here. Each Aqua position belongs to exactly one LP; no external liquidity can be inserted into it, so there is no fee split to snipe.

Cited magnitudes: up to 44% of passive LP fee income eroded per swap under strategic JIT deployment (model-based upper bound, arXiv:2509.16157); ~442,000 JIT bundles measured on Ethereum Uniswap v3 between January 2024 and September 2025, ~52,700 of them via private relays invisible in the public mempool.

Note the boundary precisely: this removes JIT fee sniping. It does not remove market risk, adverse selection, or impermanent loss.

8.4 Audits and licensing

Eight independent audit firms are reported for the public launch: OpenZeppelin, Bailsec, Hashlock, Hexens, MixBytes, Nethermind, Theori, Decurity.

DAO funding structure (1IP proposal): $1,201,000 total — $721,000 for Aqua/SwapVM audits ($321k on v1.0 completed; $240k for v1.5 and $160k for v2.0 planned in 2026) plus a $480,000 annual OpenZeppelin retainer ($180k already used on v1.0). Reports are to be published on the 1inch GitHub.

Licensing is source-available, not open source: LicenseRef-Degensoft-Aqua-Source-1.1 and LicenseRef-Degensoft-SwapVM-1.1, held by Degensoft Ltd. The 1inch DAO holds irrevocable operational rights to deploy on any chain; third-party commercial use requires a license from Degensoft. This matters for anyone planning to fork, embed, or resell the engine.

Bounty: up to $100,000 for optimization contributions and bug discovery, at 1inch's discretion.

8.5 Threat surface worth scoping in a review

Ranked by our judgment, not by 1inch's:

9. Composability: Aave collateral loops

Because positions quote against whatever ERC-20 sits in the wallet, and aTokens are ERC-20s on the 1inch token list, an Aave supply position can back an Aqua position. The same aToken balance then earns Aave supply interest and Aqua fill fees. Aqua itself adds no debt and no liquidation — Aave does.

Loop mechanics: supply WETH → receive aEthWETH → borrow stables → re-supply → repeat. Multipliers, four rounds:

The multiplier applies to interest, fees, and losses.

The instructive failure (1inch's own published case study, July 2026). A wallet supplied 95.67 WETH (~$185k), looped four rounds to $430k stablecoin debt, and opened at health factor 1.18 — which, because the collateral was stable-heavy, tolerated a 48.8% ETH drop. Over two days, Aqua fills rotated the collateral mix ($83k stables sold for 44.43 aWETH), tightening the buffer to 34.2%. On 19 July at 21:00 UTC the owner transferred $96k of aUSDT out; the buffer collapsed to 0.2%. At 22:09 UTC the position was liquidated: $215k debt repaid, 120.79 aWETH seized, $10,767 lost beyond debt repayment.

Three lessons, all generalizable:

1. Health factor is not a price buffer. The same HF means very different survival distances depending on collateral composition. Size on the price buffer.
2. Fills silently rotate collateral. Selling stables into a falling market makes collateral more ETH-heavy exactly when ETH is falling — buffer erosion with a flat-looking HF.
3. Withdrawing collateral is the sharpest lever. It cuts the buffer without changing the liquidation threshold.

Guardrail worth knowing: Aave validates every aToken transfer against the sender's health factor and reverts transfers that would push it below 1.0. So a fill cannot break the loan directly — at the edge, fills simply stop.

Tiering: supply-only (no debt, no HF) → correlated E-Mode (wstETH/WETH, low risk while correlation holds) → cross-asset (full price exposure). Aave governance controls LTV caps, liquidation thresholds, and bonuses, and can change them.

10. Institutional surface

• Verified counterparties. In the dApp, fills are routed by 1inch Resolvers — market makers and arbitrage traders that have completed 1inch's verification process. Direct contract calls bypass this and give the maker more control.
• Conditional access. A position can require the taker to hold a specific NFT. The check runs on-chain before anything else executes, rejecting unauthorized counterparties outright. This is the gating primitive for institutional allowlists, DAO membership, or loyalty tiers. It is not KYC — identity is whatever the NFT issuer attests.
• Operational features. Isolated sub-wallets per desk or mandate; batched deploy/close via a single Safe signature; multisig and MPC wallet support; one-sided quoting.
• Custody. Full self-custody throughout. No keys, no tokens handed over.

11. Networks and deployment

13 chains at public launch: Ethereum, Arbitrum, Base, Optimism, Polygon, BNB Chain, Avalanche, Gnosis, zkSync Era, Linea, Unichain, Sonic, Robinhood Chain.

The public repositories list the deterministic addresses across 12 networks (Robinhood Chain not enumerated in the repo README at time of writing):

Aqua    0x499943e74fb0ce105688beee8ef2abec5d936d31
SwapVM  0x8fdd04dbf6111437b44bbca99c28882434e0958f

Verify addresses on-chain per network before integrating. Do not trust a document for an address.

12. Developer integration blueprint

Building a strategy application (AquaApp).

1. Define a strategy struct that includes the maker address.
2. Compute strategyHash = keccak256(abi.encode(strategy)).
3. Query active balances with safeBalances().
4. Call pull() to take output tokens during a swap.
5. Implement the callback that verifies input tokens via push().
6. Apply the nonReentrantStrategy() modifier.

Using SwapVM directly.

• Makers: compose a program with ProgramBuilder, configure MakerTraits (receiver, unwrap preference, hooks), then either sign EIP-712 (SwapVM-internal balances) or use Aqua balance mode (requires ship()).
• Takers: discover orders off-chain, preview with quote(), execute with swap() and TakerTraits (amount direction, threshold, deadline, callbacks).
• Protocol builders: inherit SwapVM plus opcode contracts and override _instructions() to define a bespoke instruction set. Validate with the CoreInvariants test base.

Resources.

• Whitepaper: 1inch.com/assets/1inch-aqua-white-paper.pdf
• Aqua contracts: github.com/1inch/aqua
• SwapVM: github.com/1inch/swap-vm
• SDKs (Aqua + SwapVM, TypeScript): github.com/1inch/sdks

Integration checklist for a review engagement.

• Confirm deployed bytecode matches the published repository at the reviewed commit, per chain.
• Enumerate the exact instruction set of the router in use (_instructions() override).
• Re-derive all seven core invariants against the specific opcode composition, not just the defaults.
• Model allowance sizing versus worst-case pull() per block across all live positions.
• Test underfunded, partially funded, and adversarially drained wallet states.
• If aTokens or other yield-bearing collateral back positions, model fill-driven composition drift.
• Verify reentrancy guard coverage on every custom router and callback path.
• Confirm licensing rights if the engine is being embedded or forked.

13. Corrections to the prior summary

The earlier draft you shared was directionally right but contains five errors worth fixing before it circulates.

Two further points the prior draft omitted: the protocol fee to the 1inch DAO (1/4 or 1/6 of the swap fee, depending on tier), and the source-available Degensoft licensing — Aqua and SwapVM are not open source.

14. Open questions

Unresolved from public sources; flag these before any production commitment.

1. Aggregate SLAC in the wild. What is the system-wide ratio of quoted depth to real backing? Under a correlated move, what fraction of quotes are actually fillable? No public telemetry.
2. Revert externalities. Failed fills cost resolvers gas. How does resolver behavior adapt — do underfunded positions get deprioritized, and does that create a hidden minimum-coverage requirement?
3. Audit report availability. The DAO proposal commits to publishing reports on 1inch GitHub. Confirm all eight are public and map each to a specific commit and version (v1.0 / v1.5 / v2.0).
4. Resolver set. Size, concentration, and verification criteria for 1inch Resolvers are not publicly enumerated. This is a censorship and liveness assumption.
5. Failure precedent. The protocol is days old in public form. No adverse-market track record exists yet.
6. Robinhood Chain. Listed as supported; deployment address not enumerated in the repo README. Verify independently.

Sources

• 1inch Aqua — How Aqua Works
• 1inch Aqua — FAQ
• 1inch Aqua — Shared liquidity
• 1inch Aqua — JIT protection
• 1inch Aqua — For institutions
• 1inch Aqua — Strategy types
• 1inch Aqua — Fees, earnings & APR
• 1inch Aqua — Create your first position
• 1inch Aqua — Manage & close
• 1inch Aqua — Aave collateral loops
• 1inch Aqua whitepaper (PDF)
• GitHub — 1inch/aqua
• GitHub — 1inch/swap-vm
• 1inch Blog — Aqua Developer Release
• 1inch Governance — Aqua/SwapVM license & security audit funding
• 1inch Governance — Aqua LP Incentive Program
• The Block — 1inch introduces DeFi shared liquidity model 'Aqua'
• Decrypt — 1inch's Shared Liquidity Layer Aqua Goes Live
• PR Newswire / Manila Times — 1inch launches Aqua to the public
• CoinDesk — 1inch launches Aqua
• Greenfield Capital — Wallet-Permissioned Liquidity (Aqua & Superposition)

Unblock the Chain · Blockchain security for enterprises. contact@unblockthechain.com · https://unblockthechain.com

Informational research brief. Not investment, legal, or security advice. No code was reviewed in producing this document; findings in §8.5 are scoping hypotheses, not audit findings.