@lendasat/lendaswap-sdk-pure 0.2.24 → 0.2.26

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

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

package/dist/cctp-inbound/smartAccount.js

@@ -0,0 +1,117 @@
+/**
+ * Build a ZeroDev Kernel smart-account client on Arbitrum, owned by a
+ * viem `Account` supplied by the consumer (Privy, wagmi, raw private
+ * key — any viem-compatible signer).
+ *
+ * The smart-account address is deterministic from `(owner, factory,
+ * impl, salt)`, which makes it usable as both:
+ *   - `mintRecipient` on the source-chain CCTP burn (USDC arrives here)
+ *   - `destinationCaller` (bytes32-padded) — only this account can
+ *     call `receiveMessage` on Arbitrum
+ *
+ * The account is counterfactually deployed: the bytecode doesn't exist
+ * on-chain until the first UserOperation submits, and its `initCode`
+ * is provided by Kernel's factory.
+ *
+ * Bundler + paymaster both live at the same Alchemy app URL; the
+ * policy id is passed via the ERC-7677 `paymasterContext`.
+ */
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import { createKernelAccount, createKernelAccountClient } from "@zerodev/sdk";
+import { getEntryPoint, KERNEL_V3_1 } from "@zerodev/sdk/constants";
+import { createPublicClient, http } from "viem";
+import { createPaymasterClient } from "viem/account-abstraction";
+import { arbitrum } from "viem/chains";
+import { evmSignerToKernelOwner } from "./evmSignerAdapter.js";
+/**
+ * Creates a Kernel smart-account client ready to send UserOperations.
+ * Async — resolves once the account address + validator are derived.
+ *
+ * @returns `{ client, account, accountAddress }` where `accountAddress`
+ *          is the deterministic smart-account address.
+ */
+export async function createSwapSmartAccountClient(params) {
+    const { signer, aa, chain = arbitrum } = params;
+    const { bundlerUrl, paymasterPolicyId } = aa;
+    if (!bundlerUrl) {
+        throw new Error("aa.bundlerUrl is required");
+    }
+    if (!paymasterPolicyId) {
+        throw new Error("aa.paymasterPolicyId is required");
+    }
+    const entryPoint = getEntryPoint("0.7");
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(bundlerUrl),
+    });
+    // Adapt the EvmSigner to a viem LocalAccount so ZeroDev's validator
+    // can treat it as the owner. The adapter throws a clear error if
+    // `signer.signMessage` is missing (required for Kernel's UserOp sig).
+    const kernelOwner = evmSignerToKernelOwner(signer);
+    // ZeroDev's ECDSA validator is the signature scheme gating the Kernel
+    // account — owner signs, validator checks via ERC-1271.
+    const validator = await signerToEcdsaValidator(publicClient, {
+        signer: kernelOwner,
+        entryPoint,
+        kernelVersion: KERNEL_V3_1,
+    });
+    const account = await createKernelAccount(publicClient, {
+        plugins: { sudo: validator },
+        entryPoint,
+        kernelVersion: KERNEL_V3_1,
+    });
+    // Alchemy serves standard ERC-7677 paymaster methods
+    // (`pm_getPaymasterStubData` / `pm_getPaymasterData`) on the same app
+    // URL as the bundler. Passing the policy id via `paymasterContext`
+    // lets viem call both methods at the right points in the UserOp
+    // preparation flow (stub → gas estimate → final paymaster data).
+    const paymasterClient = createPaymasterClient({
+        transport: http(bundlerUrl),
+    });
+    const client = createKernelAccountClient({
+        account,
+        chain,
+        bundlerTransport: http(bundlerUrl),
+        paymaster: paymasterClient,
+        paymasterContext: { policyId: paymasterPolicyId },
+        userOperation: {
+            // ZeroDev's default fetcher calls `zd_getUserOperationGasPrice`,
+            // which Alchemy's bundler rejects. Use Alchemy's
+            // `rundler_maxPriorityFeePerGas` instead and combine with viem's
+            // base-fee estimate for maxFeePerGas. Falls back to a static
+            // floor (0.001 gwei) if the rundler method isn't available.
+            estimateFeesPerGas: async () => {
+                const STATIC_MIN_PRIORITY = 1000000n;
+                let maxPriorityFeePerGas = STATIC_MIN_PRIORITY;
+                try {
+                    const resp = await fetch(bundlerUrl, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            jsonrpc: "2.0",
+                            id: 1,
+                            method: "rundler_maxPriorityFeePerGas",
+                            params: [],
+                        }),
+                    });
+                    const json = await resp.json();
+                    if (typeof json.result === "string") {
+                        const rundlerFee = BigInt(json.result);
+                        maxPriorityFeePerGas =
+                            rundlerFee > STATIC_MIN_PRIORITY
+                                ? rundlerFee
+                                : STATIC_MIN_PRIORITY;
+                    }
+                }
+                catch {
+                    /* fall through to static floor */
+                }
+                const baseFees = await publicClient.estimateFeesPerGas();
+                const maxFeePerGas = baseFees.maxFeePerGas + maxPriorityFeePerGas;
+                return { maxFeePerGas, maxPriorityFeePerGas };
+            },
+        },
+    });
+    return { client, account, accountAddress: account.address };
+}
+//# sourceMappingURL=smartAccount.js.map

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

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

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

@@ -0,0 +1,75 @@
+/**
+ * `submitUserOp` — end-to-end UserOp submission for the CCTP-inbound
+ * settlement step. Composes:
+ *
+ *   1. Fetch HTLC/DEX calldata from the backend.
+ *   2. Build a Kernel smart-account client owned by the caller's signer.
+ *   3. Check the smart-account USDC balance; skip `receiveMessage` if
+ *      funds already landed (retry-safe).
+ *   4. Compose the 3-call UserOp batch.
+ *   5. Send the UserOp via the bundler; optionally wait for the
+ *      on-chain tx hash.
+ *
+ * The authoritative high-level primitive for a settlement — most
+ * consumers call this (or the even-higher-level `Client.fundSwap`).
+ */
+import type { Address, Chain, Hex } from "viem";
+import type { ApiClient } from "../api/client.js";
+import type { EvmSigner } from "../evm/wallet.js";
+import type { AaConfig } from "./types.js";
+export interface SubmitUserOpParams {
+    /** Swap ID assigned by the backend at create time. */
+    swapId: string;
+    /**
+     * Kernel smart-account owner as the SDK's `EvmSigner`. Requires
+     * `signer.signMessage` (optional on `EvmSigner`) — Kernel's validator
+     * signs the UserOp hash via it. Clear error thrown if missing.
+     */
+    signer: EvmSigner;
+    /** Raw IRIS message bytes (hex, 0x-prefixed). */
+    cctpMessage: Hex;
+    /** Raw IRIS attestation bytes (hex, 0x-prefixed). */
+    cctpAttestation: Hex;
+    /**
+     * Settlement chain. Defaults to Arbitrum mainnet — the only
+     * supported chain today, parameterised for future extension.
+     */
+    chain?: Chain;
+    /** Return immediately after submission without waiting for receipt. */
+    noWait?: boolean;
+    /**
+     * When `true`, run each batched call individually via `eth_call`
+     * before submission and log per-call status to the console. Useful
+     * for iterating on ABI / calldata issues — bundler reverts are
+     * aggregated and often opaque. Never throws; the bundler's real
+     * simulation on `sendUserOperation` remains the authoritative check.
+     */
+    preflightSimulate?: boolean;
+}
+export interface SubmitUserOpResult {
+    /** Bundler-assigned UserOperation hash. */
+    userOpHash: Hex;
+    /** Deterministic smart-account address (owned by `signer`). */
+    smartAccountAddress: Address;
+    /**
+     * On-chain transaction hash for the bundle containing this UserOp.
+     * Populated when `noWait !== true` — omitted when the caller opts
+     * out of waiting.
+     */
+    transactionHash?: Hex;
+}
+/** Inputs needed from the `CctpInboundClient` to execute a submission. */
+export interface SubmitUserOpContext {
+    apiClient: ApiClient;
+    aa: AaConfig;
+}
+/**
+ * Execute the full CCTP-inbound settlement UserOp for a swap.
+ *
+ * This is intentionally a free function rather than a
+ * `CctpInboundClient` method — the client exposes a thin wrapper that
+ * injects its own state; tests and advanced consumers can call the
+ * free function directly with a custom `SubmitUserOpContext`.
+ */
+export declare function submitCctpInboundUserOp(context: SubmitUserOpContext, params: SubmitUserOpParams): Promise<SubmitUserOpResult>;
+//# sourceMappingURL=submit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"submit.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/submit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAGhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAmC3C,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,EAAE,SAAS,CAAC;IAClB,iDAAiD;IACjD,WAAW,EAAE,GAAG,CAAC;IACjB,qDAAqD;IACrD,eAAe,EAAE,GAAG,CAAC;IACrB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,uEAAuE;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,UAAU,EAAE,GAAG,CAAC;IAChB,+DAA+D;IAC/D,mBAAmB,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,GAAG,CAAC;CACvB;AAED,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,SAAS,CAAC;IACrB,EAAE,EAAE,QAAQ,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,kBAAkB,CAAC,CA+F7B"}

package/dist/cctp-inbound/submit.js

@@ -0,0 +1,126 @@
+/**
+ * `submitUserOp` — end-to-end UserOp submission for the CCTP-inbound
+ * settlement step. Composes:
+ *
+ *   1. Fetch HTLC/DEX calldata from the backend.
+ *   2. Build a Kernel smart-account client owned by the caller's signer.
+ *   3. Check the smart-account USDC balance; skip `receiveMessage` if
+ *      funds already landed (retry-safe).
+ *   4. Compose the 3-call UserOp batch.
+ *   5. Send the UserOp via the bundler; optionally wait for the
+ *      on-chain tx hash.
+ *
+ * The authoritative high-level primitive for a settlement — most
+ * consumers call this (or the even-higher-level `Client.fundSwap`).
+ */
+import { createPublicClient, http } from "viem";
+import { arbitrum } from "viem/chains";
+import { MESSAGE_TRANSMITTER_V2 } from "../cctp/constants.js";
+import { simulateBatchCalls } from "./preflight.js";
+import { createSwapSmartAccountClient } from "./smartAccount.js";
+import { buildCctpInboundBatch, } from "./userOp.js";
+/**
+ * CCTPv2 burn/mint message layout (see Circle's `MessageTransmitterV2`):
+ *
+ *   offset  size  field
+ *   0       4     version
+ *   4       4     sourceDomain
+ *   8       4     destinationDomain
+ *   12      32    nonce            <-- what we extract
+ *   44      32    sender
+ *   ...
+ *
+ * Hex-string offsets include the "0x" prefix and 2 chars per byte, so the
+ * nonce sits at chars [26, 90).
+ */
+function extractNonce(cctpMessage) {
+    return `0x${cctpMessage.slice(26, 26 + 64)}`;
+}
+/** `MessageTransmitterV2.usedNonces(bytes32)` — returns 0 if unused. */
+const USED_NONCES_ABI = [
+    {
+        type: "function",
+        name: "usedNonces",
+        stateMutability: "view",
+        inputs: [{ name: "nonce", type: "bytes32" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+];
+/**
+ * Execute the full CCTP-inbound settlement UserOp for a swap.
+ *
+ * This is intentionally a free function rather than a
+ * `CctpInboundClient` method — the client exposes a thin wrapper that
+ * injects its own state; tests and advanced consumers can call the
+ * free function directly with a custom `SubmitUserOpContext`.
+ */
+export async function submitCctpInboundUserOp(context, params) {
+    const { apiClient, aa } = context;
+    const { swapId, signer, cctpMessage, cctpAttestation, chain = arbitrum, noWait, preflightSimulate, } = params;
+    // 1. Fetch the HTLC/DEX calldata the backend built for this swap.
+    const { data, error } = await apiClient.GET("/swap/{id}/swap-and-lock-calldata-userop", { params: { path: { id: swapId } } });
+    if (error || !data) {
+        throw new Error(`Failed to fetch CCTP-inbound calldata for swap ${swapId}: ${JSON.stringify(error)}`);
+    }
+    const server = data;
+    // 2. Derive the Kernel client + the smart-account address.
+    const { client: aaClient, account: smartAccount, accountAddress, } = await createSwapSmartAccountClient({ signer, aa, chain });
+    // 3. Decide whether to include `receiveMessage` in the batch, based on
+    //    whether *this specific burn's nonce* has already been consumed by
+    //    MessageTransmitter. A prior balance-based heuristic here was
+    //    unsafe: any USDC that happened to be at the smart-account address
+    //    (residual from a partial prior attempt, a direct transfer, …) made
+    //    it skip `receiveMessage` even if the current burn was still
+    //    unminted, stranding the fresh funds. Nonce consumption is the
+    //    authoritative signal — `MessageTransmitter.usedNonces(nonce)`
+    //    returns non-zero iff the mint for *this* message has landed.
+    //    Reuses the bundler URL as the node RPC (Alchemy serves both).
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(aa.bundlerUrl),
+    });
+    const nonce = extractNonce(cctpMessage);
+    const usedNonce = (await publicClient.readContract({
+        address: MESSAGE_TRANSMITTER_V2,
+        abi: USED_NONCES_ABI,
+        functionName: "usedNonces",
+        args: [nonce],
+    }));
+    const skipReceiveMessage = usedNonce !== 0n;
+    // 4. Compose the 3-call batch (receiveMessage + approve + HTLC create).
+    const { calls } = await buildCctpInboundBatch({
+        server,
+        smartAccountAddress: accountAddress,
+        signTypedData: (args) => smartAccount.signTypedData(args),
+        cctpMessage,
+        cctpAttestation,
+        chainId: chain.id,
+        skipReceiveMessage,
+    });
+    // 5. Optional debug pre-flight: per-call `eth_call` with the smart
+    //    account as `from`, logging per-call status. The bundler's
+    //    full simulation at `sendUserOperation` is the authoritative
+    //    check — this is purely for observability while iterating.
+    if (preflightSimulate) {
+        await simulateBatchCalls({
+            calls,
+            smartAccount: accountAddress,
+            publicClient,
+        });
+    }
+    // 6. Send the UserOp via the bundler. Paymaster sponsorship is wired
+    //    into the Kernel client already, so no gas is owed by the caller.
+    const userOpHash = await aaClient.sendUserOperation({ calls });
+    if (noWait) {
+        return { userOpHash, smartAccountAddress: accountAddress };
+    }
+    const receipt = await aaClient.waitForUserOperationReceipt({
+        hash: userOpHash,
+    });
+    return {
+        userOpHash,
+        smartAccountAddress: accountAddress,
+        transactionHash: receipt.receipt?.transactionHash,
+    };
+}
+//# sourceMappingURL=submit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"submit.js","sourceRoot":"","sources":["../../src/cctp-inbound/submit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,EACL,qBAAqB,GAEtB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;GAaG;AACH,SAAS,YAAY,CAAC,WAAgB;IACpC,OAAO,KAAK,WAAW,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAS,CAAC;AACtD,CAAC;AAED,wEAAwE;AACxE,MAAM,eAAe,GAAG;IACtB;QACE,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,YAAY;QAClB,eAAe,EAAE,MAAM;QACvB,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAC5C,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KACzC;CACO,CAAC;AAmDX;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,OAA4B,EAC5B,MAA0B;IAE1B,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC;IAClC,MAAM,EACJ,MAAM,EACN,MAAM,EACN,WAAW,EACX,eAAe,EACf,KAAK,GAAG,QAAQ,EAChB,MAAM,EACN,iBAAiB,GAClB,GAAG,MAAM,CAAC;IAEX,kEAAkE;IAClE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,SAAS,CAAC,GAAG,CACzC,0CAA0C,EAC1C,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CACrC,CAAC;IACF,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CACb,kDAAkD,MAAM,KAAK,IAAI,CAAC,SAAS,CACzE,KAAK,CACN,EAAE,CACJ,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,IAAyC,CAAC;IAEzD,2DAA2D;IAC3D,MAAM,EACJ,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,YAAY,EACrB,cAAc,GACf,GAAG,MAAM,4BAA4B,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAE9D,uEAAuE;IACvE,uEAAuE;IACvE,kEAAkE;IAClE,uEAAuE;IACvE,wEAAwE;IACxE,iEAAiE;IACjE,mEAAmE;IACnE,mEAAmE;IACnE,kEAAkE;IAClE,mEAAmE;IACnE,MAAM,YAAY,GAAG,kBAAkB,CAAC;QACtC,KAAK;QACL,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC;KAC/B,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;IACxC,MAAM,SAAS,GAAG,CAAC,MAAM,YAAY,CAAC,YAAY,CAAC;QACjD,OAAO,EAAE,sBAAuC;QAChD,GAAG,EAAE,eAAe;QACpB,YAAY,EAAE,YAAY;QAC1B,IAAI,EAAE,CAAC,KAAK,CAAC;KACd,CAAC,CAAW,CAAC;IACd,MAAM,kBAAkB,GAAG,SAAS,KAAK,EAAE,CAAC;IAE5C,wEAAwE;IACxE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,qBAAqB,CAAC;QAC5C,MAAM;QACN,mBAAmB,EAAE,cAAc;QACnC,aAAa,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC;QACzD,WAAW;QACX,eAAe;QACf,OAAO,EAAE,KAAK,CAAC,EAAE;QACjB,kBAAkB;KACnB,CAAC,CAAC;IAEH,mEAAmE;IACnE,+DAA+D;IAC/D,iEAAiE;IACjE,+DAA+D;IAC/D,IAAI,iBAAiB,EAAE,CAAC;QACtB,MAAM,kBAAkB,CAAC;YACvB,KAAK;YACL,YAAY,EAAE,cAAc;YAC5B,YAAY;SACb,CAAC,CAAC;IACL,CAAC;IAED,qEAAqE;IACrE,sEAAsE;IACtE,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAE/D,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,cAAc,EAAE,CAAC;IAC7D,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,2BAA2B,CAAC;QACzD,IAAI,EAAE,UAAU;KACjB,CAAC,CAAC;IACH,OAAO;QACL,UAAU;QACV,mBAAmB,EAAE,cAAc;QACnC,eAAe,EAAE,OAAO,CAAC,OAAO,EAAE,eAAe;KAClD,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,30 @@
+/**
+ * Shared types for the CCTP-inbound flow.
+ */
+/**
+ * Account-abstraction configuration for the CCTP-inbound path.
+ *
+ * The CCTP-inbound flow requires an ERC-4337 bundler and paymaster to
+ * fund the `receiveMessage + approve + HTLC-create` UserOp atomically
+ * on the settlement chain (Arbitrum). The user's connected wallet owns
+ * the Kernel smart account; the SDK just wires the plumbing.
+ *
+ * All URLs point to the same Alchemy app (bundler and Gas Manager share
+ * a base URL); the policy id is passed via ERC-7677 paymaster context.
+ */
+export interface AaConfig {
+    /**
+     * Bundler JSON-RPC URL (also serves as the paymaster URL for Alchemy
+     * Gas Manager via ERC-7677 `pm_*` methods).
+     *
+     * @example `https://arb-mainnet.g.alchemy.com/v2/<API_KEY>`
+     */
+    bundlerUrl: string;
+    /**
+     * Alchemy Gas Manager policy id (UUID). Passed to the paymaster RPC
+     * via the ERC-7677 context object so the bundler knows which policy
+     * is sponsoring this UserOp.
+     */
+    paymasterPolicyId: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B"}

package/dist/cctp-inbound/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared types for the CCTP-inbound flow.
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/cctp-inbound/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -0,0 +1,93 @@
+/**
+ * Compose the `executeBatch` calldata for a CCTP-inbound UserOperation.
+ *
+ * The smart account's batch atomically runs:
+ *   1. `MessageTransmitter.receiveMessage(message, attestation)` — mints
+ *      USDC to the smart account.
+ *   2. `USDC.approve(Permit2, max)` — idempotent.
+ *   3. `HTLCCoordinator.executeAndCreateWithPermit2(...)` — uses an
+ *      ERC-1271 signature from the smart account as `depositor`.
+ *
+ * All three calls execute with `msg.sender = smartAccount`, so CCTPv2's
+ * `destinationCaller` gate (pinned to the same address on the burn) is
+ * satisfied.
+ */
+import type { Address, Hex } from "viem";
+/**
+ * Shape returned by the backend's
+ * `GET /v1/swap/:id/swap-and-lock-calldata-userop` endpoint.
+ * Field names match the REST JSON (snake_case).
+ */
+export interface UseropCalldataResponse {
+    coordinator_address: string;
+    permit2_address: string;
+    source_token_address: string;
+    source_amount: string;
+    lock_token_address: string;
+    preimage_hash: string;
+    claim_address: string;
+    timelock: number;
+    calls: Array<{
+        target: string;
+        value: string;
+        call_data: string;
+    }>;
+    calls_hash: string;
+    relay_fee?: string;
+    aa: {
+        entry_point: string;
+        account_factory: string;
+        account_impl: string;
+        salt: string;
+    };
+}
+/**
+ * Sign arbitrary EIP-712 typed data with the smart account.
+ *
+ * For Kernel this wraps the hash with its "message marker" before
+ * ecrecover, so the resulting sig passes ERC-1271 verification on the
+ * deployed account. Pass `kernelAccount.signTypedData` directly.
+ */
+export type SignTypedDataFn = (args: any) => Promise<Hex>;
+export interface BuildCctpInboundBatchParams {
+    /** Calldata payload from the backend. */
+    server: UseropCalldataResponse;
+    /** Deterministic smart-account address that owns the HTLC deposit. */
+    smartAccountAddress: Address;
+    /** Produces an ERC-1271-compatible Permit2 signature via the smart account. */
+    signTypedData: SignTypedDataFn;
+    /** Raw IRIS message bytes (hex, 0x-prefixed). */
+    cctpMessage: Hex;
+    /** Raw IRIS attestation bytes (hex, 0x-prefixed). */
+    cctpAttestation: Hex;
+    /** Settlement chain id — used as the Permit2 domain chain id. */
+    chainId: number;
+    /** Whether USDC is already at `smartAccountAddress` (skip receiveMessage). */
+    skipReceiveMessage?: boolean;
+}
+/** A single (target, data, value) call the smart account will execute. */
+export interface BatchCall {
+    to: Address;
+    data: Hex;
+    value: bigint;
+}
+export interface BuiltBatch {
+    calls: BatchCall[];
+    /** The Permit2 nonce used in the witness; useful to log / surface. */
+    permit2Nonce: bigint;
+    /** Deadline embedded in the Permit2 signature (unix seconds). */
+    permit2Deadline: bigint;
+}
+/**
+ * Returns the list of calls the smart account's `executeBatch` will run.
+ * The Permit2 signature is produced via the Kernel smart account's
+ * `signTypedData` — Kernel wraps the hash before signing so the sig
+ * passes its own ERC-1271 verification once the account is deployed.
+ */
+export declare function buildCctpInboundBatch(params: BuildCctpInboundBatchParams): Promise<BuiltBatch>;
+/**
+ * Convert an EVM address (20 bytes) into the bytes32 form CCTPv2's
+ * `depositForBurn` expects for `mintRecipient` and `destinationCaller`.
+ */
+export declare function addressToBytes32Hex(address: Address): Hex;
+//# sourceMappingURL=userOp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"userOp.d.ts","sourceRoot":"","sources":["../../src/cctp-inbound/userOp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAmB,MAAM,MAAM,CAAC;AAiC1D;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE;QACF,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED;;;;;;GAMG;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAE1D,MAAM,WAAW,2BAA2B;IAC1C,yCAAyC;IACzC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,sEAAsE;IACtE,mBAAmB,EAAE,OAAO,CAAC;IAC7B,+EAA+E;IAC/E,aAAa,EAAE,eAAe,CAAC;IAC/B,iDAAiD;IACjD,WAAW,EAAE,GAAG,CAAC;IACjB,qDAAqD;IACrD,eAAe,EAAE,GAAG,CAAC;IACrB,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,0EAA0E;AAC1E,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,UAAU,CAAC,CA4HrB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,GAAG,CAEzD"}

package/dist/cctp-inbound/userOp.js

@@ -0,0 +1,151 @@
+/**
+ * Compose the `executeBatch` calldata for a CCTP-inbound UserOperation.
+ *
+ * The smart account's batch atomically runs:
+ *   1. `MessageTransmitter.receiveMessage(message, attestation)` — mints
+ *      USDC to the smart account.
+ *   2. `USDC.approve(Permit2, max)` — idempotent.
+ *   3. `HTLCCoordinator.executeAndCreateWithPermit2(...)` — uses an
+ *      ERC-1271 signature from the smart account as `depositor`.
+ *
+ * All three calls execute with `msg.sender = smartAccount`, so CCTPv2's
+ * `destinationCaller` gate (pinned to the same address on the burn) is
+ * satisfied.
+ */
+import { encodeAbiParameters, encodeFunctionData, isErc6492Signature, maxUint256, parseAbi, parseErc6492Signature, } from "viem";
+import { buildPermit2TypedData } from "../evm/coordinator.js";
+/** MessageTransmitter v2 — same on every CCTPv2 EVM chain. */
+const MESSAGE_TRANSMITTER_V2 = "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64";
+/** Canonical Permit2 deployment — same on all EVM chains. */
+const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+const MESSAGE_TRANSMITTER_ABI = parseAbi([
+    "function receiveMessage(bytes message, bytes attestation) external returns (bool)",
+]);
+const ERC20_APPROVE_ABI = parseAbi([
+    "function approve(address spender, uint256 amount) external returns (bool)",
+]);
+const HTLC_COORDINATOR_ABI = parseAbi([
+    "struct TokenPermissions { address token; uint256 amount; }",
+    "struct PermitTransferFrom { TokenPermissions permitted; uint256 nonce; uint256 deadline; }",
+    "struct Call { address target; uint256 value; bytes callData; }",
+    "function executeAndCreateWithPermit2(Call[] calls, bytes32 preimageHash, address token, address claimAddress, uint256 timelock, address depositor, PermitTransferFrom permit, bytes signature) external",
+]);
+/**
+ * Returns the list of calls the smart account's `executeBatch` will run.
+ * The Permit2 signature is produced via the Kernel smart account's
+ * `signTypedData` — Kernel wraps the hash before signing so the sig
+ * passes its own ERC-1271 verification once the account is deployed.
+ */
+export async function buildCctpInboundBatch(params) {
+    const { server, smartAccountAddress, signTypedData, cctpMessage, cctpAttestation, chainId, skipReceiveMessage, } = params;
+    const calls = [];
+    // 1. receiveMessage — skip if USDC already landed (front-runner / retry).
+    if (!skipReceiveMessage) {
+        const receiveMessageData = encodeFunctionData({
+            abi: MESSAGE_TRANSMITTER_ABI,
+            functionName: "receiveMessage",
+            args: [cctpMessage, cctpAttestation],
+        });
+        calls.push({
+            to: MESSAGE_TRANSMITTER_V2,
+            data: receiveMessageData,
+            value: 0n,
+        });
+    }
+    // 2. USDC.approve(Permit2, max) — idempotent; lets Permit2 pull from us.
+    const approveData = encodeFunctionData({
+        abi: ERC20_APPROVE_ABI,
+        functionName: "approve",
+        args: [PERMIT2_ADDRESS, maxUint256],
+    });
+    calls.push({
+        to: server.source_token_address,
+        data: approveData,
+        value: 0n,
+    });
+    // 3. Permit2 witness signature, produced via the smart account.
+    //    Kernel's signTypedData applies its message-marker wrap so the
+    //    resulting sig passes ERC-1271 when Permit2 calls back into the
+    //    (by then-deployed) account.
+    const nonceBytes = new Uint8Array(32);
+    crypto.getRandomValues(nonceBytes);
+    const permit2Nonce = BigInt(`0x${Array.from(nonceBytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")}`);
+    const permit2Deadline = BigInt(Math.floor(Date.now() / 1000) + 30 * 60);
+    const sourceAmount = BigInt(server.source_amount);
+    const typedData = buildPermit2TypedData({
+        chainId,
+        coordinatorAddress: server.coordinator_address,
+        sourceToken: server.source_token_address,
+        sourceAmount,
+        preimageHash: server.preimage_hash,
+        lockToken: server.lock_token_address,
+        claimAddress: server.claim_address,
+        refundAddress: server.coordinator_address,
+        timelock: server.timelock,
+        callsHash: server.calls_hash,
+        nonce: permit2Nonce,
+        deadline: permit2Deadline,
+    });
+    const rawSignature = (await signTypedData({
+        domain: typedData.domain,
+        types: typedData.types,
+        primaryType: typedData.primaryType,
+        message: typedData.message,
+    }));
+    // viem's `toSmartAccount` auto-wraps `signTypedData` output in ERC-6492
+    // whenever the account's factory/factoryData are non-empty. Permit2 is
+    // not ERC-6492-aware, so strip the wrapper and pass the raw Kernel
+    // signature. The account will be deployed by factoryData during the
+    // UserOp *before* Permit2 verifies, so Permit2 takes the ERC-1271
+    // path and Kernel's `isValidSignature` accepts the raw sig.
+    const permit2Signature = isErc6492Signature(rawSignature)
+        ? parseErc6492Signature(rawSignature).signature
+        : rawSignature;
+    // 4. executeAndCreateWithPermit2
+    const dexCalls = server.calls.map((c) => ({
+        target: c.target,
+        value: BigInt(c.value),
+        callData: c.call_data,
+    }));
+    const executeData = encodeFunctionData({
+        abi: HTLC_COORDINATOR_ABI,
+        functionName: "executeAndCreateWithPermit2",
+        args: [
+            dexCalls,
+            server.preimage_hash,
+            server.lock_token_address,
+            server.claim_address,
+            BigInt(server.timelock),
+            smartAccountAddress,
+            {
+                permitted: {
+                    token: server.source_token_address,
+                    amount: sourceAmount,
+                },
+                nonce: permit2Nonce,
+                deadline: permit2Deadline,
+            },
+            permit2Signature,
+        ],
+    });
+    calls.push({
+        to: server.coordinator_address,
+        data: executeData,
+        value: 0n,
+    });
+    return {
+        calls,
+        permit2Nonce,
+        permit2Deadline,
+    };
+}
+/**
+ * Convert an EVM address (20 bytes) into the bytes32 form CCTPv2's
+ * `depositForBurn` expects for `mintRecipient` and `destinationCaller`.
+ */
+export function addressToBytes32Hex(address) {
+    return encodeAbiParameters([{ type: "address" }], [address]);
+}
+//# sourceMappingURL=userOp.js.map

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

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