@eco-incorp/sauce 0.99.0

package/sdk/dist/protocols/zerox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/protocols/zerox/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

package/sdk/dist/protocols/zerox/index.js

@@ -0,0 +1,5 @@
+export { protocolInfo } from "./info.js";
+export { deployments } from "./addresses.js";
+export * from "./abis.js";
+export * from "./functions.js";
+//# sourceMappingURL=index.js.map

package/sdk/dist/protocols/zerox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/protocols/zerox/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

package/sdk/dist/protocols/zerox/info.d.ts

@@ -0,0 +1,3 @@
+import type { ProtocolInfo } from "../../core/types.js";
+export declare const protocolInfo: ProtocolInfo;
+//# sourceMappingURL=info.d.ts.map

package/sdk/dist/protocols/zerox/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/protocols/zerox/info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,eAAO,MAAM,YAAY,EAAE,YAW1B,CAAC"}

package/sdk/dist/protocols/zerox/info.js

@@ -0,0 +1,13 @@
+import { deployments } from "./addresses.js";
+export const protocolInfo = {
+    name: "0x Protocol",
+    slug: "zerox",
+    description: "DEX aggregation protocol powering swaps across the DeFi ecosystem. Exchange Proxy provides a single entry point for token swaps across multiple sources.",
+    website: "https://0x.org",
+    github: "https://github.com/0xProject",
+    npm: "@0x/contract-addresses",
+    category: "aggregator",
+    chains: deployments,
+    audited: true,
+};
+//# sourceMappingURL=info.js.map

package/sdk/dist/protocols/zerox/info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.js","sourceRoot":"","sources":["../../../src/protocols/zerox/info.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,CAAC,MAAM,YAAY,GAAiB;IACxC,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,OAAO;IACb,WAAW,EACT,0JAA0J;IAC5J,OAAO,EAAE,gBAAgB;IACzB,MAAM,EAAE,8BAA8B;IACtC,GAAG,EAAE,wBAAwB;IAC7B,QAAQ,EAAE,YAAY;IACtB,MAAM,EAAE,WAAW;IACnB,OAAO,EAAE,IAAI;CACd,CAAC"}

package/sdk/dist/protocols/zksync-bridge/abis.d.ts

@@ -0,0 +1,50 @@
+export declare const ZkSyncDiamondProxyABI: readonly [{
+    readonly name: "requestL2Transaction";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "_contractL2";
+        readonly type: "address";
+    }, {
+        readonly name: "_l2Value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_calldata";
+        readonly type: "bytes";
+    }, {
+        readonly name: "_l2GasLimit";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_l2GasPerPubdataByteLimit";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_factoryDeps";
+        readonly type: "bytes[]";
+    }, {
+        readonly name: "_refundRecipient";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "canonicalTxHash";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "l2TransactionBaseCost";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "_gasPrice";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_l2GasLimit";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_l2GasPerPubdataByteLimit";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=abis.d.ts.map

package/sdk/dist/protocols/zksync-bridge/abis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/abis.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BxB,CAAC"}

package/sdk/dist/protocols/zksync-bridge/abis.js

@@ -0,0 +1,29 @@
+export const ZkSyncDiamondProxyABI = [
+    {
+        name: "requestL2Transaction",
+        type: "function",
+        stateMutability: "payable",
+        inputs: [
+            { name: "_contractL2", type: "address" },
+            { name: "_l2Value", type: "uint256" },
+            { name: "_calldata", type: "bytes" },
+            { name: "_l2GasLimit", type: "uint256" },
+            { name: "_l2GasPerPubdataByteLimit", type: "uint256" },
+            { name: "_factoryDeps", type: "bytes[]" },
+            { name: "_refundRecipient", type: "address" },
+        ],
+        outputs: [{ name: "canonicalTxHash", type: "uint256" }],
+    },
+    {
+        name: "l2TransactionBaseCost",
+        type: "function",
+        stateMutability: "view",
+        inputs: [
+            { name: "_gasPrice", type: "uint256" },
+            { name: "_l2GasLimit", type: "uint256" },
+            { name: "_l2GasPerPubdataByteLimit", type: "uint256" },
+        ],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+];
+//# sourceMappingURL=abis.js.map

package/sdk/dist/protocols/zksync-bridge/abis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abis.js","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/abis.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC;QACE,IAAI,EAAE,sBAAsB;QAC5B,IAAI,EAAE,UAAU;QAChB,eAAe,EAAE,SAAS;QAC1B,MAAM,EAAE;YACN,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE;YACxC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;YACrC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE;YACpC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE;YACxC,EAAE,IAAI,EAAE,2BAA2B,EAAE,IAAI,EAAE,SAAS,EAAE;YACtD,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE;YACzC,EAAE,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE,SAAS,EAAE;SAC9C;QACD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KACxD;IACD;QACE,IAAI,EAAE,uBAAuB;QAC7B,IAAI,EAAE,UAAU;QAChB,eAAe,EAAE,MAAM;QACvB,MAAM,EAAE;YACN,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;YACtC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE;YACxC,EAAE,IAAI,EAAE,2BAA2B,EAAE,IAAI,EAAE,SAAS,EAAE;SACvD;QACD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KACzC;CACO,CAAC"}

package/sdk/dist/protocols/zksync-bridge/addresses.d.ts

@@ -0,0 +1,3 @@
+import type { ChainDeployment } from "../../core/types.js";
+export declare const deployments: ChainDeployment[];
+//# sourceMappingURL=addresses.d.ts.map

package/sdk/dist/protocols/zksync-bridge/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,eAAO,MAAM,WAAW,EAAE,eAAe,EAexC,CAAC"}

package/sdk/dist/protocols/zksync-bridge/addresses.js

@@ -0,0 +1,17 @@
+export const deployments = [
+    {
+        chainId: 1,
+        chainName: "Ethereum",
+        addresses: {
+            diamondProxy: "0x32400084C286CF3E17e7B677ea9583e60a000324",
+        },
+    },
+    {
+        chainId: 324,
+        chainName: "zkSync",
+        addresses: {
+            l2Bridge: "0x11f943b2c77b743AB90f4A0Ae7d5A4e7FCA3E102",
+        },
+    },
+];
+//# sourceMappingURL=addresses.js.map

package/sdk/dist/protocols/zksync-bridge/addresses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.js","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/addresses.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAsB;IAC5C;QACE,OAAO,EAAE,CAAC;QACV,SAAS,EAAE,UAAU;QACrB,SAAS,EAAE;YACT,YAAY,EAAE,4CAA4C;SAC3D;KACF;IACD;QACE,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,QAAQ;QACnB,SAAS,EAAE;YACT,QAAQ,EAAE,4CAA4C;SACvD;KACF;CACF,CAAC"}

package/sdk/dist/protocols/zksync-bridge/functions.d.ts

@@ -0,0 +1,2 @@
+export declare const depositETH = "\nimport { ZkSyncDiamondProxyABI as IDiamondProxy } from \"./abis\";\n\nfunction main(diamondProxyAddress: Address, recipient: Address, l2GasLimit: Uint256): Uint256 {\n  const proxy = IDiamondProxy.at(diamondProxyAddress);\n  return proxy.requestL2Transaction(recipient, ctx.msgValue(), \"\", l2GasLimit, 800, [], ctx.msgSender());\n}\n";
+//# sourceMappingURL=functions.d.ts.map

package/sdk/dist/protocols/zksync-bridge/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/functions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,sVAOtB,CAAC"}

package/sdk/dist/protocols/zksync-bridge/functions.js

@@ -0,0 +1,9 @@
+export const depositETH = `
+import { ZkSyncDiamondProxyABI as IDiamondProxy } from "./abis";
+
+function main(diamondProxyAddress: Address, recipient: Address, l2GasLimit: Uint256): Uint256 {
+  const proxy = IDiamondProxy.at(diamondProxyAddress);
+  return proxy.requestL2Transaction(recipient, ctx.msgValue(), "", l2GasLimit, 800, [], ctx.msgSender());
+}
+`;
+//# sourceMappingURL=functions.js.map

package/sdk/dist/protocols/zksync-bridge/functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/functions.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;CAOzB,CAAC"}

package/sdk/dist/protocols/zksync-bridge/index.d.ts

@@ -0,0 +1,5 @@
+export { protocolInfo } from "./info.js";
+export { deployments } from "./addresses.js";
+export * from "./abis.js";
+export * from "./functions.js";
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/protocols/zksync-bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

package/sdk/dist/protocols/zksync-bridge/index.js

@@ -0,0 +1,5 @@
+export { protocolInfo } from "./info.js";
+export { deployments } from "./addresses.js";
+export * from "./abis.js";
+export * from "./functions.js";
+//# sourceMappingURL=index.js.map

package/sdk/dist/protocols/zksync-bridge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

package/sdk/dist/protocols/zksync-bridge/info.d.ts

@@ -0,0 +1,3 @@
+import type { ProtocolInfo } from "../../core/types.js";
+export declare const protocolInfo: ProtocolInfo;
+//# sourceMappingURL=info.d.ts.map

package/sdk/dist/protocols/zksync-bridge/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAC"}

package/sdk/dist/protocols/zksync-bridge/info.js

@@ -0,0 +1,12 @@
+import { deployments } from "./addresses.js";
+export const protocolInfo = {
+    name: "zkSync Native Bridge",
+    slug: "zksync-bridge",
+    description: "Official zkSync Era bridge via DiamondProxy. Deposits ETH and ERC-20 tokens from Ethereum to zkSync with ZK proof-based finality.",
+    website: "https://bridge.zksync.io",
+    github: "https://github.com/matter-labs/era-contracts",
+    category: "bridge",
+    chains: deployments,
+    audited: true,
+};
+//# sourceMappingURL=info.js.map

package/sdk/dist/protocols/zksync-bridge/info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.js","sourceRoot":"","sources":["../../../src/protocols/zksync-bridge/info.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,CAAC,MAAM,YAAY,GAAiB;IACxC,IAAI,EAAE,sBAAsB;IAC5B,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,mIAAmI;IACrI,OAAO,EAAE,0BAA0B;IACnC,MAAM,EAAE,8CAA8C;IACtD,QAAQ,EAAE,QAAQ;IAClB,MAAM,EAAE,WAAW;IACnB,OAAO,EAAE,IAAI;CACd,CAAC"}

package/sdk/dist/recipes/cctp-split.sauce.ts

@@ -0,0 +1,65 @@
+/**
+ * cctp-split — move a USDC `CCTP_AMOUNT` in CCTP burns capped at `CCTP_CHUNK_SIZE`, ATOMIC in one
+ * Sauce cook.
+ *
+ * The INTERFACE is the whole point: you pass the TOTAL amount and the per-message chunk size, and
+ * THE SCRIPT does the splitting — `count = amount / chunkSize` full-cap burns, then one final burn of
+ * the leftover `remainder = amount % chunkSize` when it isn't zero. No divisibility assumption, no
+ * remainder dropped: `$2.50` at a `$1` cap becomes `$1 + $1 + $0.50`. The TypeScript builder computes
+ * nothing; it only hands the script its two numbers.
+ *
+ * THIS INTENT'S VALUES ARRIVE AS `defines`. The five consts below are declared with placeholder
+ * defaults so this file reads (and compiles) standalone; the builder
+ * (`recipes/cctp-transfer.ts`) overrides each one per intent, and a define REPLACES the module's own
+ * `const` of that name. They are constant-folded, so a given set of values yields fixed bytecode.
+ * Standalone asset, not a string assembled in TypeScript. NOT the same shape as `settle.sauce.ts`: that one takes its values as runtime entry
+ * arguments precisely so its bytecode stays invariant and hash-pinnable (`settle.sauce.ts:44`), where
+ * these fold the values in and change bytecode with them.
+ *
+ * DSL-NATIVE, ZERO HARDCODING — no ABI, no address:
+ *   • `USDC` resolves to the source chain's USDC address from the token registry.
+ *   • `Cctp.TokenMessenger.depositForBurn(...)` resolves interface + address from the CCTP protocol
+ *     descriptor.
+ *   • `Cctp.TokenMessenger` (the approve spender) resolves to that same address as a VALUE — the
+ *     accessor works in value position, not just as a call target (equivalent to the underscore
+ *     ambient define `Cctp_TokenMessenger`, just the accessor-consistent spelling).
+ * One approval for the whole amount, then the burns against it — if any burn reverts (e.g. it
+ * exceeds Circle's per-message cap) the entire source-chain tx reverts (all-or-nothing).
+ *
+ * Declarations are intentionally UNANNOTATED: the DSL accessor rewrite that resolves `USDC`/`Cctp` is
+ * acorn-based (plain JS), so a `.sauce.ts` routed through it must carry no TypeScript type syntax.
+ */
+const CCTP_RECIPIENT = 0n;
+const CCTP_AMOUNT = 0n;
+const CCTP_CHUNK_SIZE = 1n;
+const CCTP_DEST_DOMAIN = 0n;
+const CCTP_MAX_FEE = 0n;
+
+function main() {
+  USDC.approve(Cctp.TokenMessenger, CCTP_AMOUNT);
+  let count = CCTP_AMOUNT / CCTP_CHUNK_SIZE;
+  for (let i = 0n; i < count; i++) {
+    Cctp.TokenMessenger.depositForBurn(
+      CCTP_CHUNK_SIZE,
+      CCTP_DEST_DOMAIN,
+      CCTP_RECIPIENT,
+      USDC,
+      0n,
+      CCTP_MAX_FEE,
+      0n,
+    );
+  }
+  let remainder = CCTP_AMOUNT % CCTP_CHUNK_SIZE;
+  if (remainder > 0n) {
+    Cctp.TokenMessenger.depositForBurn(
+      remainder,
+      CCTP_DEST_DOMAIN,
+      CCTP_RECIPIENT,
+      USDC,
+      0n,
+      CCTP_MAX_FEE,
+      0n,
+    );
+  }
+  return 0n;
+}

package/sdk/dist/recipes/cctp-transfer.d.ts

@@ -0,0 +1,50 @@
+import { type ChainRef } from "../chains/canonical.js";
+import { type BuiltIntent, type RewardArg } from "../routes/intent-dsl.js";
+import type { AddressInput } from "../routes/types.js";
+/** Absolute path to the CCTP split-burn program asset inside THIS installed package. */
+export declare const CCTP_SPLIT_SOURCE_PATH: string;
+/** Absolute path to the plain-transfer baseline program asset inside THIS installed package. */
+export declare const PLAIN_TRANSFER_SOURCE_PATH: string;
+/** The `cctp-split.sauce.ts` program text — read once and cached. */
+export declare function cctpSplitSource(): string;
+/** The `plain-transfer.sauce.ts` program text — read once and cached. */
+export declare function plainTransferSource(): string;
+export interface CctpTransferParams {
+    /** Source chain — where USDC is burned (CCTP delivers to `to` asynchronously). */
+    readonly from: ChainRef;
+    /** Destination chain — where CCTP mints the USDC. */
+    readonly to: ChainRef;
+    /** Total USDC to move, in USDC's own 6 decimals. */
+    readonly amount: bigint;
+    /** Circle's per-message burn cap on `from` — the reason the transfer is split. */
+    readonly perMessageLimit: bigint;
+    /** Who receives the minted USDC on `to`. */
+    readonly recipient: AddressInput;
+    /** CCTP fast-deposit fee charged per chunk (default 0). */
+    readonly maxFeePerChunk?: bigint;
+    readonly pot: AddressInput;
+    /** The interpreter the Pot's cook runs on — see `routes/sauce-route.ts`, never defaulted. */
+    readonly engine: AddressInput;
+    readonly portal: AddressInput;
+    readonly sourcePortal?: AddressInput;
+    readonly deadline: bigint | number | string;
+    readonly rewardDeadline?: bigint | number | string;
+    readonly creator: AddressInput;
+    readonly prover: AddressInput;
+    readonly reward: RewardArg;
+}
+/**
+ * WITH CCTP — one intent whose route drains `amount` in `depositForBurn`s capped at
+ * `perMessageLimit` (the script splits: full-cap burns until the last, which takes the remainder),
+ * atomic in one cook. Fulfilled locally on the source chain, so the intent's destination IS its
+ * source. The builder hands the program only its two numbers; the program's `CCTP_*` consts are
+ * overridden with this intent's values via `defines`.
+ */
+export declare function buildCctpSplitTransfer(params: CctpTransferParams): BuiltIntent;
+/**
+ * WITHOUT CCTP (the baseline) — a plain cross-chain USDC transfer intent: the solver delivers
+ * `amount` USDC to `recipient` on the destination chain via the normal Eco flow, no bridge stitch.
+ * The program's `XFER_*` consts are overridden with this intent's values via `defines`.
+ */
+export declare function buildPlainTransfer(params: CctpTransferParams): BuiltIntent;
+//# sourceMappingURL=cctp-transfer.d.ts.map

package/sdk/dist/recipes/cctp-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cctp-transfer.d.ts","sourceRoot":"","sources":["../../src/recipes/cctp-transfer.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,EAAa,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,wFAAwF;AACxF,eAAO,MAAM,sBAAsB,EAAE,MAA+C,CAAC;AACrF,gGAAgG;AAChG,eAAO,MAAM,0BAA0B,EAAE,MAAmD,CAAC;AAK7F,qEAAqE;AACrE,wBAAgB,eAAe,IAAI,MAAM,CAGxC;AACD,yEAAyE;AACzE,wBAAgB,mBAAmB,IAAI,MAAM,CAI5C;AAMD,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,2DAA2D;IAC3D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAGjC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAgBD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,WAAW,CAuB9E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,WAAW,CAO1E"}

package/sdk/dist/recipes/cctp-transfer.js

@@ -0,0 +1,99 @@
+/**
+ * cctp-transfer — the step-one demo from the team thread: a Base→Arbitrum USDC transfer, "with
+ * interop/CCTP and without".
+ *
+ * The two route PROGRAMS are standalone `.sauce.ts` assets (`cctp-split.sauce.ts`,
+ * `plain-transfer.sauce.ts`) — NOT strings assembled here. Each declares its inputs as module-scope
+ * consts with placeholder defaults; this builder reads the asset from disk (like `settleSource()`)
+ * and overrides each one with THIS intent's value via `defines`, which replace a module's own const
+ * of that name and are constant-folded — so a given intent yields fixed bytecode.
+ *
+ * DSL-NATIVE BY CONSTRUCTION — the programs hardcode NO ABI and NO address. `USDC` resolves to the
+ * source chain's USDC from the token registry; `Cctp.TokenMessenger.depositForBurn(...)` resolves
+ * interface + address from the CCTP protocol descriptor; the ambient define `Cctp_TokenMessenger`
+ * (the approve spender) is that same address. The only inputs are this intent's config.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { requireChain } from "../chains/canonical.js";
+import { CCTP_DOMAIN } from "../protocols/cctp/addresses.js";
+import { openRoute } from "../routes/intent-dsl.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Absolute path to the CCTP split-burn program asset inside THIS installed package. */
+export const CCTP_SPLIT_SOURCE_PATH = join(__dirname, "cctp-split.sauce.ts");
+/** Absolute path to the plain-transfer baseline program asset inside THIS installed package. */
+export const PLAIN_TRANSFER_SOURCE_PATH = join(__dirname, "plain-transfer.sauce.ts");
+let cctpSplitCache = null;
+let plainTransferCache = null;
+/** The `cctp-split.sauce.ts` program text — read once and cached. */
+export function cctpSplitSource() {
+    if (cctpSplitCache === null)
+        cctpSplitCache = readFileSync(CCTP_SPLIT_SOURCE_PATH, "utf-8");
+    return cctpSplitCache;
+}
+/** The `plain-transfer.sauce.ts` program text — read once and cached. */
+export function plainTransferSource() {
+    if (plainTransferCache === null)
+        plainTransferCache = readFileSync(PLAIN_TRANSFER_SOURCE_PATH, "utf-8");
+    return plainTransferCache;
+}
+function toBig(a) {
+    return typeof a === "bigint" ? a : BigInt(a);
+}
+function common(params) {
+    return {
+        pot: params.pot,
+        engine: params.engine,
+        portal: params.portal,
+        sourcePortal: params.sourcePortal,
+        deadline: params.deadline,
+        rewardDeadline: params.rewardDeadline,
+        source: params.from,
+        creator: params.creator,
+        prover: params.prover,
+    };
+}
+/**
+ * WITH CCTP — one intent whose route drains `amount` in `depositForBurn`s capped at
+ * `perMessageLimit` (the script splits: full-cap burns until the last, which takes the remainder),
+ * atomic in one cook. Fulfilled locally on the source chain, so the intent's destination IS its
+ * source. The builder hands the program only its two numbers; the program's `CCTP_*` consts are
+ * overridden with this intent's values via `defines`.
+ */
+export function buildCctpSplitTransfer(params) {
+    const dest = requireChain(params.to);
+    const destDomain = CCTP_DOMAIN[dest.slug];
+    if (destDomain === undefined)
+        throw new Error(`cctp-transfer: no CCTP domain registered for destination '${dest.slug}'`);
+    if (params.amount <= 0n || params.perMessageLimit <= 0n) {
+        throw new Error("cctp-transfer: amount and perMessageLimit must be > 0");
+    }
+    const recipient = toBig(params.recipient);
+    const maxFee = params.maxFeePerChunk ?? 0n;
+    return openRoute(params.from, cctpSplitSource(), {
+        ...common(params),
+        compile: {
+            defines: {
+                CCTP_RECIPIENT: recipient,
+                CCTP_AMOUNT: params.amount,
+                CCTP_CHUNK_SIZE: params.perMessageLimit,
+                CCTP_DEST_DOMAIN: BigInt(destDomain),
+                CCTP_MAX_FEE: maxFee,
+            },
+        },
+    }).reward(params.reward);
+}
+/**
+ * WITHOUT CCTP (the baseline) — a plain cross-chain USDC transfer intent: the solver delivers
+ * `amount` USDC to `recipient` on the destination chain via the normal Eco flow, no bridge stitch.
+ * The program's `XFER_*` consts are overridden with this intent's values via `defines`.
+ */
+export function buildPlainTransfer(params) {
+    const recipient = toBig(params.recipient);
+    return openRoute(params.to, plainTransferSource(), {
+        ...common(params),
+        compile: { defines: { XFER_RECIPIENT: recipient, XFER_AMOUNT: params.amount } },
+    }).reward(params.reward);
+}
+//# sourceMappingURL=cctp-transfer.js.map

package/sdk/dist/recipes/cctp-transfer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cctp-transfer.js","sourceRoot":"","sources":["../../src/recipes/cctp-transfer.ts"],"names":[],"mappings":"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"}

package/sdk/dist/recipes/index.d.ts

@@ -0,0 +1,41 @@
+/** Absolute path to the `settle.sauce.ts` source inside THIS installed package. */
+export declare const SETTLE_SOURCE_PATH: string;
+/**
+ * `baseDirs` for compiling any program in this directory.
+ *
+ * One entry is sufficient and it is not this directory: it is the package's dist root, because what
+ * needs resolving is the program's `import { IERC20 } from "./artifacts/IERC20.json"` — which lands
+ * at `<dist>/artifacts/IERC20.json` (vendored from the pinned engine and shipped in this package's
+ * `files` list). Measured: `[distRoot]` alone reproduces the identical bytes.
+ */
+export declare const SAUCE_BASE_DIRS: readonly string[];
+/**
+ * The `settle.sauce.ts` program text — sweep the Pot's balance of every listed token to one
+ * recipient, with a minimum-output floor on `tokens[0]`. Read once and cached.
+ *
+ * Returned as the raw source (not pre-stripped, not pre-compiled) so a partner can read, hash, or
+ * diff exactly what gets compiled. The compiler's own front-end handles the TypeScript annotations, so
+ * the source needs no pre-processing and no extra option — pass the `CompileOptions` the compiler
+ * package itself exports (`import type { CompileOptions } from "sauce-compiler"`). Deliberately not
+ * restated here: `routes/rs-compile.ts` imports that type for the same reason, since a hand-written
+ * mirror drifts on the next compiler minor with nothing to catch it.
+ */
+export declare function settleSource(): string;
+/**
+ * The CCTP transfer demo — a BUILDER that constructs V2 `Intent`s via the cross-chain intent DSL,
+ * distinct in kind from the source-shipped `settle` recipe above but built the SAME way underneath:
+ * its two route PROGRAMS are standalone `.sauce.ts` assets (`cctp-split.sauce.ts`,
+ * `plain-transfer.sauce.ts`) whose module-level consts are replaced with each intent's values via
+ * `defines` — `CCTP_*` for the split (`cctp-transfer.ts:107`), `XFER_*` for the baseline (`:128`). That is the compile-time channel, and it
+ * is a DIFFERENT mechanism from `settle.sauce.ts`, whose `main` takes its values as runtime entry
+ * arguments and so compiles to one invariant program.
+ *
+ * A Base→Arbitrum USDC transfer "with interop/CCTP and without": `buildCctpSplitTransfer` splits the
+ * amount into N sub-`perMessageLimit` `depositForBurn` chunks burned in ONE atomic cook (all-or-revert
+ * on the source chain); `buildPlainTransfer` is the no-bridge baseline. Both programs read `USDC` and
+ * `Cctp.TokenMessenger` from the DSL registries — no hardcoded ABIs or addresses. `cctpSplitSource()` /
+ * `plainTransferSource()` return the raw program text (read once, cached), the same way `settleSource()`
+ * does. See `cctp-transfer.ts`.
+ */
+export { buildCctpSplitTransfer, buildPlainTransfer, cctpSplitSource, plainTransferSource, CCTP_SPLIT_SOURCE_PATH, PLAIN_TRANSFER_SOURCE_PATH, type CctpTransferParams, } from "./cctp-transfer.js";
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/recipes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/recipes/index.ts"],"names":[],"mappings":"AAmEA,mFAAmF;AACnF,eAAO,MAAM,kBAAkB,EAAE,MAA2C,CAAC;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAA4B,CAAC;AAI1E;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAGrC;AAED;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC"}

package/sdk/dist/recipes/index.js

@@ -0,0 +1,111 @@
+/**
+ * @eco-incorp/sauce/recipes — reusable Sauce recipes shipped as SOURCE.
+ *
+ * WHAT THIS IS FOR: answering the two questions a partner genuinely cannot answer themselves —
+ * "what is the program text?" and "where is this package installed?" — and then getting out of the
+ * way. It ships no compile helper, so whatever options a caller passes are the ones they can audit.
+ *
+ * BYTE-FOR-BYTE REPRODUCIBILITY, against the published Rust compiler this package depends on. The
+ * program is a pure function of the source, the target and the compiler pin — nothing about a
+ * caller's `(tokens, minOut, recipient)` reaches it, because `main` takes them as RUNTIME entry
+ * arguments:
+ *
+ * ```ts
+ * import { compile } from "@eco-incorp/sauce/compiler";
+ * import { settleSource, SAUCE_BASE_DIRS } from "@eco-incorp/sauce/recipes";
+ *
+ * // A raw compile is right HERE and not for the generated programs: settle's `main` declares its
+ * // own return type, so it needs no annotating.
+ * const { bytecode } = compile({
+ *   target: "evm",
+ *   entry: "settle.sauce.ts",
+ *   resolve: (path) =>
+ *     path.endsWith("settle.sauce.ts")
+ *       ? new TextEncoder().encode(settleSource())
+ *       : readFrom(SAUCE_BASE_DIRS, path),   // serves the program's `./artifacts/IERC20.json`
+ * });
+ * // bytecode -- 362 bytes, keccak256 === SETTLE_WIRE.PROGRAM_HASH, for every caller and every value
+ * ```
+ *
+ * Those three compile inputs are the whole contract — change any of them and the bytes change. They are
+ * deliberately NOT exported as a pre-baked options object: a partner reproducing our output should
+ * see the target and the entry, not inherit them from a constant they never read.
+ * `test/verify.compile.test.ts` runs exactly this snippet on every test run and compares the result
+ * against `SETTLE_PROGRAM` and `SETTLE_WIRE.PROGRAM_HASH`, so the promise is a live pin, not a claim.
+ *
+ * THE VALUES RIDE THE PAYLOAD, NOT THE PROGRAM. `(tokens, minOut, recipient)` are appended after the
+ * program as 32-byte big-endian words — `[program | tokensPtr | minOut | recipient | count | token…]`
+ * — and read back through CALLDATA. That is why one 362-byte blob serves every argument set, and why
+ * `@eco-incorp/sauce/verify` can answer "is this the audited settle, and what will it do?" from
+ * the bytes alone with `viem` as its only dependency. `@eco-incorp/sauce/verify`'s
+ * `encodeSettleProgram` builds the tail; its `validateSettleProgram` reads it back and checks the
+ * program half against the pinned hash. The full layout is `sdk/src/verify/decode.ts`.
+ *
+ * PREFER `settleSource()` OVER READING THE FILE YOURSELF, but both work — the raw asset is a
+ * real file inside the package and is reachable by subpath if you want to hash, diff, or vendor it:
+ *
+ * ```ts
+ * const path = fileURLToPath(import.meta.resolve("@eco-incorp/sauce/recipes/settle.sauce.ts"));
+ * ```
+ *
+ * A bare `readFileSync("@eco-incorp/sauce/...")` does NOT work — `readFileSync` takes a
+ * filesystem path and performs no package resolution. Use either form above.
+ *
+ * To go the other direction — a compiled payload back to `(tokens, minOut, recipient)` — use
+ * `@eco-incorp/sauce/verify`'s `validateSettleProgram`, whose dependency closure is `viem` only.
+ *
+ * THIS MODULE IS EVM/v12 ONLY. The SVM twin — the SVM `settle.sauce.ts`, same contract, adapted to
+ * SPL's account model — lives under the SVM subtree with the rest of the SVM SDK and is exported from
+ * `@eco-incorp/sauce/svm` (`svmSettleSource` / `svmSettleRefs`); see
+ * `sdk/src/svm/recipes/index.ts`.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Absolute path to the `settle.sauce.ts` source inside THIS installed package. */
+export const SETTLE_SOURCE_PATH = join(__dirname, "settle.sauce.ts");
+/**
+ * `baseDirs` for compiling any program in this directory.
+ *
+ * One entry is sufficient and it is not this directory: it is the package's dist root, because what
+ * needs resolving is the program's `import { IERC20 } from "./artifacts/IERC20.json"` — which lands
+ * at `<dist>/artifacts/IERC20.json` (vendored from the pinned engine and shipped in this package's
+ * `files` list). Measured: `[distRoot]` alone reproduces the identical bytes.
+ */
+export const SAUCE_BASE_DIRS = [join(__dirname, "..")];
+let cached = null;
+/**
+ * The `settle.sauce.ts` program text — sweep the Pot's balance of every listed token to one
+ * recipient, with a minimum-output floor on `tokens[0]`. Read once and cached.
+ *
+ * Returned as the raw source (not pre-stripped, not pre-compiled) so a partner can read, hash, or
+ * diff exactly what gets compiled. The compiler's own front-end handles the TypeScript annotations, so
+ * the source needs no pre-processing and no extra option — pass the `CompileOptions` the compiler
+ * package itself exports (`import type { CompileOptions } from "sauce-compiler"`). Deliberately not
+ * restated here: `routes/rs-compile.ts` imports that type for the same reason, since a hand-written
+ * mirror drifts on the next compiler minor with nothing to catch it.
+ */
+export function settleSource() {
+    if (cached === null)
+        cached = readFileSync(SETTLE_SOURCE_PATH, "utf-8");
+    return cached;
+}
+/**
+ * The CCTP transfer demo — a BUILDER that constructs V2 `Intent`s via the cross-chain intent DSL,
+ * distinct in kind from the source-shipped `settle` recipe above but built the SAME way underneath:
+ * its two route PROGRAMS are standalone `.sauce.ts` assets (`cctp-split.sauce.ts`,
+ * `plain-transfer.sauce.ts`) whose module-level consts are replaced with each intent's values via
+ * `defines` — `CCTP_*` for the split (`cctp-transfer.ts:107`), `XFER_*` for the baseline (`:128`). That is the compile-time channel, and it
+ * is a DIFFERENT mechanism from `settle.sauce.ts`, whose `main` takes its values as runtime entry
+ * arguments and so compiles to one invariant program.
+ *
+ * A Base→Arbitrum USDC transfer "with interop/CCTP and without": `buildCctpSplitTransfer` splits the
+ * amount into N sub-`perMessageLimit` `depositForBurn` chunks burned in ONE atomic cook (all-or-revert
+ * on the source chain); `buildPlainTransfer` is the no-bridge baseline. Both programs read `USDC` and
+ * `Cctp.TokenMessenger` from the DSL registries — no hardcoded ABIs or addresses. `cctpSplitSource()` /
+ * `plainTransferSource()` return the raw program text (read once, cached), the same way `settleSource()`
+ * does. See `cctp-transfer.ts`.
+ */
+export { buildCctpSplitTransfer, buildPlainTransfer, cctpSplitSource, plainTransferSource, CCTP_SPLIT_SOURCE_PATH, PLAIN_TRANSFER_SOURCE_PATH, } from "./cctp-transfer.js";
+//# sourceMappingURL=index.js.map

package/sdk/dist/recipes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/recipes/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,mFAAmF;AACnF,MAAM,CAAC,MAAM,kBAAkB,GAAW,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAsB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;AAE1E,IAAI,MAAM,GAAkB,IAAI,CAAC;AAEjC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY;IAC1B,IAAI,MAAM,KAAK,IAAI;QAAE,MAAM,GAAG,YAAY,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;IACxE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,GAE3B,MAAM,oBAAoB,CAAC"}