Events & Interfaces

source-verified

This page is the canonical reference for the Aqua smart-contract event log and its Solidity interfaces. Every signature, event, and error below is copied verbatim from source: the registry surface from 1inch/aqua (src/interfaces/IAqua.sol, src/Aqua.sol, src/AquaApp.sol) and the router/swap surface from 1inch/swap-vm (src/SwapVM.sol, src/interfaces/ISwapVM.sol, src/interfaces/ITakerCallbacks.sol).

Events

Field semantics

• maker — the liquidity provider whose wallet balances are affected.
• app — the app/strategy contract authorized to pull from the maker (the strategy's app implementation).
• strategyHash — bytes32 key identifying the shipped strategy. Returned by ship() and used as the lookup key everywhere.
• strategy (Shipped only) — the full ABI-encoded strategy/program bytes (see Decoding the Shipped strategy bytes). Presented in full rather than pre-hashed specifically for data availability.
• token / amount (Pulled/Pushed) — the ERC-20 moved and its raw amount. Pushed increases the maker's strategy balance; Pulled decreases it.

interface IAqua

Consolidated and copy-pasteable. Declarations are verbatim from 1inch/aqua/src/interfaces/IAqua.sol; NatSpec comments are trimmed for brevity — signatures, types, and mutability are unchanged.

         
         

           Solidity
         
 
         
         

           
           

             
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
           
 
           
           
// SPDX-License-Identifier: LicenseRef-Degensoft-Aqua-Source-1.1
pragma solidity ^0.8.0;

interface IAqua {
    // ---- Errors ----
    error MaxNumberOfTokensExceeded(uint256 tokensCount, uint256 maxTokensCount);
    error StrategiesMustBeImmutable(address app, bytes32 strategyHash);
    error DockingShouldCloseAllTokens(address app, bytes32 strategyHash);
    error PushToNonActiveStrategyPrevented(address maker, address app, bytes32 strategyHash, address token);
    error SafeBalancesForTokenNotInActiveStrategy(address maker, address app, bytes32 strategyHash, address token);

    // ---- Events (no indexed params) ----
    event Shipped(address maker, address app, bytes32 strategyHash, bytes strategy);
    event Docked(address maker, address app, bytes32 strategyHash);
    event Pulled(address maker, address app, bytes32 strategyHash, address token, uint256 amount);
    event Pushed(address maker, address app, bytes32 strategyHash, address token, uint256 amount);

    // ---- Views ----
    function rawBalances(address maker, address app, bytes32 strategyHash, address token)
        external view returns (uint248 balance, uint8 tokensCount);

    function safeBalances(address maker, address app, bytes32 strategyHash, address token0, address token1)
        external view returns (uint256 balance0, uint256 balance1);

    // ---- State-changing ----
    function ship(
        address app,
        bytes calldata strategy,
        address[] calldata tokens,
        uint256[] calldata amounts
    ) external returns (bytes32 strategyHash);

    function dock(address app, bytes32 strategyHash, address[] calldata tokens) external;

    function pull(address maker, bytes32 strategyHash, address token, uint256 amount, address to) external;

    function push(address maker, address app, bytes32 strategyHash, address token, uint256 amount) external;
}
         
       

App integration surface (AquaApp)

An Aqua "app" (the strategy implementation) inherits the abstract base AquaApp from 1inch/aqua/src/AquaApp.sol. This is the surface an app uses inside its own swap method to enforce that the taker actually pushed the promised tokens. It is not a standalone interface in source; the load-bearing members are reproduced verbatim below.

         
         

           Solidity
         
 
         
         

           
           

             
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
           
 
           
           
abstract contract AquaApp {
    // Reverts if strategy params don't match this app's address
    error InvalidAquaStrategy(address maker, bytes32 strategyHash, bytes32 salt, address app, address actualThis);
    // Reverts if taker hasn't pushed enough tokens to the maker
    error MissingTakerAquaPush(address token, uint256 newBalance, uint256 expectedBalance);
    // Reverts if _safeCheckAquaPush runs without reentrancy protection
    error MissingNonReentrantModifier();

    IAqua public immutable AQUA;

    // Wrap every swap method in this (or the equivalent explicit lock/unlock)
    modifier nonReentrantStrategy(address maker, bytes32 strategyHash);

    constructor(IAqua aqua);

    // Verify taker settlement; MUST be called inside nonReentrantStrategy
    function _safeCheckAquaPush(
        address maker,
        bytes32 strategyHash,
        address token,
        uint256 expectedBalance
    ) internal view;
}
         
       

Swap router interface (ISwapVM)

The router's external quote/execute surface, verbatim from the deployed source src/interfaces/ISwapVM.sol — identical in the v1.0.1 and v1.0.2 git tags of 1inch/swap-vm (the v1.0.2 tag, cut 2026-07-26, changed only the fee instruction). This is the interface the live router at 0x111111338c…c0de actually exposes — selector 0x44aa5f14 for quote, 0xf4d2d412 for swap. The taker names tokenIn and tokenOut explicitly, and that pair is the swap direction. quote() is a preview (safe to staticcall); swap() executes. Both return (amountIn, amountOut, orderHash).

         
         

           Solidity
         
 
         
         

           
           

             
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
           
 
           
           
interface ISwapVM {
    struct Order {
        address maker;
        MakerTraits traits;   // packed flags + receiver
        bytes data;           // encoded hooks data + program bytecode (no token prefix)
    }

    function hash(Order calldata order) external view returns (bytes32);

    function quote(
        Order calldata order,
        address tokenIn,
        address tokenOut,
        uint256 amount,
        bytes calldata takerTraitsAndData
    ) external view returns (uint256 amountIn, uint256 amountOut, bytes32 orderHash);

    function swap(
        Order calldata order,
        address tokenIn,
        address tokenOut,
        uint256 amount,
        bytes calldata takerTraitsAndData
    ) external returns (uint256 amountIn, uint256 amountOut, bytes32 orderHash);
}
         
       

Taker swap-callback (ITakerCallbacks)

A taker contract may implement these to be invoked during settlement, verbatim from 1inch/swap-vm/src/interfaces/ITakerCallbacks.sol.

         
         

           Solidity
         
 
         
         

           
           

             
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
           
 
           
           
interface ITakerCallbacks {
    // Called before tokenIn is transferred from taker to maker
    function preTransferInCallback(
        address maker, address taker,
        address tokenIn, address tokenOut,
        uint256 amountIn, uint256 amountOut,
        bytes32 orderHash, bytes calldata takerData
    ) external;

    // Called before tokenOut is transferred from maker to taker
    function preTransferOutCallback(
        address maker, address taker,
        address tokenIn, address tokenOut,
        uint256 amountIn, uint256 amountOut,
        bytes32 orderHash, bytes calldata takerData
    ) external;
}
         
       

Custom errors

Verbatim from source, with the exact revert condition. Registry errors are declared in IAqua and reverted in Aqua.sol; app errors are declared and reverted in AquaApp.sol; router errors in SwapVM.sol.

Decoding the Shipped strategy bytes

The strategy field in Shipped is the full ABI-encoded strategy passed to ship() — deliberately logged in full (not pre-hashed) so that anyone can reconstruct a maker's program from logs alone (data availability). It encodes an ISwapVM.Order-shaped program whose data tail is the strategy bytecode: a sequence of VM instructions the swap router executes.

• To interpret the bytecode, map each opcode to its handler in the router's opcode set. For the Aqua router this is AquaOpcodes (1inch/swap-vm/src/opcodes/AquaOpcodes.sol), which dispatches opcodes such as 10–16 (Controls: jump/deadline/balance guards), 17 (XYC swap), 18 (XYC concentrate), 19 (Decay), 21/27–30 (Fee variants), 31 (PeggedSwap), 32 (Extruction). Instruction bodies live under src/instructions/.
• The opcode table is versioned. Opcode numbers are assigned by the deployed router build and new instructions are appended to preserve backward compatibility — so a given opcode byte only has meaning relative to the exact router version that will execute the strategy. Decode against the opcode table of the specific AquaSwapVMRouter deployment the strategy targets, not a generic table. In particular, never derive the live table from the undeployed main branch: main's opcode enum has been renumbered (no reserved gaps; unknown opcodes revert UnknownOpcode(uint256)) and is not deployed anywhere — the deployed v1.0.x builds are the only valid reference. The v1.0.2 tag (the current router's source) left AquaOpcodes.sol untouched relative to v1.0.1, so the opcode table is identical across all deployed v1.0.x routers.

Read paths / monitoring

Enumerate a maker's strategies

There is no on-chain registry enumeration. Reconstruct a maker's active strategies from the log stream:

1. eth_getLogs on the Aqua registry address filtered by topics[0] = Shipped topic0. Because maker is not indexed, you must decode each log's data and keep those where maker matches.
2. Subtract strategies that later emitted Docked (match on maker, app, strategyHash) to get the currently-active set.
3. For live balances of an active strategy, call rawBalances(maker, app, strategyHash, token) (or safeBalances for a token pair).

Poll vs subscribe

• Subscribe (eth_subscribe / logs) for near-real-time updates on Pulled/Pushed/Swapped. Remember all fields are in data; your subscription filter can only pin address + topics[0], so decode-and-match client-side.
• Poll (eth_getLogs over block ranges) for backfill and for chains/providers without reliable subscriptions. Chunk block ranges to stay under provider log limits and dedupe on (blockNumber, logIndex).

Backfill needs a per-chain deployment block

Per-chain deployment blocks

The AquaSwapVMRouter v1.0.1 (superseded 2026-07-16 by 0x016b417bc933370f5eacc40b1d58b015ac72b070, in turn superseded by the canonical vanity router 0x111111338c5091e8440b67b168bae16a668ac0de on 2026-07-26) was deployed at the same deterministic address on every supported chain:

0x3c4758979ec30ca45857cabc2462a70699ed790e

The table below lists the block in which the router creation transaction was mined on each of the 12 Aqua chains. Values are taken from the router deployment receipts in the 1inch/swap-vm broadcast artifacts (broadcast/__DeployPadCreate.s.sol/<chainId>/run-latest.json) and converted from hex to decimal.

Registry deploy block

The Aqua registry deployment block is not present in the public 1inch/swap-vm broadcast artifacts, which cover only the router. To index registry events, read the registry contract's own creation transaction on each chain (for example, look up the contract address and inspect the block of its creation transaction) and begin your eth_getLogs range from that block. Do not assume it matches the router deploy block — determine it per chain from the registry's creation transaction rather than guessing.

Function-selector reference

Every function on the deployed contracts is dispatched by its 4-byte selector — bytes4(keccak256(canonicalSignature)). The tables below list the selectors for the AquaSwapVMRouter v1.0.2 swap surface and the Aqua registry (IAqua) surface, so any transaction or trace can be decided against the chain by matching calldata[0:4]. The canonical signature column is the exact string hashed: struct arguments are expanded to their ABI tuple form and the MakerTraits user-defined value type resolves to its underlying uint256.

Router selectors — AquaSwapVMRouter v1.0.2

Both entry points take the same five arguments — (Order order, address tokenIn, address tokenOut, uint256 amount, bytes takerTraitsAndData) — verbatim from 1inch/swap-vm/src/interfaces/ISwapVM.sol, identical at the v1.0.1 and v1.0.2 tags. quote() is a view preview; swap() executes. Router at 0x111111338c5091e8440b67b168bae16a668ac0de.

Registry selectors — Aqua (IAqua)

Selectors for the registry surface, computed from the signatures in 1inch/aqua/src/interfaces/IAqua.sol at v1.0.0 (the current Aqua release tag). Registry at 0x1111113ccf1426a8e30e2bff5e005d929bf6a90a.