@eco-incorp/sauce 0.99.3 → 0.99.5

package/actions/dist/spec.js

@@ -0,0 +1,323 @@
+// ---- field kinds ----------------------------------------------------------------------------
+const address = { k: "address" };
+const recipient = { k: "recipient" };
+const remoteRecipient = { k: "remoteRecipient" };
+const uint256 = { k: "uint", bits: 256 };
+const uint128 = { k: "uint", bits: 128 };
+const uint160 = { k: "uint", bits: 160 };
+const bytes = { k: "bytes" };
+const bytes32 = { k: "bytes32" };
+const bool = { k: "bool" };
+const int = (min, max) => ({ k: "int", min, max });
+const uintN = (bits) => int(0, bits >= 53 ? Number.MAX_SAFE_INTEGER : 2 ** bits - 1);
+const seconds = uintN(53);
+const f = (kind, doc) => ({ kind, doc });
+const opt = (kind, doc) => ({ kind, doc, optional: true });
+const RECIPIENT = f(recipient, 'receives the output when no later action spends it; `"self"` keeps it in the Pot');
+const MIN_OUT = f(uint256, "the least output accepted; the venue reverts below it");
+const DEADLINE = f(seconds, "Unix seconds after which the venue reverts");
+const spec = (group, defaults) => (type, summary, calls, fields, extra = {}) => ({ type, group, summary, calls, spends: true, ...defaults, fields, ...extra });
+const swap = spec("swap", { output: "realized" });
+const bridge = spec("bridge", { output: "passThrough" });
+const wrap = spec("wrap", { output: "realized" });
+const stake = spec("stake", { output: "realized" });
+const lending = spec("lending", { output: "passThrough" });
+const token = spec("token", { output: "passThrough" });
+const source = spec("source", { output: "value" });
+const SPECS = [
+    // -- swaps ----------------------------------------------------------------------------------
+    swap("uniswapV3ExactInput", "Swaps an exact input through one Uniswap V3 pool.", "SwapRouter02.exactInputSingle", {
+        router: f(address, "the SwapRouter02"),
+        tokenIn: f(address, "the token sold"),
+        tokenOut: f(address, "the token bought"),
+        fee: f({ k: "enum", values: [100, 500, 3000, 10000] }, "the pool's fee tier, in hundredths of a bip"),
+        amountOutMin: MIN_OUT,
+        sqrtPriceLimitX96: opt(uint160, "a price limit; absent or 0 for none"),
+        recipient: RECIPIENT,
+    }),
+    swap("uniswapV3ExactInputMultiHop", "Swaps an exact input along a packed Uniswap V3 path.", "SwapRouter02.exactInput", {
+        router: f(address, "the SwapRouter02"),
+        path: f(bytes, "the packed path: token ++ fee (3 bytes) ++ token ++ …"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+    }),
+    swap("uniswapV4ExactInput", "Swaps an exact ERC-20 input through one Uniswap V4 pool via the Universal Router.", "an ERC-20 transfer to the router, then UniversalRouter.execute (V4_SWAP: swap, settle, take)", {
+        router: f(address, "the Universal Router"),
+        poolKey: f({
+            k: "object",
+            fields: {
+                currency0: f(address, "the pool's lower currency"),
+                currency1: f(address, "the pool's higher currency"),
+                fee: f(uintN(24), "the pool fee, in hundredths of a bip"),
+                tickSpacing: f(int(1, 32767), "the pool's tick spacing"),
+                hooks: f(address, "the pool's hooks contract, or the zero address"),
+            },
+        }, "the V4 pool key"),
+        zeroForOne: f(bool, "true sells currency0 for currency1"),
+        amountOutMin: f(uint128, "the least output accepted; the router reverts below it"),
+        recipient: RECIPIENT,
+    }),
+    swap("uniswapV4ExactInputMultiHop", "Swaps an exact ERC-20 input along a Uniswap V4 path via the Universal Router.", "an ERC-20 transfer to the router, then UniversalRouter.execute (V4_SWAP: swap, settle, take)", {
+        router: f(address, "the Universal Router"),
+        currencyIn: f(address, "the currency sold"),
+        path: f({
+            k: "array",
+            min: 1,
+            of: {
+                k: "object",
+                fields: {
+                    intermediateCurrency: f(address, "the currency this hop buys"),
+                    fee: f(uintN(24), "the hop's pool fee"),
+                    tickSpacing: f(int(1, 32767), "the hop's pool tick spacing"),
+                    hooks: f(address, "the hop's pool hooks, or the zero address"),
+                },
+            },
+        }, "the hops, in order; the last hop's currency is the output"),
+        amountOutMin: f(uint128, "the least output accepted; the router reverts below it"),
+        recipient: RECIPIENT,
+    }),
+    swap("curveSwap", "Swaps through a Curve pool's 4-argument `exchange`; the output is a balance delta.", "pool.exchange(int128,int128,uint256,uint256)", {
+        pool: f(address, "the Curve pool"),
+        tokenOut: f(address, "the token bought, whose balance delta is the output"),
+        i: f(int(0, 7), "the pool index of the coin sold"),
+        j: f(int(0, 7), "the pool index of the coin bought"),
+        amountOutMin: MIN_OUT,
+        recipient: f(recipient, `${RECIPIENT.doc}; the pool pays the Pot, which forwards it with a transfer`),
+    }),
+    swap("curveRouterNGSwap", "Swaps along a Curve RouterNG route of up to five hops.", "RouterNG.exchange(address[11],uint256[5][5],uint256,uint256,address[5],address)", {
+        router: f(address, "the Curve RouterNG"),
+        route: f({ k: "array", of: address, min: 1, max: 11 }, "the route; padded to 11 with zero addresses"),
+        swapParams: f({
+            k: "array",
+            min: 1,
+            max: 5,
+            of: { k: "tuple", of: [int(0, 255), int(0, 255), int(0, 255), int(0, 255), int(0, 255)] },
+        }, "per hop: [i, j, swap_type, pool_type, n_coins]; padded to 5 rows"),
+        pools: f({ k: "array", of: address, max: 5 }, "a zap pool where a hop needs one; padded to 5"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+    }),
+    swap("balancerV2Swap", "Swaps through one Balancer V2 pool.", "Vault.swap", {
+        vault: f(address, "the Balancer V2 Vault"),
+        poolId: f(bytes32, "the pool id"),
+        tokenIn: f(address, "the token sold"),
+        tokenOut: f(address, "the token bought"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+        deadline: DEADLINE,
+    }),
+    swap("balancerV2BatchSwap", "Swaps along Balancer V2 pools in one batch; the output is a balance delta.", "Vault.batchSwap", {
+        vault: f(address, "the Balancer V2 Vault"),
+        steps: f({
+            k: "array",
+            min: 1,
+            of: {
+                k: "object",
+                fields: {
+                    poolId: f(bytes32, "the step's pool id"),
+                    assetInIndex: f(int(0, 255), "index into `assets` of the step's input"),
+                    assetOutIndex: f(int(0, 255), "index into `assets` of the step's output"),
+                    amount: f(uint256, "the step's input; 0 spends the previous step's output"),
+                },
+            },
+        }, "the batch's steps; the last step's output asset is the output"),
+        assets: f({ k: "array", of: address, min: 2 }, "every asset the steps index"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+        deadline: DEADLINE,
+    }, { spends: false }),
+    swap("balancerV3Swap", "Swaps an exact input through one Balancer V3 pool; the router pays the Pot and pulls " +
+        "through Permit2.", "Router.swapSingleTokenExactIn", {
+        router: f(address, "the Balancer V3 Router"),
+        pool: f(address, "the pool"),
+        tokenIn: f(address, "the token sold"),
+        tokenOut: f(address, "the token bought"),
+        amountOutMin: MIN_OUT,
+        deadline: DEADLINE,
+        wethIsEth: f(bool, "true to pay or receive native ETH for WETH"),
+    }),
+    swap("uniswapV2Swap", "Swaps an exact input along a Uniswap V2 path; the output is a balance delta.", "UniswapV2Router.swapExactTokensForTokens", {
+        router: f(address, "the V2 router"),
+        path: f({ k: "array", of: address, min: 2 }, "the token path; the last token is the output"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+        deadline: DEADLINE,
+    }),
+    swap("ambientSwap", "Swaps through an Ambient (CrocSwap) pool; the dex pays the Pot, and the output is a balance delta.", "CrocSwapDex.userCmd(1, abi.encode(...))", {
+        dex: f(address, "the CrocSwapDex"),
+        base: f(address, "the pool's base token (numerically lower)"),
+        quote: f(address, "the pool's quote token"),
+        poolIdx: f(uintN(53), "the pool type index (420 is the standard pool)"),
+        isBuy: f(bool, "true pays base and receives quote"),
+        inBaseQty: f(bool, "true when the amount is denominated in the base token"),
+        tip: f(uintN(16), "0 accepts the pool's default fee"),
+        limitPrice: f(uint128, "the worst acceptable price, as a Q64.64 square-root price"),
+        amountOutMin: f(uint128, "the least output accepted; the dex reverts below it"),
+        reserveFlags: f(uintN(8), "0x1 settles base from surplus, 0x2 quote"),
+    }),
+    swap("dodoSwap", "Swaps through DODO pairs via the DODO proxy, which pays the Pot.", "DODOProxy.dodoSwapV2TokenToToken (or dodoSwapV1)", {
+        proxy: f(address, "the DODO proxy; approvals go to DODOApprove, not to it"),
+        fromToken: f(address, "the token sold"),
+        toToken: f(address, "the token bought"),
+        pairs: f({ k: "array", of: address, min: 1 }, "the pairs to route through"),
+        directions: f(uintN(53), "a bit per pair: 0 sells base, 1 sells quote"),
+        amountOutMin: MIN_OUT,
+        deadline: DEADLINE,
+        version: opt({ k: "enum", values: ["v1", "v2"] }, '"v1" routes legacy Classical pairs through `dodoSwapV1`; default "v2"'),
+    }),
+    swap("maverickSwap", "Swaps an exact input through one Maverick V2 pool.", "MaverickV2Router.exactInputSingle", {
+        router: f(address, "the Maverick V2 router"),
+        pool: f(address, "the pool"),
+        tokenAIn: f(bool, "true sells the pool's token A"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+    }),
+    swap("maverickMultiHopSwap", "Swaps an exact input along a packed Maverick V2 path.", "MaverickV2Router.exactInputMultiHop", {
+        router: f(address, "the Maverick V2 router"),
+        path: f(bytes, "per hop, the pool's 20 bytes then one byte: 1 sells token A, 0 token B"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+    }),
+    swap("carbonSwap", "Trades against Carbon strategies by source amount; the controller pays the Pot.", "CarbonController.tradeBySourceAmount", {
+        controller: f(address, "the CarbonController"),
+        sourceToken: f(address, "the token sold"),
+        targetToken: f(address, "the token bought"),
+        tradeActions: f({
+            k: "array",
+            min: 1,
+            of: {
+                k: "object",
+                fields: {
+                    strategyId: f(uint256, "the strategy"),
+                    amount: f(uint128, "the source amount traded against it"),
+                },
+            },
+        }, "the source amount per strategy; together they are the trade"),
+        amountOutMin: f(uint128, "the least output accepted; the controller reverts below it"),
+        deadline: DEADLINE,
+    }, { spends: false }),
+    swap("fraxswapSwap", "Swaps an exact input along a Fraxswap path; the output is a balance delta.", "FraxswapRouter.swapExactTokensForTokens", {
+        router: f(address, "the Fraxswap router"),
+        path: f({ k: "array", of: address, min: 2 }, "the token path; the last token is the output"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+        deadline: DEADLINE,
+    }),
+    swap("fluidDexT1Swap", "Swaps an exact ERC-20 input through a Fluid DEX T1 pool.", "FluidDexT1.swapIn", {
+        pool: f(address, "the pool"),
+        swap0to1: f(bool, "true sells token0"),
+        amountOutMin: MIN_OUT,
+        recipient: RECIPIENT,
+    }),
+    // -- bridges --------------------------------------------------------------------------------
+    bridge("acrossBridge", "Deposits into an Across SpokePool for the same token on the destination, less the relayer fee.", "SpokePool.depositV3", {
+        spokePool: f(address, "the origin SpokePool; it pulls the token, so approve it first"),
+        token: f(address, "the token bridged (input and output)"),
+        destChainId: f(int(1, Number.MAX_SAFE_INTEGER), "the destination chain id"),
+        recipient: f(address, "receives on the destination"),
+        relayerFee: f(uint256, "kept by the relayer: the destination receives `amount - relayerFee`"),
+        quoteTimestamp: f(uintN(32), "the timestamp the fee was quoted at"),
+        fillDeadline: f(uintN(32), "Unix seconds by which a relayer must fill"),
+        exclusivityDeadline: f(uintN(32), "Unix seconds of relayer exclusivity; 0 for none"),
+        message: f(bytes, "delivered with the fill; 0x for none"),
+    }),
+    bridge("stargateBridge", "Sends through a Stargate V2 ERC-20 pool (taxi), paying the LayerZero fee it quotes.", "StargatePool.quoteSend, then StargatePool.send", {
+        pool: f(address, "the StargatePool; it pulls the token, so approve it first"),
+        dstEid: f(uintN(32), "the destination's LayerZero endpoint id"),
+        recipient: f(remoteRecipient, "receives on the destination"),
+        amountOutMin: f(uint256, "the least the destination may receive"),
+    }, { value: "the quoted native fee, from the Pot" }),
+    bridge("cctpBridge", "Burns USDC through Circle's CCTP V2 TokenMessenger for minting on the destination.", "TokenMessengerV2.depositForBurn", {
+        tokenMessenger: f(address, "the CCTP V2 TokenMessenger; it pulls the token, so approve it first"),
+        token: f(address, "the burned token (USDC)"),
+        destinationDomain: f(uintN(32), "the destination's CCTP domain"),
+        recipient: f(remoteRecipient, "receives the mint on the destination"),
+        maxFee: opt(uint256, 'the most the transfer may pay in fees, from the amount; default "0"'),
+        minFinalityThreshold: opt(uintN(32), "2000 waits for finality (standard, the default); 1000 is fast"),
+    }),
+    bridge("hyperlaneBridge", "Transfers through a Hyperlane ERC-20 warp route, paying the interchain gas it quotes.", "TokenRouter.quoteGasPayment, then TokenRouter.transferRemote", {
+        router: f(address, "the warp route; it pulls the amount plus any fee it charges"),
+        destinationDomain: f(uintN(32), "the destination's Hyperlane domain"),
+        recipient: f(remoteRecipient, "receives on the destination"),
+    }, { value: "the quoted gas payment, from the Pot" }),
+    // -- wrapping -------------------------------------------------------------------------------
+    wrap("wrapETH", "Wraps native ETH into WETH.", "WETH.deposit", { weth: f(address, "the WETH contract") }, { output: "passThrough", value: "amount" }),
+    wrap("unwrapETH", "Unwraps WETH into native ETH.", "WETH.withdraw", { weth: f(address, "the WETH contract") }, { output: "passThrough" }),
+    wrap("wrapStETH", "Wraps stETH into wstETH; the output is the wstETH minted.", "wstETH.wrap", {
+        wstETH: f(address, "the wstETH contract; it pulls the stETH, so approve it first"),
+    }),
+    wrap("unwrapStETH", "Unwraps wstETH; the output is the stETH returned.", "wstETH.unwrap", {
+        wstETH: f(address, "the wstETH contract"),
+    }),
+    // -- staking --------------------------------------------------------------------------------
+    stake("lidoStake", "Stakes native ETH with Lido; the output is the stETH received.", "stETH.submit", {
+        stETH: f(address, "the stETH contract"),
+        referral: opt(address, "Lido's referral; default the zero address"),
+    }, { value: "amount" }),
+    stake("lidoUnstake", "Requests a Lido withdrawal of stETH; the ETH is claimed later with the withdrawal NFT.", "WithdrawalQueueERC721.requestWithdrawals", {
+        withdrawalQueue: f(address, "Lido's withdrawal queue; it pulls the stETH, so approve it first"),
+        owner: f(recipient, 'receives the withdrawal NFT; `"self"` is the Pot'),
+    }, { output: "passThrough" }),
+    stake("rocketPoolStake", "Stakes native ETH with Rocket Pool; the output is the rETH received.", "RocketDepositPool.deposit", {
+        depositPool: f(address, "the live RocketDepositPool, which upgrades move; read it from RocketStorage"),
+        rETH: f(address, "the rETH token, whose balance delta is the output"),
+    }, { value: "amount" }),
+    stake("rocketPoolUnstake", "Burns rETH; the output is the ETH received.", "rETH.burn", {
+        rETH: f(address, "the rETH token"),
+    }),
+    stake("etherFiStake", "Stakes native ETH with ether.fi; the output is the eETH received.", "LiquidityPool.deposit", {
+        liquidityPool: f(address, "the ether.fi LiquidityPool"),
+        eETH: f(address, "the eETH token, whose balance delta is the output"),
+    }, { value: "amount" }),
+    // -- lending --------------------------------------------------------------------------------
+    lending("aaveV3Supply", "Supplies a token to Aave V3.", "Pool.supply", {
+        pool: f(address, "the Aave V3 Pool; it pulls the token, so approve it first"),
+        token: f(address, "the asset supplied"),
+        onBehalfOf: f(recipient, 'credited with the position; `"self"` is the Pot'),
+        referralCode: opt(uintN(16), "Aave's referral code; default 0"),
+    }),
+    lending("aaveV3Withdraw", "Withdraws a token from Aave V3; the output is the amount withdrawn.", "Pool.withdraw", {
+        pool: f(address, "the Aave V3 Pool"),
+        token: f(address, "the asset withdrawn"),
+        recipient: f(recipient, 'receives the asset; `"self"` is the Pot'),
+    }, { output: "realized" }),
+    lending("aaveV3Borrow", "Borrows a token from Aave V3 at the variable rate, the only rate it offers.", "Pool.borrow", {
+        pool: f(address, "the Aave V3 Pool"),
+        token: f(address, "the asset borrowed"),
+        onBehalfOf: f(recipient, 'whose collateral backs the debt; `"self"` is the Pot'),
+        referralCode: opt(uintN(16), "Aave's referral code; default 0"),
+    }),
+    lending("aaveV3Repay", "Repays an Aave V3 variable-rate debt.", "Pool.repay", {
+        pool: f(address, "the Aave V3 Pool; it pulls the token, so approve it first"),
+        token: f(address, "the asset repaid"),
+        onBehalfOf: f(recipient, 'whose debt is repaid; `"self"` is the Pot'),
+    }),
+    lending("compoundV3Supply", "Supplies a token to a Compound V3 (Comet) market.", "Comet.supply", {
+        comet: f(address, "the Comet market; it pulls the token, so approve it first"),
+        token: f(address, "the asset supplied"),
+    }),
+    lending("compoundV3Withdraw", "Withdraws a token from a Compound V3 (Comet) market.", "Comet.withdraw", {
+        comet: f(address, "the Comet market"),
+        token: f(address, "the asset withdrawn"),
+    }),
+    // -- tokens ---------------------------------------------------------------------------------
+    token("transfer", "Transfers an ERC-20 token.", "ERC-20 transfer, checked like SafeERC20", {
+        token: f(address, "the token"),
+        recipient: f(recipient, 'the receiver; `"self"` is the Pot'),
+    }),
+    token("approve", "Approves an ERC-20 spender, resetting a non-zero allowance first.", "ERC-20 approve, checked and reset like SafeERC20.forceApprove", { token: f(address, "the token"), spender: f(address, "the spender") }),
+    token("permit2Approve", "Grants a spender a Permit2 allowance; the token must also be approved to Permit2.", "Permit2.approve(address,address,uint160,uint48)", {
+        permit2: f(address, "Permit2 (0x000000000022D473030F116dDEE9F6B43aC78BA3)"),
+        token: f(address, "the token"),
+        spender: f(address, "the spender, such as Balancer V3's router"),
+        expiration: f(uintN(48), "Unix seconds after which the allowance lapses"),
+    }),
+    // -- sources --------------------------------------------------------------------------------
+    source("balanceOf", "Reads the Pot's balance of a token; the output is that balance.", "IERC20.balanceOf(pot)", { token: f(address, "the token") }, { spends: false }),
+    source("nativeBalance", "Reads the Pot's native balance; the output is that balance.", "ctx.selfBalance()", {}, { spends: false }),
+    source("argument", "Declares a runtime argument of the compiled program; the output is the value supplied.", "a `main` parameter", { name: f({ k: "identifier" }, "the argument's name; arguments are encoded in order") }, { spends: false }),
+];
+/** Every action's specification, by `type`. */
+export const ACTION_SPECS = Object.fromEntries(SPECS.map((s) => [s.type, s]));
+/** Every action `type`, in reference order. */
+export const ACTION_TYPES = SPECS.map((s) => s.type);

package/actions/dist/split-swap.d.ts

@@ -0,0 +1,35 @@
+import { type CompiledProgram } from "./compose.js";
+import { type QuoteOptions } from "./to-quote.js";
+import type { ApproveAction, SwapAction } from "./types.js";
+type Address = `0x${string}`;
+/** A swap of `amount` split greedily, `buckets` slices at a time, across `candidates`. */
+export interface SplitSwap {
+    /**
+     * The venues to split across. Each is an ordinary swap action without `amount`, `amountRef` or
+     * `saveOutputAs` — the split decides its amount — and must have an on-chain quote with a fixed
+     * amount offset (every venue but Uniswap V4, Balancer and Carbon). Each delivers to the Pot.
+     */
+    readonly candidates: readonly SwapAction[];
+    /** The total input, a base-10 string divisible by `buckets`. */
+    readonly amount: string;
+    /** How many equal slices the greedy allocation hands out; at least 1. */
+    readonly buckets: number;
+    /**
+     * The least total output, checked once after every leg — a per-leg floor cannot express it,
+     * because a leg's share is decided at runtime. Required: `"0"` waives it deliberately.
+     */
+    readonly amountOutMin: string;
+    /** Approvals to run first, each with an explicit `amount`. */
+    readonly approvals?: readonly ApproveAction[];
+    /** Sends the total output of `token` to `recipient` at the end; omit to keep it in the Pot. */
+    readonly sweep?: {
+        readonly token: Address;
+        readonly recipient: Address;
+    };
+    /** The quoter contracts the candidates price through. */
+    readonly quoters?: QuoteOptions;
+}
+/** Compiles a split swap into one program. It takes no runtime arguments. */
+export declare function compileSplitSwap(swap: SplitSwap): CompiledProgram;
+export {};
+//# sourceMappingURL=split-swap.d.ts.map

package/actions/dist/split-swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-swap.d.ts","sourceRoot":"","sources":["../src/split-swap.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAY,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAG9D,OAAO,EAAa,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE5D,KAAK,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAE7B,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,UAAU,EAAE,CAAC;IAC3C,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,+FAA+F;IAC/F,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAC1E,yDAAyD;IACzD,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;CACjC;AAID,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CAoFjE"}

package/actions/dist/split-swap.js

@@ -0,0 +1,175 @@
+/**
+ * Greedy split routing across several venues, as ONE SauceScript program.
+ *
+ * Declared functions:
+ *   quote_i(amount)        One per candidate; invokes the venue's quoter with a runtime amount.
+ *   quote_any(idx, amount) if/else dispatch to the matching quote_i.
+ *   swap_any(idx, amount)  Same dispatch, but executing the swap; returns what it realized.
+ *   main()                 The three passes below.
+ *
+ * Main algorithm (all three passes are real `for` loops — the per-candidate state lives in
+ * transient storage keyed by `i`):
+ *   1. Init:    for i in 0..N-1 { marg[i] = quote_any(i, bucket); }
+ *               used[i] and total[i] default to 0 (TLOAD of untouched keys).
+ *   2. Greedy:  for iter in 0..n-1 {
+ *                 for i in 0..N-1 argmax → (bestMarg, bestIdx);
+ *                 used[bestIdx]  += 1;
+ *                 total[bestIdx] += marg[bestIdx];          // cached, no call
+ *                 marg[bestIdx]   = quote_any(bestIdx, (used[bestIdx]+1)*bucket)
+ *                                    - total[bestIdx];
+ *               }
+ *   3. Execute: for i in 0..N-1 if (used[i] > 0) swap_any(i, used[i]*bucket);
+ *
+ * The compiler's constant folder UNROLLS a loop whose bound it knows, and `N`/`n` are compile-time
+ * constants here, so the emitted main is O(N + n·N) instructions.
+ */
+import { formatBigint, fn, indent, newEmitter, } from "./emit.js";
+import { contractsFor } from "./abis.js";
+import { compiled } from "./compose.js";
+import { parseActions } from "./program.js";
+import { lowerAction } from "./to-sauce.js";
+import { quoteCall } from "./to-quote.js";
+const UINT_RE = /^(0|[1-9][0-9]*)$/;
+/** Compiles a split swap into one program. It takes no runtime arguments. */
+export function compileSplitSwap(swap) {
+    const candidates = parseActions(swap.candidates, "candidates");
+    candidates.forEach((candidate, i) => {
+        for (const key of ["amount", "amountRef", "saveOutputAs"]) {
+            if (candidate[key] !== undefined) {
+                throw new Error(`candidates[${i}].${key}: a split-swap candidate's amount is decided by the split; remove it`);
+            }
+        }
+    });
+    const approvals = parseActions(swap.approvals ?? [], "approvals");
+    approvals.forEach((approval, i) => {
+        if (approval.type !== "approve" || approval.amount === undefined) {
+            throw new Error(`approvals[${i}]: expected an \`approve\` action with an explicit \`amount\``);
+        }
+    });
+    if (candidates.length === 0)
+        throw new Error("a split swap needs at least one candidate");
+    const n = swap.buckets;
+    if (!Number.isSafeInteger(n) || n < 1) {
+        throw new Error(`buckets must be a positive integer, got ${n}`);
+    }
+    for (const key of ["amount", "amountOutMin"]) {
+        if (typeof swap[key] !== "string" || !UINT_RE.test(swap[key])) {
+            throw new Error(`${key} must be a base-10 unsigned integer string, got ${JSON.stringify(swap[key])}` +
+                (key === "amountOutMin" ? ' — pass "0" to waive the floor deliberately' : ""));
+        }
+    }
+    const amount = BigInt(swap.amount);
+    if (amount % BigInt(n) !== 0n) {
+        throw new Error(`amount (${amount}) must be divisible by buckets (${n}) — a remainder would stay in the Pot under the approvals`);
+    }
+    const bucket = amount / BigInt(n);
+    if (bucket === 0n)
+        throw new Error(`amount (${amount}) must be at least buckets (${n})`);
+    const N = candidates.length;
+    const emit = newEmitter();
+    const bindings = new Set();
+    const use = (result) => {
+        for (const b of result.bindings)
+            bindings.add(b);
+        return result;
+    };
+    const quoteFns = candidates.map((candidate, i) => {
+        const dynamic = quoteCall(candidate, bucket, swap.quoters).toSauceDynamic;
+        if (!dynamic) {
+            throw new Error(`candidates[${i}] (${candidate.type}) has no on-chain quote with a runtime amount, which a split needs`);
+        }
+        const quote = dynamic(emit, "amount");
+        return fn(`quote_${i}`, ["amount: Uint256"], "Uint256", [
+            ...quote.stmts,
+            `return ${quote.expr};`,
+        ]);
+    });
+    const quoteAny = fn("quote_any", ["idx: Uint256", "amount: Uint256"], "Uint256", [
+        ...outOfRangeGuard(N),
+        ...returnDispatch(N, (i) => `return quote_${i}(amount);`),
+    ]);
+    // Every leg is lowered as consumed (`needsOutput`): it delivers to the Pot and returns what it
+    // realized, which the execute pass sums for the aggregate floor.
+    const swapAny = fn("swap_any", ["idx: Uint256", "amount: Uint256"], "Uint256", [
+        ...outOfRangeGuard(N),
+        ...blockDispatch(N, (i) => {
+            const built = use(lowerAction(emit, candidates[i], "amount", true));
+            return [...built.stmts, `return ${built.output};`];
+        }),
+    ]);
+    const main = mainFn(emit, N, n, bucket, swap, approvals, use);
+    const source = [...quoteFns, quoteAny, swapAny, main].join("\n\n") + "\n";
+    return compiled(source, contractsFor(bindings), []);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Dispatchers
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Turns an otherwise-silent fall-through (any out-of-range idx would land on branch N-1) into an
+ * explicit revert, so callers can't accidentally route an invalid index to the last candidate.
+ */
+function outOfRangeGuard(N) {
+    return [`if (idx >= ${N}n) { revert(); }`];
+}
+/** `if (idx == 0) return …; … return <last>;` — every path returns. */
+function returnDispatch(N, branch) {
+    const early = Array.from({ length: N - 1 }, (_, i) => `if (idx == ${i}n) { ${branch(i)} }`);
+    return [...early, branch(N - 1)];
+}
+/** `if (idx == 0) { … } else if … else { <last> }` — exactly one branch runs. */
+function blockDispatch(N, branch) {
+    if (N === 1)
+        return [...branch(0)];
+    const lines = [];
+    for (let i = 0; i < N - 1; i++) {
+        lines.push(`${i === 0 ? "" : "} else "}if (idx == ${i}n) {`);
+        lines.push(indent(branch(i)));
+    }
+    lines.push("} else {");
+    lines.push(indent(branch(N - 1)));
+    lines.push("}");
+    return lines;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// main
+// ─────────────────────────────────────────────────────────────────────────────
+function mainFn(emit, N, n, bucket, swap, approvals, use) {
+    // Transient-storage key layout (compile-time bases; indexed at runtime):
+    //   used[i]  at key i
+    //   total[i] at key N + i
+    //   marg[i]  at key 2N + i
+    const key = (base, idx) => (base === 0 ? idx : `${base}n + ${idx}`);
+    const used = (idx) => `evm.tload(${key(0, idx)})`;
+    const total = (idx) => `evm.tload(${key(N, idx)})`;
+    const marg = (idx) => `evm.tload(${key(2 * N, idx)})`;
+    const bucketExpr = formatBigint(bucket);
+    const body = [];
+    for (const approval of approvals) {
+        body.push(...use(lowerAction(emit, approval, formatBigint(BigInt(approval.amount)), false)).stmts);
+    }
+    // Init loop: marg[i] = quote_any(i, bucket).
+    body.push(`for (let i = 0n; i < ${N}n; i = i + 1n) {`, `  evm.tstore(${key(2 * N, "i")}, quote_any(i, ${bucketExpr}));`, "}");
+    // Greedy loop.
+    body.push("let bestMarg = 0n;", "let bestIdx = 0n;", `for (let iter = 0n; iter < ${n}n; iter = iter + 1n) {`, "  bestMarg = 0n;", "  bestIdx = 0n;", `  for (let j = 0n; j < ${N}n; j = j + 1n) {`, `    if (${marg("j")} > bestMarg) {`, `      bestMarg = ${marg("j")};`, "      bestIdx = j;", "    }", "  }", 
+    // Allocate only when some venue actually pays. With every marginal at zero the argmax leaves
+    // bestIdx at 0, so the old code walked used[0] up to n and sent the WHOLE trade to candidate 0.
+    "  if (bestMarg > 0n) {", `    evm.tstore(${key(0, "bestIdx")}, ${used("bestIdx")} + 1n);`, `    evm.tstore(${key(N, "bestIdx")}, ${total("bestIdx")} + ${marg("bestIdx")});`, 
+    // The next marginal, CLAMPED. `-` is checked on both engines (compiler/README.md's ledger: the
+    // EVM's Math.huff checks add/sub/mul natively), so a quote that comes back below the running
+    // total does not wrap — it REVERTS, killing the whole route. Quotes are not guaranteed monotone
+    // across sizes: fee tiers are discontinuous, curves are not concave, and an oracle-backed
+    // quoter can move between two calls in the same transaction.
+    `    let nextQuote = quote_any(bestIdx, (${used("bestIdx")} + 1n) * ${bucketExpr});`, `    let running = ${total("bestIdx")};`, `    evm.tstore(${key(2 * N, "bestIdx")}, nextQuote > running ? nextQuote - running : 0n);`, "  }", "}");
+    // Execute loop: dispatch the swap for every candidate with used > 0, summing what each returns.
+    body.push("let totalOut = 0n;", `for (let k = 0n; k < ${N}n; k = k + 1n) {`, `  if (${used("k")} > 0n) {`, `    totalOut = totalOut + swap_any(k, ${used("k")} * ${bucketExpr});`, "  }", "}");
+    // The aggregate floor, over the realized sum — see `SplitSwap.amountOutMin`.
+    const amountOutMin = BigInt(swap.amountOutMin);
+    if (amountOutMin > 0n) {
+        body.push(`if (totalOut < ${formatBigint(amountOutMin)}) { revert(); }`);
+    }
+    if (swap.sweep) {
+        const { token, recipient } = swap.sweep;
+        body.push(...use(lowerAction(emit, { type: "transfer", token, recipient }, "totalOut", false)).stmts);
+    }
+    return fn("main", [], "void", body);
+}

package/actions/dist/to-quote.d.ts

@@ -2,69 +2,45 @@ import { type Emitter, type Expr, type Fragment } from "./emit.js";
 import type { SwapAction } from "./types.js";
 type Address = `0x${string}`;
 type Hex = `0x${string}`;
-/** Result of compiling a swap action into a quote call. */
-export interface QuoteCall {
-    /** Contract to call via eth_call */
-    to: Address;
-    /** ABI-encoded calldata */
-    data: Hex;
-    /** Decode the raw eth_call result into the output amount */
-    decode: (result: Hex) => bigint;
-    /**
-     * Emit the SauceScript that performs the on-chain quote call, plus the expression yielding the
-     * output amount. Every quote extracts to a single uint256 regardless of the underlying return
-     * shape.
-     *
-     * Absent when the protocol's quote cannot run on-chain at all, so its presence is the signal that
-     * emitting it produces a program that can execute. Callers must check for it.
-     *
-     * BREAKING: took and returned a `Saucer`; takes an `Emitter` and returns a source [`Fragment`].
-     */
-    toSauce?: (emit: Emitter) => Fragment;
+/** A quote as an `eth_call`: send `data` to `to`, and `decode` the result into the output amount. */
+export interface Quote {
+    readonly to: Address;
+    readonly data: Hex;
+    decode(result: Hex): bigint;
+}
+/** A quote, plus its on-chain forms where the protocol's quoter can run inside a transaction. */
+export interface QuoteCall extends Quote {
+    /** The quote as SauceScript statements, leaving the output amount as their expression. */
+    readonly toSauce?: (emit: Emitter) => Fragment;
     /**
-     * Runtime-amount variant: splices `amountExpr` into the calldata at the
-     * protocol's fixed amount offset and returns the uint256 output expression.
-     *
-     * Only present for protocols whose quote calldata has the input amount at
-     * a fixed 32-byte offset (UniV3, Curve, BalV3, Maverick, Clipper, DODO,
-     * Integral, FluidT1, UniV2/Fraxswap routers). Callers that need
-     * runtime-parameterised quoting (e.g. split routing) must check for this
-     * field and error out if absent.
-     *
-     * BREAKING: took and returned `Saucer`s; takes an `Emitter` plus a SauceScript amount
-     * EXPRESSION, and returns a source [`Fragment`].
+     * The same, with the input amount a runtime expression spliced in at the quote's fixed amount
+     * offset — what the split swap needs. Absent where the amount has no fixed offset.
      */
-    toSauceDynamic?: (emit: Emitter, amountExpr: Expr) => Fragment;
+    readonly toSauceDynamic?: (emit: Emitter, amountExpr: Expr) => Fragment;
 }
 /**
- * External contract addresses needed for quoting protocols that use a
- * separate quoter / resolver / impact contract.
+ * The quoter contracts for venues that price through one rather than through the pool or router
+ * the action names.
  */
-export interface QuoteOpts {
-    /** UniswapV3 QuoterV2 address (required for uniswapV3 actions) */
-    quoterV3?: Address;
-    /** UniswapV4 V4Quoter address (required for uniswapV4 actions) */
-    quoterV4?: Address;
-    /** Maverick V2 MaverickV2Quoter address (required for maverick actions) */
-    quoterMaverick?: Address;
-    /** Ambient CrocImpact address (required for ambient actions) */
-    impact?: Address;
-    /** Integral TwapRelayer address (required for integral actions) */
-    relayer?: Address;
-    /** Fluid DexReservesResolver address (required for fluidDexT1 actions) */
-    fluidResolver?: Address;
-    /** Fluid DexLiteResolver address (required for fluidDexLite actions) */
-    fluidLiteResolver?: Address;
+export interface QuoteOptions {
+    /** Uniswap's QuoterV2, for `uniswapV3ExactInput` and `uniswapV3ExactInputMultiHop`. */
+    readonly uniswapV3Quoter?: Address;
+    /** Uniswap's V4Quoter, for `uniswapV4ExactInput` and `uniswapV4ExactInputMultiHop`. */
+    readonly uniswapV4Quoter?: Address;
+    /** The MaverickV2Quoter, for `maverickSwap` and `maverickMultiHopSwap`. */
+    readonly maverickQuoter?: Address;
+    /** Ambient's CrocImpact, for `ambientSwap`. */
+    readonly ambientImpact?: Address;
+    /** Fluid's DexReservesResolver, for `fluidDexT1Swap`. */
+    readonly fluidDexResolver?: Address;
 }
 /**
- * Compile a swap action into calldata for quoting the output amount via `eth_call`.
- *
- * Every supported action resolves to a view or revert-simulation call that
- * does **not** require token balance or approvals.
- *
- * Some protocols use a separate quoter/resolver contract. Pass the relevant
- * address in {@link QuoteOpts} when quoting those protocols.
+ * The `eth_call` that prices `action` at its own `amount` (a Carbon trade or a Balancer batch at
+ * the amounts it carries). None needs a balance or an allowance. Venues that price through a
+ * separate quoter take its address from `options`.
  */
-export declare function actionToQuote(action: SwapAction, amountIn: bigint, opts?: QuoteOpts): QuoteCall;
+export declare function quoteAction(action: SwapAction, options?: QuoteOptions): Quote;
+/** The quote for `action` at `amountIn`, with its on-chain forms where there are any. */
+export declare function quoteCall(action: SwapAction, amountIn: bigint, opts?: QuoteOptions): QuoteCall;
 export {};
 //# sourceMappingURL=to-quote.d.ts.map