@eco-incorp/sauce 0.99.4 → 0.99.5

package/actions/dist/abis.d.ts

@@ -0,0 +1,167 @@
+/**
+ * The ABI bindings action programs call through — one `Binding.at(address).method(...)` per call,
+ * the shape SDK route bodies use.
+ *
+ * WHERE EACH ABI COMES FROM. The SDK's protocol registry (`sdk/src/protocols/<slug>/abis.ts`) is
+ * used whenever it declares the exact function an action calls. "Exact" is checked, not assumed:
+ * `sdk()` below looks the function up by its canonical signature and throws if the registry spells
+ * it differently, because a different spelling is a different selector — a function the contract
+ * does not have. The registry's own suite (`sdk/test/registry-abi.test.ts`) pins each of its
+ * functions to the deployed contracts. Where the registry has no such function — the contract is
+ * not in it, or it declares another overload — the binding declares its fragment here and says why
+ * next to it.
+ *
+ * WHY OUTPUTS ARE DROPPED. A binding decodes every output its ABI declares, even one the program
+ * never reads, and decoding from empty return data reverts. 3pool-era Curve pools return nothing
+ * from `exchange`, so declaring that output would revert a swap that succeeded. The rule here is
+ * therefore: declare an output only when an action reads it. Every other method is bound
+ * output-free — the call must succeed, and nothing is decoded. ERC-20 `approve`/`transfer` are not
+ * bindings at all: tokens such as USDT return nothing from them, and they go through the SDK's own
+ * `SafeERC20` lowering, `token/safe` (see `to-sauce.ts#Lowering.erc20Write`).
+ *
+ * WHY SOME CALLS ARE STILL RAW. A binding call cannot attach native value, and the compiler has no
+ * calldata builtin besides `abi.encode`. So a payable call carrying ETH (`WETH.deposit`, Lido
+ * `submit`, a bridge fee) stays `evm.call(target, value, selector ++ abi.encode(args))`, with the
+ * selector taken from the same ABI fragment a binding would use — see `valueCall` in `to-sauce.ts`.
+ */
+import { type AbiFunction, type Hex } from "viem";
+/** A parsed ABI in the shape the compiler's `inlineContracts` and the SDK's `compile.contracts` take. */
+export interface ActionContract {
+    readonly abi: AbiFunction[];
+}
+/** ABI bindings by the name the emitted source uses for them. */
+export type ActionContracts = Record<string, ActionContract>;
+/** Where a binding's methods come from — kept per method, because some bindings mix both. */
+export type MethodSource = {
+    readonly kind: "sdk";
+    readonly protocol: string;
+    readonly abiExport: string;
+} | {
+    readonly kind: "local";
+    readonly reason: string;
+};
+export interface BoundMethod {
+    readonly fn: AbiFunction;
+    readonly source: MethodSource;
+}
+/** The canonical `name(type,...)` signature, tuples expanded — the string a selector hashes. */
+export declare function canonicalSignature(fn: Pick<AbiFunction, "name" | "inputs">): string;
+/**
+ * The registry function with exactly `signature`, from `abi` (the `abiExport` of `protocol`), as a
+ * plain copy. Throws when the registry has no such function — the signal that it changed under the
+ * action. The bindings below and the quotes in `to-quote.ts` both take registry ABIs through it.
+ */
+export declare function registryFunction(protocol: string, abiExport: string, abi: readonly unknown[], signature: string): AbiFunction;
+/**
+ * Every binding, by the name emitted source calls it. The names start with `I` and contain no `_`,
+ * so none can collide with an SDK protocol namespace (`AaveV3`, `Erc20`), a chain accessor (`Base`)
+ * or a name the route rewrite synthesizes (`IAaveV3_Pool`) — `abis.unit.test.ts` checks all three.
+ */
+declare const CATALOG: {
+    IErc20: () => {
+        balanceOf: BoundMethod;
+    };
+    IWeth9: () => {
+        withdraw: BoundMethod;
+        deposit: BoundMethod;
+    };
+    ISwapRouter02: () => {
+        exactInputSingle: BoundMethod;
+        exactInput: BoundMethod;
+    };
+    IUniversalRouter: () => {
+        execute: BoundMethod;
+    };
+    ICurvePool: () => {
+        exchange: BoundMethod;
+    };
+    ICurveRouterNG: () => {
+        exchange: BoundMethod;
+    };
+    IBalancerV2Vault: () => {
+        swap: BoundMethod;
+        batchSwap: BoundMethod;
+    };
+    IBalancerV3Router: () => {
+        swapSingleTokenExactIn: BoundMethod;
+    };
+    IUniswapV2Router: () => {
+        swapExactTokensForTokens: BoundMethod;
+    };
+    ICrocSwapDex: () => {
+        userCmd: BoundMethod;
+    };
+    IDodoProxy: () => {
+        dodoSwapV2TokenToToken: BoundMethod;
+        dodoSwapV1: BoundMethod;
+    };
+    IMaverickV2Router: () => {
+        exactInputSingle: BoundMethod;
+        exactInputMultiHop: BoundMethod;
+    };
+    ICarbonController: () => {
+        tradeBySourceAmount: BoundMethod;
+    };
+    IFluidDexT1: () => {
+        swapIn: BoundMethod;
+    };
+    IWstEth: () => {
+        wrap: BoundMethod;
+        unwrap: BoundMethod;
+    };
+    ILido: () => {
+        submit: BoundMethod;
+    };
+    ILidoWithdrawalQueue: () => {
+        requestWithdrawals: BoundMethod;
+    };
+    IRocketDepositPool: () => {
+        deposit: BoundMethod;
+    };
+    IRocketTokenReth: () => {
+        burn: BoundMethod;
+    };
+    IEtherFiLiquidityPool: () => {
+        deposit: BoundMethod;
+    };
+    IAaveV3Pool: () => {
+        supply: BoundMethod;
+        withdraw: BoundMethod;
+        borrow: BoundMethod;
+        repay: BoundMethod;
+    };
+    ICometMarket: () => {
+        supply: BoundMethod;
+        withdraw: BoundMethod;
+    };
+    IAcrossSpokePool: () => {
+        depositV3: BoundMethod;
+    };
+    IStargatePool: () => {
+        quoteSend: BoundMethod;
+        send: BoundMethod;
+    };
+    ICctpTokenMessenger: () => {
+        depositForBurn: BoundMethod;
+    };
+    IWarpRoute: () => {
+        quoteGasPayment: BoundMethod;
+        transferRemote: BoundMethod;
+    };
+    IPermit2: () => {
+        approve: BoundMethod;
+    };
+};
+export type BindingName = keyof typeof CATALOG;
+type MethodsOf<B extends BindingName> = ReturnType<(typeof CATALOG)[B]>;
+export type MethodName<B extends BindingName> = keyof MethodsOf<B> & string;
+/** A binding's methods, resolved (and registry-checked) on first use. */
+export declare function bindingMethods(binding: BindingName): Readonly<Record<string, BoundMethod>>;
+/** Every binding name, for tests and documentation. */
+export declare const BINDING_NAMES: BindingName[];
+/** The 4-byte selector of a binding's method, from the same fragment the binding compiles with. */
+export declare function methodSelector<B extends BindingName>(binding: B, method: MethodName<B>): Hex;
+/** The `contracts` map a program naming `bindings` compiles with. */
+export declare function contractsFor(bindings: Iterable<BindingName>): ActionContracts;
+export {};
+//# sourceMappingURL=abis.d.ts.map

package/actions/dist/abis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../src/abis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAGL,KAAK,WAAW,EAEhB,KAAK,GAAG,EACT,MAAM,MAAM,CAAC;AASd,yGAAyG;AACzG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,iEAAiE;AACjE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE7D,6FAA6F;AAC7F,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG,MAAM,CAEnF;AAgBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,SAAS,OAAO,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,WAAW,CAgBb;AAyBD;;;;GAIG;AACH,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6OgD,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,OAAO,CAAC;AAC/C,KAAK,SAAS,CAAC,CAAC,SAAS,WAAW,IAAI,UAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,WAAW,IAAI,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAI5E,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAQ1F;AAED,uDAAuD;AACvD,eAAO,MAAM,aAAa,EAA2B,WAAW,EAAE,CAAC;AAEnE,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAE5F;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,eAAe,CAO7E"}

package/actions/dist/abis.js

@@ -0,0 +1,215 @@
+/**
+ * The ABI bindings action programs call through — one `Binding.at(address).method(...)` per call,
+ * the shape SDK route bodies use.
+ *
+ * WHERE EACH ABI COMES FROM. The SDK's protocol registry (`sdk/src/protocols/<slug>/abis.ts`) is
+ * used whenever it declares the exact function an action calls. "Exact" is checked, not assumed:
+ * `sdk()` below looks the function up by its canonical signature and throws if the registry spells
+ * it differently, because a different spelling is a different selector — a function the contract
+ * does not have. The registry's own suite (`sdk/test/registry-abi.test.ts`) pins each of its
+ * functions to the deployed contracts. Where the registry has no such function — the contract is
+ * not in it, or it declares another overload — the binding declares its fragment here and says why
+ * next to it.
+ *
+ * WHY OUTPUTS ARE DROPPED. A binding decodes every output its ABI declares, even one the program
+ * never reads, and decoding from empty return data reverts. 3pool-era Curve pools return nothing
+ * from `exchange`, so declaring that output would revert a swap that succeeded. The rule here is
+ * therefore: declare an output only when an action reads it. Every other method is bound
+ * output-free — the call must succeed, and nothing is decoded. ERC-20 `approve`/`transfer` are not
+ * bindings at all: tokens such as USDT return nothing from them, and they go through the SDK's own
+ * `SafeERC20` lowering, `token/safe` (see `to-sauce.ts#Lowering.erc20Write`).
+ *
+ * WHY SOME CALLS ARE STILL RAW. A binding call cannot attach native value, and the compiler has no
+ * calldata builtin besides `abi.encode`. So a payable call carrying ETH (`WETH.deposit`, Lido
+ * `submit`, a bridge fee) stays `evm.call(target, value, selector ++ abi.encode(args))`, with the
+ * selector taken from the same ABI fragment a binding would use — see `valueCall` in `to-sauce.ts`.
+ */
+import { parseAbiItem, toFunctionSelector, } from "viem";
+import { AaveV3PoolABI, AcrossSpokePoolABI, BalancerV2VaultABI, CometABI } from "./registry.js";
+import { CrocSwapDexABI, CurveRouterNGABI, CurveThreePoolABI, DODOV2ProxyABI } from "./registry.js";
+import { ERC20ABI, LidoABI, LiquidityPoolABI, MaverickV2RouterABI } from "./registry.js";
+import { Permit2ABI, RETHABI, RocketDepositPoolABI, StargatePoolABI } from "./registry.js";
+import { TokenMessengerABI, UniswapV2RouterABI, UniswapV3SwapRouter02ABI } from "./registry.js";
+import { UniswapV4UniversalRouterABI, WstETHABI } from "./registry.js";
+/** The canonical `name(type,...)` signature, tuples expanded — the string a selector hashes. */
+export function canonicalSignature(fn) {
+    return `${fn.name}(${fn.inputs.map(canonicalType).join(",")})`;
+}
+function canonicalType(param) {
+    if (!param.type.startsWith("tuple"))
+        return param.type;
+    const components = param.components ?? [];
+    return `(${components.map(canonicalType).join(",")})${param.type.slice("tuple".length)}`;
+}
+/** A deep, mutable copy — the registry's ABIs are `as const`, and the compiler gets plain JSON. */
+function plain(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * The registry function with exactly `signature`, from `abi` (the `abiExport` of `protocol`), as a
+ * plain copy. Throws when the registry has no such function — the signal that it changed under the
+ * action. The bindings below and the quotes in `to-quote.ts` both take registry ABIs through it.
+ */
+export function registryFunction(protocol, abiExport, abi, signature) {
+    const found = abi.find((item) => item.type === "function" && canonicalSignature(item) === signature);
+    if (found === undefined) {
+        const spelled = abi
+            .filter((item) => item.type === "function" && item.name === signature.split("(")[0])
+            .map(canonicalSignature);
+        throw new Error(`actions: the SDK registry's ${protocol} ${abiExport} has no \`${signature}\`` +
+            (spelled.length > 0 ? ` (it declares ${spelled.join(", ")})` : "") +
+            " — the action would call a function the contract does not have.");
+    }
+    return plain(found);
+}
+/** A binding method from the registry, its outputs dropped unless an action reads them. */
+function sdk(protocol, abiExport, abi, signature, outputs) {
+    const fn = registryFunction(protocol, abiExport, abi, signature);
+    if (outputs === "drop")
+        fn.outputs = [];
+    return { fn, source: { kind: "sdk", protocol, abiExport } };
+}
+/** A fragment declared here, in viem's human-readable form, with the reason the registry's is not used. */
+function local(signature, reason) {
+    const fn = parseAbiItem(signature);
+    return { fn: plain(fn), source: { kind: "local", reason } };
+}
+const NOT_IN_REGISTRY = "not in the SDK protocol registry";
+/**
+ * Every binding, by the name emitted source calls it. The names start with `I` and contain no `_`,
+ * so none can collide with an SDK protocol namespace (`AaveV3`, `Erc20`), a chain accessor (`Base`)
+ * or a name the route rewrite synthesizes (`IAaveV3_Pool`) — `abis.unit.test.ts` checks all three.
+ */
+const CATALOG = {
+    // Only the read: `approve`/`transfer` go through `token/safe`, which decodes no output.
+    IErc20: () => ({
+        balanceOf: sdk("erc20", "ERC20ABI", ERC20ABI, "balanceOf(address)", "keep"),
+    }),
+    IWeth9: () => ({
+        withdraw: local("function withdraw(uint256 wad)", `WETH9 is ${NOT_IN_REGISTRY}`),
+        deposit: local("function deposit() payable", `WETH9 is ${NOT_IN_REGISTRY}`),
+    }),
+    // Both return the amount they swapped out, which is the action's output.
+    ISwapRouter02: () => ({
+        exactInputSingle: sdk("uniswap-v3", "UniswapV3SwapRouter02ABI", UniswapV3SwapRouter02ABI, "exactInputSingle((address,address,uint24,address,uint256,uint256,uint160))", "keep"),
+        exactInput: sdk("uniswap-v3", "UniswapV3SwapRouter02ABI", UniswapV3SwapRouter02ABI, "exactInput((bytes,address,uint256,uint256))", "keep"),
+    }),
+    IUniversalRouter: () => ({
+        // The deadline-free overload: these actions carry no deadline. It returns nothing.
+        execute: sdk("uniswap-v4", "UniswapV4UniversalRouterABI", UniswapV4UniversalRouterABI, "execute(bytes,bytes[])", "drop"),
+    }),
+    ICurvePool: () => ({
+        // 3pool's `exchange` returns nothing, and a StableSwap-NG pool's `uint256` return is simply not
+        // decoded: this output-free spelling suits every 4-argument pool. The output is a balance delta.
+        exchange: sdk("curve", "CurveThreePoolABI", CurveThreePoolABI, "exchange(int128,int128,uint256,uint256)", "drop"),
+    }),
+    ICurveRouterNG: () => ({
+        // The six-argument overload, which takes a receiver. Its return is the amount received.
+        exchange: sdk("curve", "CurveRouterNGABI", CurveRouterNGABI, "exchange(address[11],uint256[5][5],uint256,uint256,address[5],address)", "keep"),
+    }),
+    IBalancerV2Vault: () => ({
+        swap: sdk("balancer-v2", "BalancerV2VaultABI", BalancerV2VaultABI, "swap((bytes32,uint8,address,address,uint256,bytes),(address,bool,address,bool),uint256,uint256)", "keep"),
+        // Its output is measured as a balance delta, so the `int256[]` deltas it returns are not decoded.
+        batchSwap: sdk("balancer-v2", "BalancerV2VaultABI", BalancerV2VaultABI, "batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256)", "drop"),
+    }),
+    IBalancerV3Router: () => ({
+        swapSingleTokenExactIn: local("function swapSingleTokenExactIn(address pool, address tokenIn, address tokenOut, uint256 exactAmountIn, uint256 minAmountOut, uint256 deadline, bool wethIsEth, bytes userData) payable returns (uint256 amountOut)", `Balancer V3 is ${NOT_IN_REGISTRY}`),
+    }),
+    IUniswapV2Router: () => ({
+        // Fraxswap's router is UniswapV2-compatible for this function, so `fraxswapSwap` binds it too.
+        swapExactTokensForTokens: sdk("uniswap-v2", "UniswapV2RouterABI", UniswapV2RouterABI, "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)", "drop"),
+    }),
+    ICrocSwapDex: () => ({
+        userCmd: sdk("ambient", "CrocSwapDexABI", CrocSwapDexABI, "userCmd(uint16,bytes)", "drop"),
+    }),
+    IDodoProxy: () => ({
+        dodoSwapV2TokenToToken: sdk("dodo", "DODOV2ProxyABI", DODOV2ProxyABI, "dodoSwapV2TokenToToken(address,address,uint256,uint256,address[],uint256,bool,uint256)", "keep"),
+        dodoSwapV1: local("function dodoSwapV1(address fromToken, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] dodoPairs, uint256 directions, bool isIncentive, uint256 deadLine) payable returns (uint256 returnAmount)", "the registry declares only the proxy's V2 entry point"),
+    }),
+    IMaverickV2Router: () => ({
+        // The registry and the previous raw call both read the first return word as the output.
+        exactInputSingle: sdk("maverick", "MaverickV2RouterABI", MaverickV2RouterABI, "exactInputSingle(address,address,bool,uint256,uint256)", "keep"),
+        exactInputMultiHop: local("function exactInputMultiHop(address recipient, bytes path, uint256 amountIn, uint256 amountOutMinimum) payable returns (uint256 amountOut)", "the registry declares only the single-pool entry point"),
+    }),
+    ICarbonController: () => ({
+        tradeBySourceAmount: local("function tradeBySourceAmount(address sourceToken, address targetToken, (uint256 strategyId, uint128 amount)[] tradeActions, uint256 deadline, uint128 minReturn) payable returns (uint128)", `Carbon is ${NOT_IN_REGISTRY}`),
+    }),
+    IFluidDexT1: () => ({
+        swapIn: local("function swapIn(bool swap0to1, uint256 amountIn, uint256 amountOutMin, address to) payable returns (uint256 amountOut)", "the registry's fluid entry covers lending, not the DEX"),
+    }),
+    IWstEth: () => ({
+        // Both return the amount they minted or released, which is the action's output.
+        wrap: sdk("lido", "WstETHABI", WstETHABI, "wrap(uint256)", "keep"),
+        unwrap: sdk("lido", "WstETHABI", WstETHABI, "unwrap(uint256)", "keep"),
+    }),
+    ILido: () => ({
+        submit: sdk("lido", "LidoABI", LidoABI, "submit(address)", "drop"),
+    }),
+    ILidoWithdrawalQueue: () => ({
+        requestWithdrawals: local("function requestWithdrawals(uint256[] amounts, address owner)", `Lido's withdrawal queue is ${NOT_IN_REGISTRY}`),
+    }),
+    IRocketDepositPool: () => ({
+        deposit: sdk("rocket-pool", "RocketDepositPoolABI", RocketDepositPoolABI, "deposit()", "drop"),
+    }),
+    IRocketTokenReth: () => ({
+        burn: sdk("rocket-pool", "RETHABI", RETHABI, "burn(uint256)", "drop"),
+    }),
+    IEtherFiLiquidityPool: () => ({
+        deposit: sdk("etherfi", "LiquidityPoolABI", LiquidityPoolABI, "deposit()", "drop"),
+    }),
+    IAaveV3Pool: () => ({
+        supply: sdk("aave-v3", "PoolABI", AaveV3PoolABI, "supply(address,uint256,address,uint16)", "keep"),
+        withdraw: sdk("aave-v3", "PoolABI", AaveV3PoolABI, "withdraw(address,uint256,address)", "keep"),
+        borrow: sdk("aave-v3", "PoolABI", AaveV3PoolABI, "borrow(address,uint256,uint256,uint16,address)", "keep"),
+        repay: sdk("aave-v3", "PoolABI", AaveV3PoolABI, "repay(address,uint256,uint256,address)", "drop"),
+    }),
+    ICometMarket: () => ({
+        supply: sdk("compound-v3", "CometABI", CometABI, "supply(address,uint256)", "keep"),
+        withdraw: sdk("compound-v3", "CometABI", CometABI, "withdraw(address,uint256)", "keep"),
+    }),
+    IAcrossSpokePool: () => ({
+        depositV3: sdk("across", "AcrossSpokePoolABI", AcrossSpokePoolABI, "depositV3(address,address,address,address,uint256,uint256,uint256,address,uint32,uint32,uint32,bytes)", "keep"),
+    }),
+    IStargatePool: () => ({
+        quoteSend: local("function quoteSend((uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, bool payInLzToken) view returns ((uint256 nativeFee, uint256 lzTokenFee) fee)", "the registry's StargatePoolABI declares `send` but not `quoteSend`"),
+        // The receipts it returns are never read, so they are not decoded.
+        send: sdk("stargate", "StargatePoolABI", StargatePoolABI, "send((uint32,bytes32,uint256,uint256,bytes,bytes,bytes),(uint256,uint256),address)", "drop"),
+    }),
+    ICctpTokenMessenger: () => ({
+        depositForBurn: sdk("cctp", "TokenMessengerABI", TokenMessengerABI, "depositForBurn(uint256,uint32,bytes32,address,bytes32,uint256,uint32)", "drop"),
+    }),
+    IWarpRoute: () => {
+        const reason = "the registry's hyperlane entry is the Mailbox, not a warp route";
+        return {
+            quoteGasPayment: local("function quoteGasPayment(uint32 destinationDomain) view returns (uint256)", reason),
+            transferRemote: local("function transferRemote(uint32 destination, bytes32 recipient, uint256 amountOrId) payable", `${reason}; the message id it returns is never read`),
+        };
+    },
+    IPermit2: () => ({
+        approve: sdk("permit2", "Permit2ABI", Permit2ABI, "approve(address,address,uint160,uint48)", "drop"),
+    }),
+};
+const resolved = new Map();
+/** A binding's methods, resolved (and registry-checked) on first use. */
+export function bindingMethods(binding) {
+    let methods = resolved.get(binding);
+    if (methods === undefined) {
+        methods = CATALOG[binding]();
+        resolved.set(binding, methods);
+    }
+    return methods;
+}
+/** Every binding name, for tests and documentation. */
+export const BINDING_NAMES = Object.keys(CATALOG);
+/** The 4-byte selector of a binding's method, from the same fragment the binding compiles with. */
+export function methodSelector(binding, method) {
+    return toFunctionSelector(bindingMethods(binding)[method].fn);
+}
+/** The `contracts` map a program naming `bindings` compiles with. */
+export function contractsFor(bindings) {
+    const out = {};
+    for (const binding of [...new Set(bindings)].sort()) {
+        out[binding] = { abi: Object.values(bindingMethods(binding)).map((m) => plain(m.fn)) };
+    }
+    return out;
+}

package/actions/dist/compile.d.ts

@@ -1,12 +1,19 @@
 /**
- * This package's one compiler seam — the published `@eco-incorp/sauce-compiler` wasm package,
- * depended on under the alias `sauce-compiler`.
+ * This package's one compiler seam — the SDK's own (`sdk/src/wasm-compiler.ts`), so an actions
+ * compile shares the SDK's wasm instance and its `ready()`: in a browser, `await ready()` from
+ * `@eco-incorp/sauce` or `@eco-incorp/sauce/compiler` once, and every compile here works.
  *
- * The programs these generators emit import nothing (no ABI artifact, no sibling module: every
- * call is a raw `evm.call` over a selector this package computes itself), so the resolver only ever
- * has to serve the entry — no `baseDirs`, no `resolvePackage`, no `contracts`. That is the whole
- * reason this is 30 lines rather than a copy of `sdk/src/routes/rs-compile.ts`.
+ * A generated program imports no module: its ABI bindings are handed to the compiler in memory as
+ * `inlineContracts`, so the resolver only ever serves the entry — no caller modules, no
+ * `resolvePackage`. That is why this is not the SDK's `routes/rs-compile.ts`, which also resolves
+ * the SDK's own stdlib and a caller's files.
  */
-/** Compiles a generated SauceScript program for the EVM. */
-export declare function compileEvm(source: string): Uint8Array;
+import type { CompileResult } from "sauce-compiler";
+import type { ActionContracts } from "./abis.js";
+export interface EvmCompileOptions {
+    /** Encode `main`'s arguments compact-v1 instead of ABI-v1. */
+    readonly compactArgs?: boolean;
+}
+/** Compiles a generated SauceScript program, and the ABI bindings it names, for the EVM. */
+export declare function compileEvm(source: string, contracts?: ActionContracts, options?: EvmCompileOptions): CompileResult;
 //# sourceMappingURL=compile.d.ts.map

package/actions/dist/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA8BH,4DAA4D;AAC5D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAQrD"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIjD,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,eAAoB,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAaf"}

package/actions/dist/compile.js

@@ -1,38 +1,16 @@
-/**
- * This package's one compiler seam — the published `@eco-incorp/sauce-compiler` wasm package,
- * depended on under the alias `sauce-compiler`.
- *
- * The programs these generators emit import nothing (no ABI artifact, no sibling module: every
- * call is a raw `evm.call` over a selector this package computes itself), so the resolver only ever
- * has to serve the entry — no `baseDirs`, no `resolvePackage`, no `contracts`. That is the whole
- * reason this is 30 lines rather than a copy of `sdk/src/routes/rs-compile.ts`.
- */
-import { createRequire } from "node:module";
+// By relative path into the SDK's build, like `registry.ts`: in the published tarball `actions/dist`
+// and `sdk/dist` are siblings.
+import { compile } from "../../sdk/dist/wasm-compiler.js";
 const ENTRY = "main.js";
-let compileFn;
-/** Lazily loads the wasm module — only paid once something actually compiles. */
-function load() {
-    if (compileFn)
-        return compileFn;
-    // Required via `createRequire`, not `import`: the package's `node` condition is a CommonJS build
-    // that reads its sibling `.wasm` off disk at load, and Node's own CJS loader is the one that
-    // resolves that sibling. Mirrors `sdk/src/routes/rs-compile.ts`.
-    let mod;
-    try {
-        mod = createRequire(import.meta.url)("sauce-compiler");
-    }
-    catch (cause) {
-        throw new Error("the SauceScript compiler (`sauce-compiler` -> the published @eco-incorp/sauce-compiler) failed to load.", { cause });
-    }
-    compileFn = mod.compile;
-    return compileFn;
-}
-/** Compiles a generated SauceScript program for the EVM. */
-export function compileEvm(source) {
-    const bytes = Buffer.from(source, "utf8");
-    return load()({
+/** Compiles a generated SauceScript program, and the ABI bindings it names, for the EVM. */
+export function compileEvm(source, contracts = {}, options = {}) {
+    const bytes = new TextEncoder().encode(source);
+    const inlineContracts = Object.entries(contracts).map(([name, { abi }]) => [name, JSON.stringify(abi)]);
+    return compile({
         target: "evm",
         entry: ENTRY,
         resolve: (path) => (path === ENTRY ? bytes : undefined),
-    }).bytecode;
+        inlineContracts: inlineContracts.length > 0 ? inlineContracts : undefined,
+        compactArgs: options.compactArgs,
+    });
 }

package/actions/dist/compose.d.ts

@@ -0,0 +1,46 @@
+import { type IntentOptions, type PendingSauceRoute } from "../../sdk/dist/routes/index.js";
+import type { ActionContracts } from "./abis.js";
+import type { ActionProgram } from "./types.js";
+export interface CompileOptions {
+    /** Encode the runtime arguments compact-v1 instead of ABI-v1. Default `false`. */
+    readonly compactArgs?: boolean;
+}
+/** Runtime argument values, by `argument` name. Each is a uint256. */
+export type ArgumentValues = Readonly<Record<string, bigint | number | string>>;
+export interface ArgumentEncoding {
+    /**
+     * Compact-v1 only: encode every argument in exactly this many bytes (1..32) instead of the
+     * minimal width, so each sits at a fixed offset whatever its value.
+     */
+    readonly scalarWidth?: number;
+}
+export interface CompiledProgram {
+    readonly bytecode: Uint8Array;
+    /** The SauceScript that was compiled. */
+    readonly source: string;
+    /** The `argument` names, in the order `main` takes them. Empty when there are none. */
+    readonly parameters: readonly string[];
+    readonly entryEncoding: "abi-v1" | "compact-v1";
+    /** The compact-v1 argument schema; present with `compactArgs`. */
+    readonly entrySchema?: Uint8Array;
+    /** `bytecode` followed by the encoded arguments — the `program` a Pot's `cook(engine, program)` takes. */
+    payload(values?: ArgumentValues, encoding?: ArgumentEncoding): Uint8Array;
+    /**
+     * Where argument `name`'s big-endian value starts in `payload(...)`, for splicing a number into
+     * a payload built earlier: its 32-byte word under ABI-v1, its `scalarWidth` bytes under
+     * compact-v1 (which requires a `scalarWidth`).
+     */
+    argumentOffset(name: string, encoding?: ArgumentEncoding): number;
+}
+/** Compiles an action program standalone. Its `argument` actions become runtime arguments. */
+export declare function compileProgram(program: ActionProgram, options?: CompileOptions): CompiledProgram;
+/** Compiles generated source into a `CompiledProgram`. */
+export declare function compiled(source: string, contracts: ActionContracts, parameters: readonly string[], options?: CompileOptions): CompiledProgram;
+/**
+ * An action program as an Eco intent route on the program's own chain:
+ * `programIntent(program, options).reward(reward)` is `Base(body, options).reward(reward)` with the
+ * program as the body. Moving value to another chain is a bridge action inside the program, or a
+ * nested intent (`.nest(...)`) on the returned route.
+ */
+export declare function programIntent(program: ActionProgram, options: IntentOptions): PendingSauceRoute;
+//# sourceMappingURL=compose.d.ts.map

package/actions/dist/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EAEvB,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,sEAAsE;AACtE,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;AAEhF,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,QAAQ,GAAG,YAAY,CAAC;IAChD,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC;IAClC,0GAA0G;IAC1G,OAAO,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,UAAU,CAAC;IAC1E;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;CACnE;AAED,8FAA8F;AAC9F,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,cAAmB,GAC3B,eAAe,CAIjB;AAED,0DAA0D;AAC1D,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,GAAE,cAAmB,GAC3B,eAAe,CAmEjB;AA8BD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,GAAG,iBAAiB,CAQ/F"}

package/actions/dist/compose.js

@@ -0,0 +1,118 @@
+/**
+ * An action program, compiled standalone or opened as an Eco intent route.
+ *
+ * STANDALONE (`compileProgram`). One compiled program; its `argument` actions are `main`
+ * parameters, so the same bytecode serves every amount and the amounts travel as argument bytes
+ * appended to it. ABI-v1 arguments are 32-byte words; compact-v1 arguments are smaller, and with a
+ * declared `scalarWidth` each sits at a fixed offset (`argumentOffset`), which is what lets a caller
+ * splice a number measured at runtime into an otherwise precompiled payload.
+ *
+ * INTENT (`programIntent`). The program is the route body on its own chain: the SDK compiles it
+ * there, puts its cook in the route, and `.reward(...)` / `.nest(...)` work on it like on any other.
+ * A route body takes no runtime arguments, so an amount only known at execution comes from a
+ * `balanceOf` action instead — which is also how a child of a dynamic `.nest()` spends exactly what
+ * its parent delivered.
+ */
+import { concatBytes, encodeAbiParameters, hexToBytes } from "viem";
+import { encodeCompactArguments } from "../../sdk/dist/compact-arguments.js";
+import { openRoute, } from "../../sdk/dist/routes/index.js";
+import { compileEvm } from "./compile.js";
+import { parseProgram } from "./program.js";
+import { lowerActions, renderProgram, renderRouteBody } from "./to-sauce.js";
+/** Compiles an action program standalone. Its `argument` actions become runtime arguments. */
+export function compileProgram(program, options = {}) {
+    const lowered = lowerActions(parseProgram(program).actions);
+    return compiled(renderProgram(lowered), lowered.contracts, lowered.parameters, options);
+}
+/** Compiles generated source into a `CompiledProgram`. */
+export function compiled(source, contracts, parameters, options = {}) {
+    const result = compileEvm(source, contracts, { compactArgs: options.compactArgs });
+    const { bytecode } = result;
+    const positional = (values = {}) => {
+        const unknown = Object.keys(values).filter((name) => !parameters.includes(name));
+        if (unknown.length > 0) {
+            throw new Error(`no argument named ${unknown.map((n) => `'${n}'`).join(", ")}` +
+                ` (the program takes ${parameters.length === 0 ? "none" : parameters.map((p) => `'${p}'`).join(", ")})`);
+        }
+        return parameters.map((name) => {
+            const value = values[name];
+            if (value === undefined)
+                throw new Error(`missing a value for argument '${name}'`);
+            const scalar = BigInt(value);
+            if (scalar < 0n || scalar >= 1n << 256n) {
+                throw new Error(`argument '${name}' must be a uint256, got ${value}`);
+            }
+            return scalar;
+        });
+    };
+    const encodeArguments = (values, encoding = {}) => {
+        const args = positional(values);
+        if (result.entryEncoding === "compact-v1") {
+            return encodeCompactArguments(result.entrySchema, args, {
+                scalarWidth: encoding.scalarWidth,
+            });
+        }
+        if (encoding.scalarWidth !== undefined) {
+            throw new Error("`scalarWidth` applies to compact-v1 arguments; compile with `compactArgs`");
+        }
+        if (args.length === 0)
+            return new Uint8Array();
+        return hexToBytes(encodeAbiParameters(args.map(() => ({ type: "uint256" })), args));
+    };
+    return {
+        bytecode,
+        source,
+        parameters,
+        entryEncoding: result.entryEncoding,
+        entrySchema: result.entrySchema,
+        payload: (values, encoding) => concatBytes([bytecode, encodeArguments(values, encoding)]),
+        argumentOffset(name, encoding = {}) {
+            const index = parameters.indexOf(name);
+            if (index < 0)
+                throw new Error(`no argument named '${name}'`);
+            if (result.entryEncoding === "abi-v1")
+                return bytecode.length + 32 * index;
+            const width = encoding.scalarWidth;
+            if (width === undefined) {
+                throw new Error("a compact-v1 argument has a fixed offset only under a `scalarWidth`");
+            }
+            // "SA" + version (1) + flags (0), then per scalar a one-byte width and its value bytes.
+            return bytecode.length + 4 + index * (1 + width) + 1;
+        },
+    };
+}
+/**
+ * Merges the action bindings into `compile.contracts`, refusing a same-named binding with a
+ * different ABI rather than letting one silently shadow the other.
+ */
+function withContracts(compile, contracts) {
+    const existing = compile?.contracts ?? {};
+    for (const [name, { abi }] of Object.entries(contracts)) {
+        const other = existing[name];
+        if (other !== undefined && JSON.stringify(other.abi) !== JSON.stringify(abi)) {
+            throw new Error(`compile.contracts already binds '${name}' to a different ABI — an action program binds ` +
+                "its contracts under I-prefixed names such as this one; rename yours");
+        }
+    }
+    return {
+        ...compile,
+        contracts: {
+            ...existing,
+            ...contracts,
+        },
+    };
+}
+/**
+ * An action program as an Eco intent route on the program's own chain:
+ * `programIntent(program, options).reward(reward)` is `Base(body, options).reward(reward)` with the
+ * program as the body. Moving value to another chain is a bridge action inside the program, or a
+ * nested intent (`.nest(...)`) on the returned route.
+ */
+export function programIntent(program, options) {
+    const { chainId, actions } = parseProgram(program);
+    const lowered = lowerActions(actions);
+    return openRoute(chainId, renderRouteBody(lowered), {
+        ...options,
+        compile: withContracts(options.compile, lowered.contracts),
+    });
+}