@lendasat/lendaswap-sdk-pure 0.2.24 → 0.2.26

package/dist/cctp-inbound/client.d.ts.map

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

package/dist/cctp-inbound/client.js

@@ -0,0 +1,117 @@
+/**
+ * `CctpInboundClient` — the `client.cctpInbound` namespace on the main
+ * `Client`. Holds the AA (bundler + paymaster) config and will expose
+ * the step-by-step primitives for the CCTP-inbound flow:
+ *
+ *   - `approveAndBurn` (source-chain burn)
+ *   - `waitForAttestation` (IRIS polling)
+ *   - `submitUserOp` (settlement-chain UserOp via Kernel smart account)
+ *   - `createSmartAccountClient` (low-level Kernel account factory)
+ *
+ * The one-shot `Client.fundSwap(...)` is implemented on top of these
+ * primitives — consumers wanting custom progress UX drop down to the
+ * primitives directly; simple integrations just call `fundSwap`.
+ *
+ * Scaffolding only in this commit; primitives land in follow-up steps.
+ */
+import { fetchAttestation, } from "../cctp/attestation.js";
+import { approveAndBurn, } from "./approveAndBurn.js";
+import { cctpFundSwap, } from "./fundSwap.js";
+import { createSwapSmartAccountClient, } from "./smartAccount.js";
+import { submitCctpInboundUserOp, } from "./submit.js";
+import { buildCctpInboundBatch, } from "./userOp.js";
+export class CctpInboundClient {
+    #apiClient;
+    #aa;
+    constructor(config) {
+        this.#apiClient = config.apiClient;
+        this.#aa = config.aa;
+    }
+    /** The AA config this client was built with. */
+    get aa() {
+        return this.#aa;
+    }
+    /** The underlying typed API client. */
+    get api() {
+        return this.#apiClient;
+    }
+    /**
+     * Build a Kernel smart-account client owned by `owner`.
+     *
+     * Low-level primitive — most consumers will use `submitUserOp` or
+     * the one-shot `client.fundSwap` instead of constructing the AA
+     * client themselves.
+     */
+    createSmartAccountClient(args) {
+        const params = {
+            signer: args.signer,
+            aa: this.#aa,
+            chain: args.chain,
+        };
+        return createSwapSmartAccountClient(params);
+    }
+    /**
+     * Compose the 3-call UserOp batch (receiveMessage + USDC.approve +
+     * executeAndCreateWithPermit2) that the smart account will execute
+     * atomically. Produces the Permit2 signature via the caller-supplied
+     * `signTypedData` — typically `kernelAccount.signTypedData`.
+     *
+     * Low-level primitive — most consumers call `submitUserOp` instead,
+     * which composes batch + send + wait-for-receipt.
+     */
+    buildUserOpBatch(params) {
+        return buildCctpInboundBatch(params);
+    }
+    /**
+     * End-to-end settlement UserOp: fetch calldata, build Kernel client,
+     * compose the batch, submit via the bundler, and (by default) wait
+     * for the on-chain receipt.
+     *
+     * This is the main high-level entry point for the CCTP-inbound
+     * settlement step. Pass the IRIS message + attestation (from
+     * `waitForAttestation`, landing in a follow-up step) and the
+     * caller's signer.
+     */
+    submitUserOp(params) {
+        return submitCctpInboundUserOp({ apiClient: this.#apiClient, aa: this.#aa }, params);
+    }
+    /**
+     * Source-chain USDC approve (if needed) + `depositForBurn`. The
+     * minted USDC on the destination chain is pinned to
+     * `smartAccountAddress`, and `destinationCaller` is pinned to the
+     * same address — only that account can settle the message.
+     *
+     * Does not wait for CCTP attestation; returns as soon as both txs
+     * are broadcast. The caller pairs this with `waitForAttestation`
+     * (landing in the next step) and `submitUserOp`.
+     */
+    approveAndBurn(params) {
+        return approveAndBurn(params);
+    }
+    /**
+     * Poll Circle's IRIS V2 API until the CCTP attestation for a burn
+     * tx is `complete`, then return the `message` + `attestation` bytes
+     * ready to feed into `submitUserOp`.
+     *
+     * Typical wait: ~15 seconds for fast transfers, a few minutes for
+     * standard. Defaults to a 15-minute timeout; callers can pass
+     * `signal` (AbortSignal) to cancel early.
+     */
+    waitForAttestation(options) {
+        return fetchAttestation(options);
+    }
+    /**
+     * One-shot CCTP-inbound swap: approve + burn on the source chain,
+     * poll IRIS for the attestation, then submit the settlement UserOp
+     * via the Kernel smart account. Paymaster sponsors the settlement
+     * so the user needs no ETH on the destination chain.
+     *
+     * The `walletClient.account` signs both the source-chain txs and
+     * the destination-chain UserOp (as Kernel owner), and its address
+     * anchors the deterministic smart-account address.
+     */
+    fundSwap(params) {
+        return cctpFundSwap({ apiClient: this.#apiClient, aa: this.#aa }, params);
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/cctp-inbound/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/cctp-inbound/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAGL,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAGL,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,YAAY,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,uBAAuB,GACxB,MAAM,aAAa,CAAC;AAErB,OAAO,EAGL,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAOrB,MAAM,OAAO,iBAAiB;IACnB,UAAU,CAAY;IACtB,GAAG,CAAW;IAEvB,YAAY,MAA+B;QACzC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,EAAE,CAAC;IACvB,CAAC;IAED,gDAAgD;IAChD,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,uCAAuC;IACvC,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,wBAAwB,CAAC,IAA0C;QACjE,MAAM,MAAM,GAAuC;YACjD,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,EAAE,EAAE,IAAI,CAAC,GAAG;YACZ,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;QACF,OAAO,4BAA4B,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;OAQG;IACH,gBAAgB,CAAC,MAAmC;QAClD,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;OASG;IACH,YAAY,CAAC,MAA0B;QACrC,OAAO,uBAAuB,CAC5B,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAC5C,MAAM,CACP,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc,CAAC,MAA4B;QACzC,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;OAQG;IACH,kBAAkB,CAChB,OAAgC;QAEhC,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAA0B;QACjC,OAAO,YAAY,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;IAC5E,CAAC;CACF"}

package/dist/cctp-inbound/eip2612.d.ts

@@ -0,0 +1,77 @@
+/**
+ * EIP-2612 permit signing for USDC → Permit2 approval using the SDK's
+ * HD-derived EVM key.
+ *
+ * On a brand-new SDK-derived Arbitrum address, USDC's allowance for Permit2
+ * is zero. Rather than doing an on-chain `approve` (which requires ETH the
+ * user doesn't have), we sign an EIP-2612 `permit` off-chain; the backend's
+ * multicall on Arbitrum includes `USDC.permit(...)` to establish the
+ * allowance atomically before `executeAndCreateWithPermit2` pulls via Permit2.
+ */
+/** Parameters for signing an EIP-2612 permit against a specific token. */
+export interface SignEip2612Params {
+    /** Signer's secp256k1 private key (from the SDK HD signer). */
+    secretKey: Uint8Array | string;
+    /** The token's EIP-712 DOMAIN_SEPARATOR (0x-prefixed, from `token.DOMAIN_SEPARATOR()`). */
+    domainSeparator: string;
+    /** Token owner address (= `deriveEvmAddress(secretKey)`). */
+    owner: string;
+    /**
+     * Spender. Defaults to Permit2 (the usual target — this is what enables
+     * `executeAndCreateWithPermit2` to pull via Permit2 in the same multicall).
+     */
+    spender?: string;
+    /** Approval amount. Pass `MAX_UINT256` to remove the need for future permits. */
+    value: bigint;
+    /** Current EIP-2612 nonce for `owner` on the token (from `token.nonces(owner)`). */
+    nonce: number;
+    /** Signature deadline (unix seconds). */
+    deadline: bigint;
+}
+/** Signed EIP-2612 permit ready to submit on-chain. */
+export interface SignedEip2612Permit {
+    /** v, r, s components — v is 27 or 28. */
+    v: number;
+    r: string;
+    s: string;
+    /** Approval amount (as stringified decimal for API transport). */
+    value: string;
+    /** Signature deadline (unix seconds). */
+    deadline: number;
+}
+/** uint256 max — sign once, never need another permit. */
+export declare const MAX_UINT256: bigint;
+/**
+ * Signs an EIP-2612 permit using the SDK's derived key, returning the
+ * split signature + value/deadline in a shape the backend's gasless
+ * endpoint accepts directly.
+ */
+export declare function signEip2612Permit(params: SignEip2612Params): SignedEip2612Permit;
+/**
+ * Builds an EIP-712 domain separator from the standard 4-field domain.
+ *
+ * Use when you know the token's on-chain `name` and `version` and want to
+ * avoid an RPC call to `token.DOMAIN_SEPARATOR()`. For USDC deployments,
+ * both vary slightly — see {@link USDC_DOMAIN_FIELDS}.
+ */
+export declare function buildDomainSeparator(params: {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+}): string;
+/**
+ * Known EIP-712 domain fields for native USDC on each CCTPv2-supported EVM
+ * chain. Populate as needed — verify on-chain via `DOMAIN_SEPARATOR()` before
+ * relying on these in production.
+ *
+ * Arbitrum native USDC (`0xaf88d065e77c8cC2239327C5EDb3A432268e5831`) reports
+ * `name = "USD Coin"`, `version = "2"`. Most Circle-issued native USDC uses
+ * the same; bridged USDC.e variants differ.
+ */
+export declare const USDC_DOMAIN_FIELDS: Record<number, {
+    name: string;
+    version: string;
+    address: string;
+}>;
+//# sourceMappingURL=eip2612.d.ts.map

package/dist/cctp-inbound/eip2612.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eip2612.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/eip2612.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAWH,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,SAAS,EAAE,UAAU,GAAG,MAAM,CAAC;IAC/B,2FAA2F;IAC3F,eAAe,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC,0CAA0C;IAC1C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,0DAA0D;AAC1D,eAAO,MAAM,WAAW,QAAoB,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,GACxB,mBAAmB,CAqBrB;AAID;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,MAAM,CAYT;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CACrC,MAAM,EACN;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAOnD,CAAC"}

package/dist/cctp-inbound/eip2612.js

@@ -0,0 +1,95 @@
+/**
+ * EIP-2612 permit signing for USDC → Permit2 approval using the SDK's
+ * HD-derived EVM key.
+ *
+ * On a brand-new SDK-derived Arbitrum address, USDC's allowance for Permit2
+ * is zero. Rather than doing an on-chain `approve` (which requires ETH the
+ * user doesn't have), we sign an EIP-2612 `permit` off-chain; the backend's
+ * multicall on Arbitrum includes `USDC.permit(...)` to establish the
+ * allowance atomically before `executeAndCreateWithPermit2` pulls via Permit2.
+ */
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { buildEip2612PermitDigest, PERMIT2_ADDRESS, } from "../evm/coordinator.js";
+import { signEvmDigest } from "../evm/signing.js";
+/** uint256 max — sign once, never need another permit. */
+export const MAX_UINT256 = (1n << 256n) - 1n;
+/**
+ * Signs an EIP-2612 permit using the SDK's derived key, returning the
+ * split signature + value/deadline in a shape the backend's gasless
+ * endpoint accepts directly.
+ */
+export function signEip2612Permit(params) {
+    const spender = params.spender ?? PERMIT2_ADDRESS;
+    const digestParams = {
+        domainSeparator: params.domainSeparator,
+        owner: params.owner,
+        spender,
+        value: params.value,
+        nonce: params.nonce,
+        deadline: params.deadline,
+    };
+    const digest = buildEip2612PermitDigest(digestParams);
+    const sig = signEvmDigest(params.secretKey, digest);
+    return {
+        v: sig.v,
+        r: sig.r,
+        s: sig.s,
+        value: params.value.toString(),
+        deadline: Number(params.deadline),
+    };
+}
+// ── Domain separator helper ──────────────────────────────────────────────────
+/**
+ * Builds an EIP-712 domain separator from the standard 4-field domain.
+ *
+ * Use when you know the token's on-chain `name` and `version` and want to
+ * avoid an RPC call to `token.DOMAIN_SEPARATOR()`. For USDC deployments,
+ * both vary slightly — see {@link USDC_DOMAIN_FIELDS}.
+ */
+export function buildDomainSeparator(params) {
+    const TYPEHASH = keccak256Hex("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
+    const encoded = strip(TYPEHASH) +
+        strip(keccak256Hex(params.name)) +
+        strip(keccak256Hex(params.version)) +
+        uint256Hex(BigInt(params.chainId)) +
+        addressHex(params.verifyingContract);
+    return keccak256HexBytes(encoded);
+}
+/**
+ * Known EIP-712 domain fields for native USDC on each CCTPv2-supported EVM
+ * chain. Populate as needed — verify on-chain via `DOMAIN_SEPARATOR()` before
+ * relying on these in production.
+ *
+ * Arbitrum native USDC (`0xaf88d065e77c8cC2239327C5EDb3A432268e5831`) reports
+ * `name = "USD Coin"`, `version = "2"`. Most Circle-issued native USDC uses
+ * the same; bridged USDC.e variants differ.
+ */
+export const USDC_DOMAIN_FIELDS = {
+    42161: {
+        name: "USD Coin",
+        version: "2",
+        address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    },
+};
+// ── helpers ──────────────────────────────────────────────────────────────────
+function keccak256Hex(input) {
+    return `0x${bytesToHex(keccak_256(new TextEncoder().encode(input)))}`;
+}
+function keccak256HexBytes(hexInput) {
+    const bytes = new Uint8Array(hexInput.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hexInput.slice(i * 2, i * 2 + 2), 16);
+    }
+    return `0x${bytesToHex(keccak_256(bytes))}`;
+}
+function strip(hex) {
+    return hex.replace(/^0x/, "").toLowerCase();
+}
+function uint256Hex(value) {
+    return value.toString(16).padStart(64, "0");
+}
+function addressHex(address) {
+    return address.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+}
+//# sourceMappingURL=eip2612.js.map

package/dist/cctp-inbound/eip2612.js.map

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

package/dist/cctp-inbound/evmSignerAdapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bridge `EvmSigner` → a viem `LocalAccount` that ZeroDev's Kernel
+ * ECDSA validator accepts as an `owner`.
+ *
+ * Kernel's validator calls:
+ *   - `signMessage({ message: { raw } })` to sign the UserOp hash.
+ *   - `signTypedData({ ... })` to sign the Permit2 witness (and any
+ *     other EIP-712 message routed through the smart account).
+ *
+ * `EvmSigner.signTypedData` is required on all callers. `signMessage`
+ * is optional on `EvmSigner` — this adapter throws a clear error if
+ * the CCTP path is reached with an `EvmSigner` that lacks it.
+ *
+ * `signTransaction` is provided as a stub: Kernel never routes txs
+ * through the owner account (the bundler submits UserOps), so calling
+ * it would be a programmer error.
+ */
+import type { LocalAccount } from "viem";
+import type { EvmSigner } from "../evm/wallet.js";
+/**
+ * Wrap an `EvmSigner` in a viem `LocalAccount` so ZeroDev Kernel's
+ * `signerToEcdsaValidator` can use it as the account owner.
+ */
+export declare function evmSignerToKernelOwner(signer: EvmSigner): LocalAccount;
+//# sourceMappingURL=evmSignerAdapter.d.ts.map

package/dist/cctp-inbound/evmSignerAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evmSignerAdapter.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/evmSignerAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAO,YAAY,EAAE,MAAM,MAAM,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAiCtE"}

package/dist/cctp-inbound/evmSignerAdapter.js

@@ -0,0 +1,50 @@
+/**
+ * Bridge `EvmSigner` → a viem `LocalAccount` that ZeroDev's Kernel
+ * ECDSA validator accepts as an `owner`.
+ *
+ * Kernel's validator calls:
+ *   - `signMessage({ message: { raw } })` to sign the UserOp hash.
+ *   - `signTypedData({ ... })` to sign the Permit2 witness (and any
+ *     other EIP-712 message routed through the smart account).
+ *
+ * `EvmSigner.signTypedData` is required on all callers. `signMessage`
+ * is optional on `EvmSigner` — this adapter throws a clear error if
+ * the CCTP path is reached with an `EvmSigner` that lacks it.
+ *
+ * `signTransaction` is provided as a stub: Kernel never routes txs
+ * through the owner account (the bundler submits UserOps), so calling
+ * it would be a programmer error.
+ */
+import { toAccount } from "viem/accounts";
+/**
+ * Wrap an `EvmSigner` in a viem `LocalAccount` so ZeroDev Kernel's
+ * `signerToEcdsaValidator` can use it as the account owner.
+ */
+export function evmSignerToKernelOwner(signer) {
+    return toAccount({
+        address: signer.address,
+        async signMessage({ message }) {
+            if (!signer.signMessage) {
+                throw new Error("CCTP-inbound flow requires `EvmSigner.signMessage`. Extend your signer — e.g. `(m) => walletClient.signMessage({ account, message: m })`.");
+            }
+            // viem's `message` is `SignableMessage`: either a string or
+            // `{ raw: Hex }`. Kernel always passes `{ raw }` — but be
+            // defensive about the string shape too.
+            const raw = typeof message === "string"
+                ? new TextEncoder().encode(message)
+                : message.raw;
+            return (await signer.signMessage({ raw }));
+        },
+        async signTypedData(typedData) {
+            // Narrow viem's broad SignTypedDataParameters to the SDK's
+            // internal EIP712TypedData shape — at runtime they're
+            // structurally identical, the difference is just generic-heavy
+            // typing on viem's side.
+            return (await signer.signTypedData(typedData));
+        },
+        async signTransaction() {
+            throw new Error("signTransaction is not supported on the Kernel owner — UserOps are submitted via the bundler, not from the owner EOA directly.");
+        },
+    });
+}
+//# sourceMappingURL=evmSignerAdapter.js.map

package/dist/cctp-inbound/evmSignerAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evmSignerAdapter.js","sourceRoot":"","sources":["../../src/cctp-inbound/evmSignerAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAiB;IACtD,OAAO,SAAS,CAAC;QACf,OAAO,EAAE,MAAM,CAAC,OAAc;QAC9B,KAAK,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE;YAC3B,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;gBACxB,MAAM,IAAI,KAAK,CACb,2IAA2I,CAC5I,CAAC;YACJ,CAAC;YACD,4DAA4D;YAC5D,0DAA0D;YAC1D,wCAAwC;YACxC,MAAM,GAAG,GACP,OAAO,OAAO,KAAK,QAAQ;gBACzB,CAAC,CAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAuB;gBAC1D,CAAC,CAAE,OAAO,CAAC,GAAc,CAAC;YAC9B,OAAO,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC,CAAQ,CAAC;QACpD,CAAC;QACD,KAAK,CAAC,aAAa,CAAC,SAAS;YAC3B,2DAA2D;YAC3D,sDAAsD;YACtD,+DAA+D;YAC/D,yBAAyB;YACzB,OAAO,CAAC,MAAM,MAAM,CAAC,aAAa,CAChC,SAAiE,CAClE,CAAQ,CAAC;QACZ,CAAC;QACD,KAAK,CAAC,eAAe;YACnB,MAAM,IAAI,KAAK,CACb,gIAAgI,CACjI,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/cctp-inbound/fundSwap.d.ts

@@ -0,0 +1,94 @@
+/**
+ * `cctpFundSwap` — one-shot CCTP-inbound settlement.
+ *
+ * Composes the three primitives into a single flow most consumers
+ * can call directly:
+ *
+ *   1. `approveAndBurn` on the source chain.
+ *   2. `waitForAttestation` against IRIS until the burn is attested.
+ *   3. `submitUserOp` on the settlement chain via the caller's Kernel
+ *      smart account (paymaster-sponsored).
+ *
+ * The caller's single `EvmSigner` serves double duty: source-chain
+ * signer for step 1 AND Kernel owner for step 3. The smart-account
+ * address is derived once up-front and pinned as
+ * `mintRecipient` / `destinationCaller` on the burn.
+ */
+import type { Chain, Hex } from "viem";
+import type { ApiClient } from "../api/client.js";
+import type { EvmSigner } from "../evm/wallet.js";
+import type { AaConfig } from "./types.js";
+/**
+ * High-level progress events emitted during a CCTP-inbound swap.
+ * Consumers wire a single `onProgress` callback to drive UI updates
+ * without coupling to the primitive-level mechanics.
+ */
+export type CctpProgressStep = {
+    phase: "approving";
+} | {
+    phase: "burning";
+    burnTxHash: Hex;
+} | {
+    phase: "attestation";
+} | {
+    phase: "submitting";
+} | {
+    phase: "settled";
+    userOpHash: Hex;
+    transactionHash?: Hex;
+};
+export interface CctpFundSwapParams {
+    /** Swap ID from `client.createSwap(...)`. */
+    swapId: string;
+    /**
+     * SDK signer bound to the **source chain**. Its `address` is the
+     * source-chain sender AND the Kernel-account owner on the settlement
+     * chain. Requires `signer.signMessage` for the CCTP path.
+     */
+    signer: EvmSigner;
+    /** USDC amount in smallest units (6 decimals). */
+    amount: bigint;
+    /**
+     * Max fast-transfer fee in USDC units (from IRIS's
+     * `/v2/burn/USDC/fees` endpoint). Typical: ~1/10000 of `amount`.
+     */
+    maxFee: bigint;
+    /**
+     * Settlement chain. Defaults to Arbitrum mainnet — the only
+     * supported settlement chain today.
+     */
+    settlementChain?: Chain;
+    /**
+     * IRIS API base URL. Defaults to mainnet; override for testnet.
+     */
+    irisApiUrl?: string;
+    /** Invoked as the flow advances through its phases. */
+    onProgress?: (step: CctpProgressStep) => void;
+    /** Abort signal for cancelling the attestation wait. */
+    signal?: AbortSignal;
+}
+export interface CctpFundSwapResult {
+    /** Source-chain burn tx. */
+    burnTxHash: Hex;
+    /** Source-chain approve tx (omitted if allowance was already sufficient). */
+    approveTxHash?: Hex;
+    /** Settlement-chain UserOp hash. */
+    userOpHash: Hex;
+    /** Settlement-chain bundled tx hash (populated once the UserOp is mined). */
+    transactionHash?: Hex;
+    /** Deterministic Kernel smart-account address owning the HTLC deposit. */
+    smartAccountAddress: Hex;
+}
+/** Context passed by `CctpInboundClient` when delegating to this function. */
+export interface CctpFundSwapContext {
+    apiClient: ApiClient;
+    aa: AaConfig;
+}
+/**
+ * Execute the full CCTP-inbound swap flow end to end. Most consumers
+ * call this directly — the primitives (`approveAndBurn`,
+ * `waitForAttestation`, `submitUserOp`) are available separately for
+ * wizard-style UX that needs per-step control.
+ */
+export declare function cctpFundSwap(context: CctpFundSwapContext, params: CctpFundSwapParams): Promise<CctpFundSwapResult>;
+//# sourceMappingURL=fundSwap.d.ts.map

package/dist/cctp-inbound/fundSwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fundSwap.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/fundSwap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,GACtB;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,GAAG,CAAA;CAAE,GACrC;IAAE,KAAK,EAAE,aAAa,CAAA;CAAE,GACxB;IAAE,KAAK,EAAE,YAAY,CAAA;CAAE,GACvB;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC;IAAC,eAAe,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;AAEjE,MAAM,WAAW,kBAAkB;IACjC,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,EAAE,SAAS,CAAC;IAClB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,eAAe,CAAC,EAAE,KAAK,CAAC;IACxB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC9C,wDAAwD;IACxD,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,4BAA4B;IAC5B,UAAU,EAAE,GAAG,CAAC;IAChB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,oCAAoC;IACpC,UAAU,EAAE,GAAG,CAAC;IAChB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,0EAA0E;IAC1E,mBAAmB,EAAE,GAAG,CAAC;CAC1B;AAED,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,SAAS,CAAC;IACrB,EAAE,EAAE,QAAQ,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,kBAAkB,CAAC,CA2E7B"}

package/dist/cctp-inbound/fundSwap.js

@@ -0,0 +1,90 @@
+/**
+ * `cctpFundSwap` — one-shot CCTP-inbound settlement.
+ *
+ * Composes the three primitives into a single flow most consumers
+ * can call directly:
+ *
+ *   1. `approveAndBurn` on the source chain.
+ *   2. `waitForAttestation` against IRIS until the burn is attested.
+ *   3. `submitUserOp` on the settlement chain via the caller's Kernel
+ *      smart account (paymaster-sponsored).
+ *
+ * The caller's single `EvmSigner` serves double duty: source-chain
+ * signer for step 1 AND Kernel owner for step 3. The smart-account
+ * address is derived once up-front and pinned as
+ * `mintRecipient` / `destinationCaller` on the burn.
+ */
+import { arbitrum } from "viem/chains";
+import { fetchAttestation } from "../cctp/attestation.js";
+import { IRIS_API_MAINNET } from "../cctp/constants.js";
+import { approveAndBurn } from "./approveAndBurn.js";
+import { cctpMetaForChainId } from "./chainMap.js";
+import { createSwapSmartAccountClient } from "./smartAccount.js";
+import { submitCctpInboundUserOp } from "./submit.js";
+/**
+ * Execute the full CCTP-inbound swap flow end to end. Most consumers
+ * call this directly — the primitives (`approveAndBurn`,
+ * `waitForAttestation`, `submitUserOp`) are available separately for
+ * wizard-style UX that needs per-step control.
+ */
+export async function cctpFundSwap(context, params) {
+    const { swapId, signer, amount, maxFee, settlementChain = arbitrum, irisApiUrl = IRIS_API_MAINNET, onProgress, signal, } = params;
+    // Derive CCTP source metadata from the signer's chain id. No need
+    // for the caller to spell out "Optimism" or the numeric domain —
+    // the signer already knows which chain it's on.
+    const source = cctpMetaForChainId(signer.chainId);
+    const destination = cctpMetaForChainId(settlementChain.id);
+    // Derive the Kernel smart-account address up front. Stable across
+    // all three phases — we mint to it on settlement and gate the
+    // `receiveMessage` call on it.
+    const { accountAddress: smartAccountAddress } = await createSwapSmartAccountClient({
+        signer,
+        aa: context.aa,
+        chain: settlementChain,
+    });
+    // 1. Source-chain approve + burn.
+    onProgress?.({ phase: "approving" });
+    const { approveTxHash, burnTxHash } = await approveAndBurn({
+        signer,
+        amount,
+        usdcAddress: source.usdc,
+        destinationDomain: destination.domain,
+        smartAccountAddress,
+        maxFee,
+    });
+    onProgress?.({ phase: "burning", burnTxHash });
+    const burnReceipt = await signer.waitForReceipt(burnTxHash);
+    if (burnReceipt.status !== "success") {
+        throw new Error(`CCTP burn tx reverted: ${burnTxHash}`);
+    }
+    // 2. Wait for the IRIS attestation to clear.
+    onProgress?.({ phase: "attestation" });
+    const { message, attestation } = await fetchAttestation({
+        sourceChain: source.name,
+        txHash: burnTxHash,
+        irisApiUrl,
+        signal,
+    });
+    // 3. Submit the settlement UserOp and wait for the on-chain receipt.
+    onProgress?.({ phase: "submitting" });
+    const submit = await submitCctpInboundUserOp(context, {
+        swapId,
+        signer,
+        cctpMessage: message,
+        cctpAttestation: attestation,
+        chain: settlementChain,
+    });
+    onProgress?.({
+        phase: "settled",
+        userOpHash: submit.userOpHash,
+        transactionHash: submit.transactionHash,
+    });
+    return {
+        approveTxHash,
+        burnTxHash,
+        userOpHash: submit.userOpHash,
+        transactionHash: submit.transactionHash,
+        smartAccountAddress: smartAccountAddress,
+    };
+}
+//# sourceMappingURL=fundSwap.js.map

package/dist/cctp-inbound/fundSwap.js.map

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

package/dist/cctp-inbound/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CCTP-inbound flow — "any CCTPv2 chain → Arbitrum USDC → BTC" swaps.
+ *
+ * The SDK orchestrates:
+ *   1. Source-chain USDC burn via `TokenMessenger.depositForBurn`
+ *      (`destinationCaller` pinned to the user's Kernel smart account).
+ *   2. IRIS attestation polling.
+ *   3. Settlement-chain UserOp via the user's Kernel smart account
+ *      (atomic `receiveMessage` + `USDC.approve(Permit2)` +
+ *      `executeAndCreateWithPermit2`), paymaster-sponsored so the user
+ *      needs no ETH on Arbitrum.
+ *
+ * The Kernel smart account is owned by the user's connected wallet
+ * (viem `Account` / Privy / wagmi / raw key) — no SDK-derived key
+ * material. Consumer-side wallet prompts cover Permit2 typed data and
+ * the UserOp signature.
+ *
+ * Public API:
+ *   - `client.cctpInbound.*` — step-by-step primitives (for custom UX)
+ *   - `client.fundSwap(swapId, signer)` — one-shot wrapper built on top
+ */
+export { type ApproveAndBurnParams, type ApproveAndBurnResult, approveAndBurn, } from "./approveAndBurn.js";
+export { type DepositForBurnParams, encodeDepositForBurn, } from "./burn.js";
+export { CCTP_VIEM_CHAINS, CHAIN_ID_TO_CCTP_NAME, cctpMetaForChainId, DIRECT_SOURCE_CHAIN_IDS, getCctpViemChain, getCctpViemChainByName, isCctpOnlySource, } from "./chainMap.js";
+export type { CctpInboundClientConfig } from "./client.js";
+export { CctpInboundClient } from "./client.js";
+export { buildDomainSeparator, MAX_UINT256, type SignEip2612Params, type SignedEip2612Permit, signEip2612Permit, USDC_DOMAIN_FIELDS, } from "./eip2612.js";
+export { type CctpFundSwapContext, type CctpFundSwapParams, type CctpFundSwapResult, type CctpProgressStep, cctpFundSwap, } from "./fundSwap.js";
+export { type SignedPermit2Witness, type SignPermit2Params, signPermit2Witness, } from "./permit2.js";
+export { extractRevertData, type SimulateBatchCallsArgs, simulateBatchCalls, } from "./preflight.js";
+export { type CreateSwapSmartAccountClientParams, createSwapSmartAccountClient, } from "./smartAccount.js";
+export { type SubmitUserOpContext, type SubmitUserOpParams, type SubmitUserOpResult, submitCctpInboundUserOp, } from "./submit.js";
+export type { AaConfig } from "./types.js";
+export { addressToBytes32Hex, type BatchCall, type BuildCctpInboundBatchParams, type BuiltBatch, buildCctpInboundBatch, type SignTypedDataFn, type UseropCalldataResponse, } from "./userOp.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cctp-inbound/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,oBAAoB,EACzB,oBAAoB,GACrB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,YAAY,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,iBAAiB,EACjB,KAAK,sBAAsB,EAC3B,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,kCAAkC,EACvC,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EACL,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,2BAA2B,EAChC,KAAK,UAAU,EACf,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,sBAAsB,GAC5B,MAAM,aAAa,CAAC"}