Venues & routing

The trade manager knows nothing about any DEX. It resolves route.dex — a uint8 we call a dexId — through a registry of adapter contracts, and forwards the trade. Each adapter owns one venue’s specifics: router interfaces, approvals, WETH wrapping, callback plumbing, curve pre-checks. Adding a venue is one adapter deploy plus one owner transaction. No new manager, no re-approvals, no subgraph redeploy.

#The registry, and why it is safe to own

• Append-only. addAdapter(dexId, adapter) reverts with AdapterExists if that id is already bound. A dexId can never be re-pointed, so a route carries exactly the trust assumptions it had the day it was registered.
• Pause is the only mutable bit. setDexPaused can disable a venue; it cannot redirect one. The worst an owner can do to an existing route is turn it off — reversibly.
• Adapters are custody-free. They never see a user allowance and never hold funds between transactions. Only the manager is ever approved.
• Adapters bind their manager immutably. A new adapter cannot be pointed at an old manager, and an old adapter cannot be reused by a new one.

#The dexId table

Live on mainnet, none currently paused.

#The Route struct

The tuple layout is frozen and ABI-compatible back to earlier managers. What the fields mean belongs to the adapter the dexId routes to — a new venue that needs different parameters encodes them into v3Path as opaque bytes rather than changing the struct.

struct Route {
    uint8     dex;          // the dexId, resolved through the adapter registry
    bytes     v3Path;       // V3: packed path. Others: adapter-defined payload
    address[] v2Path;       // V2: WETH-anchored token list
    uint24    fee;          // V4 pool fee
    int24     tickSpacing;  // V4 only
    address   hooks;        // V4 only
}

#dexId 7 — the general V4 executor

One optional Uniswap V3 leg (WETH↔quote) followed by an ordered chain of N Uniswap V4 hops, all inside a single PoolManager unlock. It exists because the most interesting pools on this chain are not quoted in ETH: a Doppler-launched memecoin whose deep pool is priced in a Robinhood stock token, which itself only trades on V4.

ETH ──[V3]──▶ USDG ──[v4, 0.3%]──▶ TSLA stock ──[v4, Doppler dynamic fee]──▶ TSLA-Inc meme

struct V4Hop {
    address currency0;   // sorted; address(0) = native ETH
    address currency1;
    uint24  fee;         // 0x800000 marks a dynamic-fee pool — pass it verbatim
    int24   tickSpacing;
    address hooks;
}

struct MultiHopPath {
    bytes    v3Leg;      // empty = no V3 leg
    V4Hop[]  hops;
}

• Direction is derived, not declared. Hops carry no direction bit; the adapter works out zeroForOne from the currency it currently holds and reverts BrokenChain() if a hop does not connect or the chain ends off-target. Buys run the V3 leg then the hops; sells run the hops then the V3 leg.
• Flash accounting. Intermediate currencies net to zero inside the unlock and are never transferred — one settle at the start, one take at the end.
• Native ETH is a first-class chain currency. A buy with no V3 leg enters natively when the first hop is ETH-keyed, which is why dexId 7 fully supersedes dexId 2.
• Partial fills revert, per hop. Any hop that does not fully consume its input reverts with a typed PartialFill() rather than over-settling into V4’s undecodable CurrencyNotSettled. That also rejects input-skimming hooks. Either way the trade is atomic.

#Hooked pools and the trust boundary

Doppler’s decaying anti-snipe fee and creator cut ride afterSwap, and the PoolManager’s returned delta is already net of them, so exact-input chaining stays exact and simulation prices the whole chain correctly. Dynamic-fee pools carry fee = 0x800000 in the pool key — pass it verbatim, byte-for-byte, or the key will not match. A V4 pool id is keccak256(abi.encode(PoolKey)), which is a useful way to verify your key off-chain before you submit.

#Bonding-curve venues

dexIds 3 and 4 reach two pre-graduation curve venues on this chain (Flap and Virtuals), so a token that has not yet listed on a DEX is still tradeable from the terminal with the same ABI, the same fee, and the same slippage guarantees. Curve buys that cross a graduation threshold hand unconsumed ETH back; the manager forwards it and emits EthRefunded.

#Adding a venue

The path is deliberately narrow, and it is the same one dexIds 6 and 7 took: write an adapter extending TradeAdapterBase, with no admin surface and immutable addresses; test it against mocks and then against the live venue on a mainnet fork; deploy and addAdapter the next free id; verify on Blockscout. Ids are never reused and never renumbered — the frontend, the subgraph and the launch registry all key on these numbers.