@anywalletkit/protocol-swap2-curve 0.0.0-stage → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,390 @@
+import { C as CurveRouterFamily, a as CurveDeployment } from './deployments-D4pk2tPy.cjs';
+export { b as CRVUSD_ETHEREUM, c as CURVE_DENIED_POOLS, d as CURVE_DEPLOYMENTS, e as CURVE_ETH, f as CURVE_LEGACY_ROUTERS, M as MAX_ROUTE_POOLS, g as MAX_ROUTE_STEPS, S as SCRVUSD, Z as ZERO_ADDRESS, h as chainIdOf, i as deploymentOf } from './deployments-D4pk2tPy.cjs';
+import { Hex } from 'viem';
+import { C as CurvePool, a as CurveChainPools } from './provider-B_n93qi8.cjs';
+export { b as CurveProviderConfig, c as curveProvider } from './provider-B_n93qi8.cjs';
+import { Quote, UnsignedTx, RemotePins, QuoteParams } from '@anywalletkit/protocol-swap2-core/types';
+export { CURVE_MODULE, describeCurveActivity } from './activity.cjs';
+export { CurveSwap2Config, CurveSwap2Protocol, CurveSwap2Protocol as default } from './protocol.cjs';
+import '@anywalletkit/core';
+import '@anywalletkit/protocol-swap2-core/swap2/single';
+import '@anywalletkit/protocol-swap2-core/swap2/base';
+
+/**
+ * Router NG entry points, both ABI families (selectors with `viem toFunctionSelector`, checked against every pinned
+ * router's code 2026-11-05). This module writes only the explicit-receiver `exchange` of each family and reads
+ * `get_dy`; the other forms are listed for history recognition.
+ */
+declare const ROUTER_NG5_ABI: readonly [{
+    readonly name: "exchange";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[5][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_min_dy";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "exchange";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[5][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_min_dy";
+    }, {
+        readonly type: "address[5]";
+        readonly name: "_pools";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "exchange";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[5][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_min_dy";
+    }, {
+        readonly type: "address[5]";
+        readonly name: "_pools";
+    }, {
+        readonly type: "address";
+        readonly name: "_receiver";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "get_dy";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[5][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "version";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}];
+declare const ROUTER_LITE4_ABI: readonly [{
+    readonly name: "exchange";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[4][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_min_dy";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "exchange";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[4][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_min_dy";
+    }, {
+        readonly type: "address";
+        readonly name: "_receiver";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "get_dy";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address[11]";
+        readonly name: "_route";
+    }, {
+        readonly type: "uint256[4][5]";
+        readonly name: "_swap_params";
+    }, {
+        readonly type: "uint256";
+        readonly name: "_amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "version";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}];
+declare const VERSION_ABI: readonly [{
+    readonly name: "version";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}];
+/** `coins(uint256)` (every NG pool and most plain ones) and `coins(int128)` (the oldest stable pools). */
+declare const COINS_UINT: Hex;
+declare const COINS_INT: Hex;
+declare const ADDRESS_PROVIDER_ABI: readonly [{
+    readonly name: "get_address";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "_id";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+/** The `exchange` this module builds: with an explicit receiver. */
+declare const EXCHANGE_SELECTOR: Readonly<Record<CurveRouterFamily, Hex>>;
+declare const GET_DY_SELECTOR: Readonly<Record<CurveRouterFamily, Hex>>;
+/** Every swap entry point per family, for history: `[5][5]` 4-, 5- and 6-argument forms; `[4][5]` 4- and 5-argument. */
+declare const ROUTER_SELECTORS: Readonly<Record<CurveRouterFamily, ReadonlySet<string>>>;
+/** topic0 of the router's `Exchange` event per family (`[5][5]` logs `pools` too). */
+declare const EXCHANGE_TOPIC: Readonly<Record<CurveRouterFamily, Hex>>;
+/** A route as the router takes it: 11 addresses and one swap-params row per step (5 rows; 5 or 4 columns). */
+interface RouterArgs {
+    route: readonly Hex[];
+    params: readonly (readonly bigint[])[];
+}
+/** One router call, decoded. `receiver` is null when the call names none (the router then pays `msg.sender`). */
+interface DecodedExchange extends RouterArgs {
+    amount: bigint;
+    minDy: bigint;
+    pools: readonly Hex[] | null;
+    receiver: Hex | null;
+    selector: Hex;
+}
+/** `exchange(route, params, amount, minDy, [zero pools,] receiver)` for the router family. */
+declare function encodeExchange(family: CurveRouterFamily, args: RouterArgs, amount: bigint, minDy: bigint, receiver: Hex): Hex;
+/** `get_dy(route, params, amount)` for the router family. */
+declare function encodeGetDy(family: CurveRouterFamily, args: RouterArgs, amount: bigint): Hex;
+/** Any of the family's `exchange` forms, decoded; null for anything else (another selector, malformed data). */
+declare function decodeExchange(family: CurveRouterFamily, data: string): DecodedExchange | null;
+
+/** One router step: a pool swap, the native ↔ wrapped-native hop (8) or the ERC-4626 hop (9). */
+type CurveStep = {
+    kind: "pool";
+    pool: CurvePool;
+    swapType: 1 | 2;
+    i: number;
+    j: number;
+    tokenIn: Hex;
+    tokenOut: Hex;
+} | {
+    kind: "wrap";
+    weth: Hex;
+    tokenIn: Hex;
+    tokenOut: Hex;
+} | {
+    kind: "erc4626";
+    vault: Hex;
+    deposit: boolean;
+    tokenIn: Hex;
+    tokenOut: Hex;
+};
+interface CurveRoute {
+    steps: readonly CurveStep[];
+    /** Human description for the review / logs, e.g. "3pool", "wrap → TricryptoUSDT". */
+    label: string;
+}
+/** Most candidate routes priced for one quote (three JSON-RPC batches of ten). */
+declare const MAX_QUOTE_CANDIDATES = 30;
+/**
+ * Whether a route may hand the swap through `token` between two hops on `chainId`: the router's native sentinel, the
+ * pinned wrapped native, or a token the swap2-assets catalog lists on that chain, matched by address. The source and
+ * the destination follow the engine's listed / unlisted token policy instead (as for every provider).
+ */
+declare function intermediateAllowed(chainId: number, deployment: CurveDeployment, token: string): boolean;
+/**
+ * Whether `exchange_underlying` (swap_type 2) may run on `pool`, given the chain's allowlisted pools `index`: only on a
+ * metapool that names its base pool, with that base pool itself allowlisted (and not denied), and `underlying` the
+ * meta coins followed by the base pool's coins. Never on a lending pool (no base pool): its underlying route deposits
+ * into the lending venue, which a `get_dy` view never touches (Aave v2 on Polygon has every reserve frozen).
+ */
+declare function underlyingAllowed(pool: CurvePool, index: ReadonlyMap<string, CurvePool>): boolean;
+/** Pool types the router family can execute: `[4][5]` routers speak only to NG pools (stable-ng, twocrypto-ng, tricrypto-ng). */
+declare function poolTypeAllowed(family: CurveDeployment["family"], poolType: number): boolean;
+/** Allowlisted pools by address (lowercase), denied pools left out. */
+declare function poolIndex(chainId: number, deployment: CurveDeployment, table: CurveChainPools | undefined): Map<string, CurvePool>;
+/**
+ * Candidate routes tokenIn → tokenOut: at most {@link MAX_ROUTE_POOLS} pools and {@link MAX_ROUTE_STEPS} steps, no
+ * token or pool twice, at most one wrap and one ERC-4626 hop. Ranked fewest pools first, then by the thinnest pool's
+ * TVL, and cut to `limit`. `truncated` says the cut (or the search budget) dropped some.
+ */
+declare function findRoutes(chainId: number, deployment: CurveDeployment, table: CurveChainPools | undefined, tokenIn: Hex, tokenOut: Hex, limit?: number): {
+    routes: CurveRoute[];
+    truncated: boolean;
+};
+/** The router's `_route` / `_swap_params` for a route, in the deployment's ABI family. */
+declare function routeArgs(family: CurveDeployment["family"], route: CurveRoute): RouterArgs;
+/** Pool addresses a route's router arguments cross, in order. */
+declare function routePools(args: RouterArgs): Hex[];
+/**
+ * Whether router arguments are a route this module would build on `chainId`: from `tokenIn` to `tokenOut`, every pool
+ * hop through an allowlisted (and not denied) pool whose pinned coins at `i`/`j` are the hop's tokens, with the pool's
+ * own pool type, an allowed swap type (1, or 2 for a metapool listing it whose base pool is allowlisted too) and its
+ * coin count; every token between two hops a catalog token, the native coin or the pinned wrapped native; swap_type 8 only through
+ * the pinned wrapped native between it and the native sentinel; swap_type 9 only on a v1.2 router through its pinned
+ * ERC-4626 vault; no other swap type; at most {@link MAX_ROUTE_POOLS} pools, {@link MAX_ROUTE_STEPS} steps, no pool
+ * twice, and nothing after the route's end. The reason it is not, or null.
+ */
+declare function checkRoute(chainId: number, deployment: CurveDeployment, table: CurveChainPools | undefined, args: RouterArgs, tokenIn: string, tokenOut: string): string | null;
+
+type RpcCall = {
+    method: string;
+    params: unknown[];
+};
+
+interface CurveTables {
+    /** Override the deployments (tests). */
+    deployments?: Readonly<Record<number, CurveDeployment>>;
+    /** Override the pool allowlist (tests). */
+    pools?: Readonly<Record<number, CurveChainPools>>;
+}
+/**
+ * The check of a Curve quote's router call against the app's own request, with the tables it uses. The returned
+ * function is {@link curveVerifyQuote} for the shipped tables: synchronous, no I/O — the allowlist is static.
+ */
+declare function curveQuoteCheck(tables?: CurveTables): (params: QuoteParams, quote: Quote) => string | null;
+/**
+ * The swap a Curve quote's router call makes, opened on the client against the app's own request: the explicit-receiver
+ * `exchange` on the chain's pinned Router NG (`0xc872a3c5` on `[5][5]` routers, `0xfd44959c` on `[4][5]`), selling
+ * exactly the input of the source token (the router's native sentinel for a native input, paid as exactly that
+ * `value`; a token input attaches no value and approves exactly the router), for the destination token, with
+ * `min_dy` the quote's minimum (never 0), paid to the recipient, no zap pools, and a route that `checkRoute` accepts:
+ * allowlisted pools only, their pinned coins, swap types 1/2 (8 through the pinned wrapped native, 9 only on router
+ * v1.2 through scrvUSD). The reason it fails, or null.
+ */
+declare const curveVerifyQuote: (params: QuoteParams, quote: Quote) => string | null;
+/**
+ * The Router NG a Curve swap calls and approves on a chain (the shipped {@link CURVE_DEPLOYMENTS} table), and
+ * {@link curveVerifyQuote} — the app's pins for `remoteProvider({name: "curve", baseUrl, ...curvePins})`. For the build
+ * checked on chain as well (router code hash, fresh `get_dy`, pool coins), use {@link curveRemotePins}.
+ */
+declare const curvePins: RemotePins;
+interface CurveOnChainOptions extends CurveTables {
+    rpcUrls: Readonly<Record<number, readonly string[]>>;
+    /** Told when the chain's AddressProvider lists another router than the pinned one (never acted on). Default console.warn. */
+    onWarning?: (message: string) => void;
+}
+/**
+ * On-chain checks shared by the provider and {@link curveRemotePins}: the pinned router's code hash and version (once
+ * per chain; the AddressProvider's id 2 only compared), and a sealed quote re-checked right before broadcast.
+ */
+declare function curveOnChain(opts: CurveOnChainOptions): {
+    rpc: (chainId: number, calls: RpcCall[], signal?: AbortSignal) => Promise<(unknown | null)[]>;
+    verifyDeployment: (chainId: number) => Promise<void>;
+    checkSealed: (quote: Quote, tx: UnsignedTx) => Promise<string | null>;
+    inspectSealed: (quote: Quote, tx: UnsignedTx, probe: boolean) => Promise<string | {
+        out: bigint;
+        probeOut: bigint | null;
+        amount: bigint;
+        minDy: bigint;
+    }>;
+};
+/**
+ * How far the device's own auto slippage may sit under the backend's before a remote build's minimum counts as too low:
+ * the backend sized it from its probe at quote time, the device from a fresh one, and half the impact moves it.
+ */
+declare const CURVE_AUTO_SLIPPAGE_DRIFT_BPS = 5;
+interface CurveRemotePinsOptions extends CurveOnChainOptions {
+    /** The backend provider's `defaultSlippageBps`, when it sets one (a build's minimum is bounded by it). Default: auto slippage. */
+    defaultSlippageBps?: number;
+}
+/**
+ * {@link curvePins} plus `verifyBuild`: a remote Curve build checked on the client — {@link curveVerifyQuote} on the
+ * request it answered, then on chain (over the app's own RPCs) the pinned router (code and version, once per chain),
+ * each hop pool's pinned code and coins, and a fresh `get_dy` of the exact route at or above the minimum. The quote's
+ * figures are then held to that fresh `get_dy` (§5.3 C9: the minimum is the device's own): `destAmount` no more than the
+ * slippage above it, and `min_dy` no more than the slippage below it (or below `destAmount`, if lower) — the request's
+ * `slippageBps`, else `defaultSlippageBps`, else the provider's auto slippage re-derived here from a fresh 1/1000 probe
+ * (plus {@link CURVE_AUTO_SLIPPAGE_DRIFT_BPS}). A backend naming `min_dy = 1` or an inflated output is refused.
+ * `remoteProvider({name: "curve", baseUrl, ...curveRemotePins({rpcUrls})})`.
+ */
+declare function curveRemotePins(opts: CurveRemotePinsOptions): RemotePins & {
+    verifyBuild(quote: Quote, tx: UnsignedTx, params?: QuoteParams): Promise<string | null>;
+};
+
+/**
+ * Labels for the contracts a Curve swap touches on `chainId`, for tx-preview's `known` (address → label): the pinned
+ * Router NG (and Ethereum's older routers, so history reads), every allowlisted pool, the wrapped native the router's
+ * wrap hop uses and, on Ethereum, the scrvUSD vault. Empty for a chain without a pinned router.
+ */
+declare function curveKnownContracts(chainId: number, tables?: {
+    deployments?: Readonly<Record<number, CurveDeployment>>;
+    pools?: Readonly<Record<number, CurveChainPools>>;
+}): Record<string, string>;
+
+/** Curated Curve pools per chain id. A chain missing here has no pool that passed the rules. */
+declare const CURVE_POOLS: Readonly<Record<number, CurveChainPools>>;
+
+export { ADDRESS_PROVIDER_ABI, COINS_INT, COINS_UINT, CURVE_AUTO_SLIPPAGE_DRIFT_BPS, CURVE_POOLS, CurveChainPools, CurveDeployment, type CurveOnChainOptions, CurvePool, type CurveRemotePinsOptions, type CurveRoute, CurveRouterFamily, type CurveStep, type CurveTables, type DecodedExchange, EXCHANGE_SELECTOR, EXCHANGE_TOPIC, GET_DY_SELECTOR, MAX_QUOTE_CANDIDATES, ROUTER_LITE4_ABI, ROUTER_NG5_ABI, ROUTER_SELECTORS, type RouterArgs, type RpcCall, VERSION_ABI, checkRoute, curveKnownContracts, curveOnChain, curvePins, curveQuoteCheck, curveRemotePins, curveVerifyQuote, decodeExchange, encodeExchange, encodeGetDy, findRoutes, intermediateAllowed, poolIndex, poolTypeAllowed, routeArgs, routePools, underlyingAllowed };