@rhinestone/sdk 1.5.1 → 2.0.0-beta.1

package/dist/src/execution/index.js

@@ -1,29 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignerNotSupportedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.IntentStatusTimeoutError = exports.IntentFailedError = exports.ExecutionError = exports.isExecutionError = void 0;
-exports.sendTransaction = sendTransaction;
-exports.sendTransactionInternal = sendTransactionInternal;
-exports.sendUserOperation = sendUserOperation;
-exports.sendUserOperationInternal = sendUserOperationInternal;
-exports.waitForExecution = waitForExecution;
-exports.getPortfolio = getPortfolio;
-exports.getIntentStatus = getIntentStatus;
-exports.splitIntents = splitIntents;
-const viem_1 = require("viem");
-const accounts_1 = require("../accounts");
-const utils_1 = require("../accounts/utils");
-const provider_1 = require("../auth/provider");
-const orchestrator_1 = require("../orchestrator");
-const registry_1 = require("../orchestrator/registry");
-const error_1 = require("./error");
-Object.defineProperty(exports, "ExecutionError", { enumerable: true, get: function () { return error_1.ExecutionError; } });
-Object.defineProperty(exports, "IntentFailedError", { enumerable: true, get: function () { return error_1.IntentFailedError; } });
-Object.defineProperty(exports, "IntentStatusTimeoutError", { enumerable: true, get: function () { return error_1.IntentStatusTimeoutError; } });
-Object.defineProperty(exports, "isExecutionError", { enumerable: true, get: function () { return error_1.isExecutionError; } });
-Object.defineProperty(exports, "OrderPathRequiredForIntentsError", { enumerable: true, get: function () { return error_1.OrderPathRequiredForIntentsError; } });
-Object.defineProperty(exports, "SessionChainRequiredError", { enumerable: true, get: function () { return error_1.SessionChainRequiredError; } });
-Object.defineProperty(exports, "SignerNotSupportedError", { enumerable: true, get: function () { return error_1.SignerNotSupportedError; } });
-const utils_2 = require("./utils");
+import { createPublicClient } from 'viem';
+import { deploy, getAddress } from '../accounts/index.js';
+import { createTransport, getBundlerClient } from '../accounts/utils.js';
+import { createAuthProvider } from '../auth/provider.js';
+import { getOrchestrator, INTENT_STATUS_COMPLETED, INTENT_STATUS_FAILED, INTENT_STATUS_FILLED, INTENT_STATUS_PRECONFIRMED, isRateLimited, isRetryable, } from '../orchestrator/index.js';
+import { getChainById, getSupportedChainIds, isTestnet, } from '../orchestrator/registry.js';
+import { ExecutionError, IntentFailedError, IntentStatusTimeoutError, isExecutionError, OrderPathRequiredForIntentsError, QuoteNotInPreparedTransactionError, SessionChainRequiredError, SignerNotSupportedError, } from './error.js';
+import { getTargetExecutionSignature, getTokenRequests, getValidatorAccount, parseCalls, prepareTransactionAsIntent, resolveCallInputs, signAuthorizationsInternal, signIntent, submitIntentInternal, } from './utils.js';
 const POLL_INITIAL_MS = 500;
 const POLL_SLOW_AFTER_MS = 15000;
 const POLL_SLOW_MS = 2000;
@@ -36,7 +18,7 @@ async function sendTransaction(config, transaction) {
     const { calls, gasLimit, tokenRequests, recipient, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, } = transaction;
     const isUserOpSigner = signers?.type === 'guardians';
     if (isUserOpSigner) {
-        throw new error_1.SignerNotSupportedError();
+        throw new SignerNotSupportedError();
     }
     return await sendTransactionInternal(config, sourceChains, targetChain, {
         callInputs: calls,
@@ -52,35 +34,35 @@ async function sendTransaction(config, transaction) {
     });
 }
 async function sendUserOperation(config, transaction) {
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const resolvedCalls = await (0, utils_2.resolveCallInputs)(transaction.calls, config, transaction.chain, accountAddress);
+    const accountAddress = getAddress(config);
+    const resolvedCalls = await resolveCallInputs(transaction.calls, config, transaction.chain, accountAddress);
     return await sendUserOperationInternal(config, transaction.chain, resolvedCalls, transaction.signers);
 }
 async function sendTransactionInternal(config, sourceChains, targetChain, options) {
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const resolvedCalls = await (0, utils_2.resolveCallInputs)(options.callInputs, config, targetChain, accountAddress);
-    const tokenRequests = (0, utils_2.getTokenRequests)(targetChain, options.initialTokenRequests);
+    const accountAddress = getAddress(config);
+    const resolvedCalls = await resolveCallInputs(options.callInputs, config, targetChain, accountAddress);
+    const tokenRequests = getTokenRequests(targetChain, options.initialTokenRequests);
     const sendAsUserOp = options.signers?.type === 'guardians';
     if (sendAsUserOp) {
-        throw new error_1.SignerNotSupportedError();
+        throw new SignerNotSupportedError();
     }
     else {
-        return await sendTransactionAsIntent(config, sourceChains, targetChain, resolvedCalls, options.gasLimit, tokenRequests, options.recipient, options.signers, options.sponsored, options.eip7702InitSignature, options.settlementLayers, options.sourceAssets, options.feeAsset, options.lockFunds);
+        return await sendTransactionAsIntent(config, sourceChains, targetChain, resolvedCalls, options.gasLimit, tokenRequests, options.recipient, options.signers, options.sponsored, options.eip7702InitSignature, options.settlementLayers, options.sourceAssets, options.feeAsset);
     }
 }
 async function sendUserOperationInternal(config, chain, callInputs, signers) {
     // Make sure the account is deployed
-    await (0, accounts_1.deploy)(config, chain);
-    const publicClient = (0, viem_1.createPublicClient)({
+    await deploy(config, chain);
+    const publicClient = createPublicClient({
         chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
+        transport: createTransport(chain, config.provider),
     });
-    const validatorAccount = await (0, utils_2.getValidatorAccount)(config, signers, publicClient, chain);
+    const validatorAccount = await getValidatorAccount(config, signers, publicClient, chain);
     if (!validatorAccount) {
         throw new Error('No validator account found');
     }
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    const calls = (0, utils_2.parseCalls)(callInputs, chain.id);
+    const bundlerClient = getBundlerClient(config, publicClient);
+    const calls = parseCalls(callInputs, chain.id);
     const hash = await bundlerClient.sendUserOperation({
         account: validatorAccount,
         calls,
@@ -91,27 +73,32 @@ async function sendUserOperationInternal(config, chain, callInputs, signers) {
         chain: chain.id,
     };
 }
-async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds) {
-    const prepared = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, sponsored ?? false, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, undefined, undefined, signers);
+async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset) {
+    const prepared = await prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, sponsored ?? false, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, undefined, undefined, signers);
     if (!prepared) {
-        throw new error_1.OrderPathRequiredForIntentsError();
+        throw new OrderPathRequiredForIntentsError();
     }
-    const { intentRoute, intentInput } = prepared;
-    const { originSignatures, destinationSignature } = await (0, utils_2.signIntent)(config, intentRoute.intentOp, targetChain, signers);
-    const targetExecutionSignature = await (0, utils_2.getTargetExecutionSignature)(config, intentRoute.intentOp, targetChain, signers);
+    const { quotes, intentInput } = prepared;
+    const quote = quotes.best;
+    const { originSignatures, destinationSignature } = await signIntent(config, quote.signData, targetChain, signers);
+    const targetExecutionSignature = await getTargetExecutionSignature(config, quote.signData, targetChain, signers);
     const authorizations = config.eoa
-        ? await (0, utils_2.signAuthorizationsInternal)(config, intentRoute)
+        ? await signAuthorizationsInternal(config, {
+            sourceChains,
+            targetChain,
+            eip7702InitSignature,
+        })
         : [];
-    return await (0, utils_2.submitIntentInternal)(config, sourceChains, targetChain, intentRoute.intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, false, intentInput);
+    return await submitIntentInternal(config, sourceChains, targetChain, quote, originSignatures, destinationSignature, targetExecutionSignature, authorizations, false, intentInput);
 }
 async function waitForExecution(config, result, acceptsPreconfirmations) {
     const validStatuses = new Set([
-        orchestrator_1.INTENT_STATUS_FAILED,
-        orchestrator_1.INTENT_STATUS_COMPLETED,
-        orchestrator_1.INTENT_STATUS_FILLED,
+        INTENT_STATUS_FAILED,
+        INTENT_STATUS_COMPLETED,
+        INTENT_STATUS_FILLED,
     ]);
     if (acceptsPreconfirmations) {
-        validStatuses.add(orchestrator_1.INTENT_STATUS_PRECONFIRMED);
+        validStatuses.add(INTENT_STATUS_PRECONFIRMED);
     }
     switch (result.type) {
         case 'intent': {
@@ -122,15 +109,15 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
             while (intentStatus === null || !validStatuses.has(intentStatus.status)) {
                 const now = Date.now();
                 if (now - startTs >= POLL_MAX_WAIT_MS) {
-                    throw new error_1.IntentStatusTimeoutError({
+                    throw new IntentStatusTimeoutError({
                         context: {
-                            intentId: result.id.toString(),
+                            intentId: result.id,
                         },
                     });
                 }
-                const orchestrator = (0, orchestrator_1.getOrchestrator)(config._authProvider ?? (0, provider_1.createAuthProvider)(config), config.endpointUrl, config.headers);
+                const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
                 try {
-                    intentStatus = await orchestrator.getIntentOpStatus(result.id);
+                    intentStatus = await orchestrator.getIntent(result.id);
                     // reset error backoff on success
                     errorBackoffMs = POLL_ERROR_BACKOFF_MS;
                     const elapsed = Date.now() - startTs;
@@ -139,8 +126,8 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
                     await new Promise((resolve) => setTimeout(resolve, nextDelayMs));
                 }
                 catch (err) {
-                    if ((0, orchestrator_1.isRateLimited)(err)) {
-                        const retryAfter = err?.context?.retryAfter;
+                    if (isRateLimited(err)) {
+                        const retryAfter = err.retryAfter;
                         let retryMs = nextDelayMs;
                         if (retryAfter) {
                             const parsed = Number(retryAfter);
@@ -160,7 +147,7 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
                         await new Promise((resolve) => setTimeout(resolve, retryMs));
                         continue;
                     }
-                    if ((0, orchestrator_1.isRetryable)(err)) {
+                    if (isRetryable(err)) {
                         const backoff = Math.min(errorBackoffMs, POLL_ERROR_BACKOFF_MAX_MS);
                         errorBackoffMs = Math.min(errorBackoffMs * 2, POLL_ERROR_BACKOFF_MAX_MS);
                         await new Promise((resolve) => setTimeout(resolve, backoff));
@@ -169,11 +156,10 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
                     throw err;
                 }
             }
-            if (intentStatus.status === orchestrator_1.INTENT_STATUS_FAILED) {
-                const intentId = result.id.toString();
-                throw new error_1.IntentFailedError({
+            if (intentStatus.status === INTENT_STATUS_FAILED) {
+                throw new IntentFailedError({
                     context: {
-                        intentId,
+                        intentId: result.id,
                     },
                 });
             }
@@ -189,12 +175,12 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
             };
         }
         case 'userop': {
-            const targetChain = (0, registry_1.getChainById)(result.chain);
-            const publicClient = (0, viem_1.createPublicClient)({
+            const targetChain = getChainById(result.chain);
+            const publicClient = createPublicClient({
                 chain: targetChain,
-                transport: (0, utils_1.createTransport)(targetChain, config.provider),
+                transport: createTransport(targetChain, config.provider),
             });
-            const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+            const bundlerClient = getBundlerClient(config, publicClient);
             const receipt = await bundlerClient.waitForUserOperationReceipt({
                 hash: result.hash,
             });
@@ -203,12 +189,12 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
     }
 }
 async function getPortfolio(config, onTestnets) {
-    const address = (0, accounts_1.getAddress)(config);
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(config._authProvider ?? (0, provider_1.createAuthProvider)(config), config.endpointUrl, config.headers);
-    const supportedChainIds = (0, registry_1.getSupportedChainIds)();
+    const address = getAddress(config);
+    const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
+    const supportedChainIds = getSupportedChainIds();
     const filteredChainIds = supportedChainIds.filter((id) => {
         try {
-            return (0, registry_1.isTestnet)(id) === onTestnets;
+            return isTestnet(id) === onTestnets;
         }
         catch {
             return false;
@@ -217,8 +203,8 @@ async function getPortfolio(config, onTestnets) {
     return orchestrator.getPortfolio(address, { chainIds: filteredChainIds });
 }
 async function getIntentStatus(authProvider, endpointUrl, intentId, headers) {
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(authProvider, endpointUrl, headers);
-    const internalStatus = await orchestrator.getIntentOpStatus(intentId);
+    const orchestrator = getOrchestrator(authProvider, endpointUrl, headers);
+    const internalStatus = await orchestrator.getIntent(intentId);
     return {
         status: internalStatus.status,
         fill: {
@@ -232,6 +218,9 @@ async function getIntentStatus(authProvider, endpointUrl, intentId, headers) {
     };
 }
 async function splitIntents(authProvider, endpointUrl, input, headers) {
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(authProvider, endpointUrl, headers);
-    return orchestrator.splitIntents(input);
+    const orchestrator = getOrchestrator(authProvider, endpointUrl, headers);
+    return orchestrator.getSplit(input);
 }
+export { sendTransaction, sendTransactionInternal, sendUserOperation, sendUserOperationInternal, waitForExecution, getPortfolio, getIntentStatus, splitIntents, 
+// Errors
+isExecutionError, ExecutionError, IntentFailedError, IntentStatusTimeoutError, OrderPathRequiredForIntentsError, QuoteNotInPreparedTransactionError, SessionChainRequiredError, SignerNotSupportedError, };

package/dist/src/execution/permit2.d.ts

@@ -1,143 +1,7 @@
 import { type Address, type Chain } from 'viem';
-import type { IntentOpElement } from '../orchestrator/types';
-import type { RhinestoneConfig } from '../types';
-import type { BatchPermit2Result, MultiChainPermit2Config, MultiChainPermit2Result, TokenPermissions } from './types';
-declare function getTypedData(element: IntentOpElement, nonce: bigint, expires: bigint): {
-    readonly domain: {
-        readonly name: "Permit2";
-        readonly chainId: number;
-        readonly verifyingContract: "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-    };
-    readonly types: {
-        readonly TokenPermissions: readonly [{
-            readonly name: "token";
-            readonly type: "address";
-        }, {
-            readonly name: "amount";
-            readonly type: "uint256";
-        }];
-        readonly Token: readonly [{
-            readonly name: "token";
-            readonly type: "address";
-        }, {
-            readonly name: "amount";
-            readonly type: "uint256";
-        }];
-        readonly Target: readonly [{
-            readonly name: "recipient";
-            readonly type: "address";
-        }, {
-            readonly name: "tokenOut";
-            readonly type: "Token[]";
-        }, {
-            readonly name: "targetChain";
-            readonly type: "uint256";
-        }, {
-            readonly name: "fillExpiry";
-            readonly type: "uint256";
-        }];
-        readonly Ops: readonly [{
-            readonly name: "to";
-            readonly type: "address";
-        }, {
-            readonly name: "value";
-            readonly type: "uint256";
-        }, {
-            readonly name: "data";
-            readonly type: "bytes";
-        }];
-        readonly Op: readonly [{
-            readonly name: "vt";
-            readonly type: "bytes32";
-        }, {
-            readonly name: "ops";
-            readonly type: "Ops[]";
-        }];
-        readonly Mandate: readonly [{
-            readonly name: "target";
-            readonly type: "Target";
-        }, {
-            readonly name: "minGas";
-            readonly type: "uint128";
-        }, {
-            readonly name: "originOps";
-            readonly type: "Op";
-        }, {
-            readonly name: "destOps";
-            readonly type: "Op";
-        }, {
-            readonly name: "q";
-            readonly type: "bytes32";
-        }];
-        readonly PermitBatchWitnessTransferFrom: readonly [{
-            readonly name: "permitted";
-            readonly type: "TokenPermissions[]";
-        }, {
-            readonly name: "spender";
-            readonly type: "address";
-        }, {
-            readonly name: "nonce";
-            readonly type: "uint256";
-        }, {
-            readonly name: "deadline";
-            readonly type: "uint256";
-        }, {
-            readonly name: "mandate";
-            readonly type: "Mandate";
-        }];
-    };
-    readonly primaryType: "PermitBatchWitnessTransferFrom";
-    readonly message: {
-        readonly permitted: TokenPermissions[];
-        readonly spender: `0x${string}`;
-        readonly nonce: bigint;
-        readonly deadline: bigint;
-        readonly mandate: {
-            readonly target: {
-                readonly recipient: `0x${string}`;
-                readonly tokenOut: {
-                    token: `0x${string}`;
-                    amount: bigint;
-                }[];
-                readonly targetChain: bigint;
-                readonly fillExpiry: bigint;
-            };
-            readonly minGas: bigint;
-            readonly originOps: import("../orchestrator/types").Op;
-            readonly destOps: import("../orchestrator/types").Op;
-            readonly q: `0x${string}`;
-        };
-    };
-};
+import type { RhinestoneConfig } from '../types.js';
 declare function checkERC20AllowanceDirect(owner: Address, spender: Address, tokenAddress: Address, publicClient: any): Promise<bigint>;
 declare function checkERC20Allowance(tokenAddress: Address, chain: Chain, config: RhinestoneConfig): Promise<bigint>;
-/**
- * Get the Permit2 contract address
- * @returns The Permit2 contract address
- */
 declare function getPermit2Address(): Address;
-/**
- * Signs permit2 calls across multiple chains using batch approach.
- * Collects all signatures first, then returns them all at once.
- *
- * This approach is efficient for backend signers but may be memory-intensive
- * for frontend applications with many chains.
- *
- * @param configs - Array of permit2 signing configurations for different chains
- * @returns Promise<BatchPermit2Result> - All signatures collected
- */
-declare function signPermit2Batch(configs: MultiChainPermit2Config[]): Promise<BatchPermit2Result>;
-/**
- * Signs permit2 calls across multiple chains sequentially.
- * Signs one by one, useful for frontend applications to avoid memory issues.
- *
- * This approach is more memory-efficient for frontend applications but slower
- * due to sequential processing.
- *
- * @param configs - Array of permit2 signing configurations for different chains
- * @param onProgress - Optional callback for progress updates
- * @returns Promise<BatchPermit2Result> - All signatures collected
- */
-declare function signPermit2Sequential(configs: MultiChainPermit2Config[], onProgress?: (completed: number, total: number, current: MultiChainPermit2Result) => void): Promise<BatchPermit2Result>;
-export { getTypedData, checkERC20Allowance, checkERC20AllowanceDirect, getPermit2Address, signPermit2Batch, signPermit2Sequential, type MultiChainPermit2Config, type MultiChainPermit2Result, type BatchPermit2Result, };
+export { checkERC20Allowance, checkERC20AllowanceDirect, getPermit2Address };
 //# sourceMappingURL=permit2.d.ts.map

package/dist/src/execution/permit2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permit2.d.ts","sourceRoot":"","sources":["../../../execution/permit2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIX,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EACV,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAQhB,iBAAS,YAAY,CACnB,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwFhB;AAED,iBAAe,yBAAyB,CACtC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,GAAG,GAChB,OAAO,CAAC,MAAM,CAAC,CAyBjB;AAED,iBAAe,mBAAmB,CAChC,YAAY,EAAE,OAAO,EACrB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAED;;;GAGG;AACH,iBAAS,iBAAiB,IAAI,OAAO,CAEpC;AAED;;;;;;;;;GASG;AACH,iBAAe,gBAAgB,CAC7B,OAAO,EAAE,uBAAuB,EAAE,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAyE7B;AAED;;;;;;;;;;GAUG;AACH,iBAAe,qBAAqB,CAClC,OAAO,EAAE,uBAAuB,EAAE,EAClC,UAAU,CAAC,EAAE,CACX,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,uBAAuB,KAC7B,IAAI,GACR,OAAO,CAAC,kBAAkB,CAAC,CA8D7B;AAED,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB,EAEjB,gBAAgB,EAChB,qBAAqB,EAErB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,GACxB,CAAA"}
+{"version":3,"file":"permit2.d.ts","sourceRoot":"","sources":["../../../execution/permit2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAsB,MAAM,MAAM,CAAA;AAEnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAIhD,iBAAe,yBAAyB,CACtC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,GAAG,GAChB,OAAO,CAAC,MAAM,CAAC,CAyBjB;AAED,iBAAe,mBAAmB,CAChC,YAAY,EAAE,OAAO,EACrB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAED,iBAAS,iBAAiB,IAAI,OAAO,CAEpC;AAED,OAAO,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/src/execution/permit2.js

@@ -1,101 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypedData = getTypedData;
-exports.checkERC20Allowance = checkERC20Allowance;
-exports.checkERC20AllowanceDirect = checkERC20AllowanceDirect;
-exports.getPermit2Address = getPermit2Address;
-exports.signPermit2Batch = signPermit2Batch;
-exports.signPermit2Sequential = signPermit2Sequential;
-const viem_1 = require("viem");
-const utils_1 = require("../accounts/utils");
+import { createPublicClient } from 'viem';
+import { createTransport } from '../accounts/utils.js';
 const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
-function toToken(id) {
-    return `0x${(id & ((1n << 160n) - 1n)).toString(16).padStart(40, '0')}`;
-}
-function getTypedData(element, nonce, expires) {
-    const tokens = element.idsAndAmounts.map(([id, amount]) => [
-        BigInt(id),
-        BigInt(amount),
-    ]);
-    const tokenPermissions = tokens.reduce((permissions, [id, amountIn]) => {
-        const token = toToken(BigInt(id));
-        const amount = BigInt(amountIn);
-        const permission = { token, amount };
-        permissions.push(permission);
-        return permissions;
-    }, []);
-    const spender = element.arbiter;
-    const mandate = element.mandate;
-    const typedData = {
-        domain: {
-            name: 'Permit2',
-            chainId: Number(element.chainId),
-            verifyingContract: PERMIT2_ADDRESS,
-        },
-        types: {
-            TokenPermissions: [
-                { name: 'token', type: 'address' },
-                { name: 'amount', type: 'uint256' },
-            ],
-            Token: [
-                { name: 'token', type: 'address' },
-                { name: 'amount', type: 'uint256' },
-            ],
-            Target: [
-                { name: 'recipient', type: 'address' },
-                { name: 'tokenOut', type: 'Token[]' },
-                { name: 'targetChain', type: 'uint256' },
-                { name: 'fillExpiry', type: 'uint256' },
-            ],
-            Ops: [
-                { name: 'to', type: 'address' },
-                { name: 'value', type: 'uint256' },
-                { name: 'data', type: 'bytes' },
-            ],
-            Op: [
-                { name: 'vt', type: 'bytes32' },
-                { name: 'ops', type: 'Ops[]' },
-            ],
-            Mandate: [
-                { name: 'target', type: 'Target' },
-                { name: 'minGas', type: 'uint128' },
-                { name: 'originOps', type: 'Op' },
-                { name: 'destOps', type: 'Op' },
-                { name: 'q', type: 'bytes32' },
-            ],
-            PermitBatchWitnessTransferFrom: [
-                { name: 'permitted', type: 'TokenPermissions[]' },
-                { name: 'spender', type: 'address' },
-                { name: 'nonce', type: 'uint256' },
-                { name: 'deadline', type: 'uint256' },
-                { name: 'mandate', type: 'Mandate' },
-            ],
-        },
-        primaryType: 'PermitBatchWitnessTransferFrom',
-        message: {
-            permitted: tokenPermissions,
-            spender: spender,
-            nonce: nonce,
-            deadline: expires,
-            mandate: {
-                target: {
-                    recipient: mandate.recipient,
-                    tokenOut: mandate.tokenOut.map((token) => ({
-                        token: toToken(BigInt(token[0])),
-                        amount: BigInt(token[1]),
-                    })),
-                    targetChain: BigInt(mandate.destinationChainId),
-                    fillExpiry: BigInt(mandate.fillDeadline),
-                },
-                minGas: BigInt(mandate.minGas),
-                originOps: mandate.preClaimOps,
-                destOps: mandate.destinationOps,
-                q: (0, viem_1.keccak256)(mandate.qualifier.encodedVal),
-            },
-        },
-    };
-    return typedData;
-}
 async function checkERC20AllowanceDirect(owner, spender, tokenAddress, publicClient) {
     try {
         const allowance = await publicClient.readContract({
@@ -124,9 +29,9 @@ async function checkERC20AllowanceDirect(owner, spender, tokenAddress, publicCli
 }
 async function checkERC20Allowance(tokenAddress, chain, config) {
     try {
-        const publicClient = (0, viem_1.createPublicClient)({
+        const publicClient = createPublicClient({
             chain,
-            transport: (0, utils_1.createTransport)(chain, config.provider),
+            transport: createTransport(chain, config.provider),
         });
         // Get the account owner from the config
         const owner = config.eoa?.address;
@@ -140,146 +45,7 @@ async function checkERC20Allowance(tokenAddress, chain, config) {
         throw new Error('Failed to check ERC20 allowance');
     }
 }
-/**
- * Get the Permit2 contract address
- * @returns The Permit2 contract address
- */
 function getPermit2Address() {
     return PERMIT2_ADDRESS;
 }
-/**
- * Signs permit2 calls across multiple chains using batch approach.
- * Collects all signatures first, then returns them all at once.
- *
- * This approach is efficient for backend signers but may be memory-intensive
- * for frontend applications with many chains.
- *
- * @param configs - Array of permit2 signing configurations for different chains
- * @returns Promise<BatchPermit2Result> - All signatures collected
- */
-async function signPermit2Batch(configs) {
-    const results = [];
-    let successfulSignatures = 0;
-    let failedSignatures = 0;
-    // Process all signing operations in parallel
-    const signingPromises = configs.map(async (config) => {
-        try {
-            // sign each element individually for this chain sequentially to preserve order
-            if (!config.eoaAccount.signTypedData) {
-                throw new Error('EOA account does not support typed data signing');
-            }
-            const originSignatures = [];
-            for (const element of config.intentOp.elements) {
-                const typedData = getTypedData(element, BigInt(config.intentOp.nonce), BigInt(config.intentOp.expires));
-                const sig = await config.eoaAccount.signTypedData(typedData);
-                originSignatures.push(sig);
-            }
-            const result = {
-                chainId: config.chain.id,
-                originSignatures,
-                destinationSignature: originSignatures[0] ?? '0x',
-                success: true,
-            };
-            successfulSignatures++;
-            return result;
-        }
-        catch (error) {
-            const result = {
-                chainId: config.chain.id,
-                originSignatures: [],
-                destinationSignature: '0x',
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-            failedSignatures++;
-            return result;
-        }
-    });
-    // Wait for all signing operations to complete
-    const signingResults = await Promise.allSettled(signingPromises);
-    for (const result of signingResults) {
-        if (result.status === 'fulfilled') {
-            results.push(result.value);
-        }
-        else {
-            // This shouldn't happen since we catch errors in the promise
-            failedSignatures++;
-            results.push({
-                chainId: 0,
-                originSignatures: [],
-                destinationSignature: '0x',
-                success: false,
-                error: result.reason,
-            });
-        }
-    }
-    return {
-        results,
-        totalChains: configs.length,
-        successfulSignatures,
-        failedSignatures,
-        allSuccessful: failedSignatures === 0,
-    };
-}
-/**
- * Signs permit2 calls across multiple chains sequentially.
- * Signs one by one, useful for frontend applications to avoid memory issues.
- *
- * This approach is more memory-efficient for frontend applications but slower
- * due to sequential processing.
- *
- * @param configs - Array of permit2 signing configurations for different chains
- * @param onProgress - Optional callback for progress updates
- * @returns Promise<BatchPermit2Result> - All signatures collected
- */
-async function signPermit2Sequential(configs, onProgress) {
-    const results = [];
-    let successfulSignatures = 0;
-    let failedSignatures = 0;
-    // Process signing operations sequentially
-    for (let i = 0; i < configs.length; i++) {
-        const config = configs[i];
-        try {
-            // sign each element for this chain sequentially to preserve order
-            if (!config.eoaAccount.signTypedData) {
-                throw new Error('EOA account does not support typed data signing');
-            }
-            const originSignatures = [];
-            for (const element of config.intentOp.elements) {
-                const typedData = getTypedData(element, BigInt(config.intentOp.nonce), BigInt(config.intentOp.expires));
-                const sig = await config.eoaAccount.signTypedData(typedData);
-                originSignatures.push(sig);
-            }
-            const result = {
-                chainId: config.chain.id,
-                originSignatures,
-                destinationSignature: originSignatures[0] ?? '0x',
-                success: true,
-            };
-            results.push(result);
-            successfulSignatures++;
-            // Call progress callback if provided
-            onProgress?.(i + 1, configs.length, result);
-        }
-        catch (error) {
-            const result = {
-                chainId: config.chain.id,
-                originSignatures: [],
-                destinationSignature: '0x',
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-            results.push(result);
-            failedSignatures++;
-            // Call progress callback if provided
-            onProgress?.(i + 1, configs.length, result);
-        }
-    }
-    return {
-        results,
-        totalChains: configs.length,
-        successfulSignatures,
-        failedSignatures,
-        allSuccessful: failedSignatures === 0,
-    };
-}
+export { checkERC20Allowance, checkERC20AllowanceDirect, getPermit2Address };