@charterlabs/rhinestone-sdk 0.2.7-dev.2 → 0.2.7-dev.4

package/dist/src/execution/index.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.UserOperationRequiredForSmartSessionsError = exports.SourceChainsNotAvailableForUserOpFlowError = exports.ExecutionError = exports.IntentFailedError = exports.isExecutionError = void 0;
+exports.SignerNotSupportedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.IntentFailedError = exports.ExecutionError = exports.isExecutionError = void 0;
 exports.sendTransaction = sendTransaction;
+exports.sendTransactionInternal = sendTransactionInternal;
+exports.sendUserOperation = sendUserOperation;
+exports.sendUserOperationInternal = sendUserOperationInternal;
 exports.waitForExecution = waitForExecution;
 exports.getMaxSpendableAmount = getMaxSpendableAmount;
 exports.getPortfolio = getPortfolio;
@@ -17,46 +20,53 @@ Object.defineProperty(exports, "IntentFailedError", { enumerable: true, get: fun
 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, "SourceChainsNotAvailableForUserOpFlowError", { enumerable: true, get: function () { return error_1.SourceChainsNotAvailableForUserOpFlowError; } });
-Object.defineProperty(exports, "UserOperationRequiredForSmartSessionsError", { enumerable: true, get: function () { return error_1.UserOperationRequiredForSmartSessionsError; } });
+Object.defineProperty(exports, "SignerNotSupportedError", { enumerable: true, get: function () { return error_1.SignerNotSupportedError; } });
 const smart_session_1 = require("./smart-session");
 const utils_2 = require("./utils");
 const POLLING_INTERVAL = 500;
 async function sendTransaction(config, transaction) {
-    if ('chain' in transaction) {
-        // Same-chain transaction
-        return await sendTransactionInternal(config, [transaction.chain], transaction.chain, transaction.calls, transaction.gasLimit, transaction.tokenRequests, transaction.signers, transaction.sponsored);
+    const sourceChains = 'chain' in transaction
+        ? [transaction.chain]
+        : transaction.sourceChains || [];
+    const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
+    const { calls, gasLimit, tokenRequests, signers, sponsored, settlementLayers, sourceAssets, feeAsset, } = transaction;
+    const isUserOpSigner = signers?.type === 'guardians' || signers?.type === 'session';
+    if (isUserOpSigner) {
+        throw new error_1.SignerNotSupportedError();
     }
-    else {
-        // Cross-chain transaction
-        return await sendTransactionInternal(config, transaction.sourceChains || [], transaction.targetChain, transaction.calls, transaction.gasLimit, transaction.tokenRequests, transaction.signers, transaction.sponsored);
+    return await sendTransactionInternal(config, sourceChains, targetChain, calls, {
+        gasLimit,
+        initialTokenRequests: tokenRequests,
+        signers,
+        sponsored,
+        settlementLayers,
+        sourceAssets,
+        feeAsset,
+    });
+}
+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 userOpSigner = transaction.signers?.type === 'session' ? transaction.signers.session : null;
+    if (userOpSigner) {
+        await (0, smart_session_1.enableSmartSession)(transaction.chain, config, userOpSigner);
     }
+    // Smart sessions require a UserOp flow
+    return await sendUserOperationInternal(config, transaction.chain, resolvedCalls, transaction.signers);
 }
-async function sendTransactionInternal(config, sourceChains, targetChain, callInputs, gasLimit, initialTokenRequests, signers, sponsored) {
+async function sendTransactionInternal(config, sourceChains, targetChain, callInputs, options) {
     const accountAddress = (0, accounts_1.getAddress)(config);
-    // Across requires passing some value to repay the solvers
-    const tokenRequests = !initialTokenRequests || initialTokenRequests.length === 0
-        ? [
-            {
-                address: viem_1.zeroAddress,
-                amount: 1n,
-            },
-        ]
-        : initialTokenRequests;
-    const asUserOp = signers?.type === 'guardians' || signers?.type === 'session';
-    if (asUserOp) {
-        const withSession = signers?.type === 'session' ? signers.session : null;
-        if (withSession) {
-            await (0, smart_session_1.enableSmartSession)(targetChain, config, withSession);
-        }
-        // Smart sessions require a UserOp flow
-        return await sendTransactionAsUserOp(config, targetChain, callInputs, signers);
+    const resolvedCalls = await (0, utils_2.resolveCallInputs)(callInputs, config, targetChain, accountAddress);
+    const tokenRequests = (0, utils_2.getTokenRequests)(sourceChains, targetChain, options.initialTokenRequests, options.settlementLayers);
+    const sendAsUserOp = options.signers?.type === 'guardians' || options.signers?.type === 'session';
+    if (sendAsUserOp) {
+        throw new error_1.SignerNotSupportedError();
     }
     else {
-        return await sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, signers, sponsored);
+        return await sendTransactionAsIntent(config, sourceChains, targetChain, resolvedCalls, options.gasLimit, tokenRequests, accountAddress, options.signers, options.sponsored, options.settlementLayers, options.sourceAssets, options.feeAsset, options.lockFunds);
     }
 }
-async function sendTransactionAsUserOp(config, chain, callInputs, signers) {
+async function sendUserOperationInternal(config, chain, callInputs, signers) {
     // Make sure the account is deployed
     await (0, accounts_1.deploy)(config, chain);
     const withSession = signers?.type === 'session' ? signers.session : null;
@@ -83,17 +93,14 @@ async function sendTransactionAsUserOp(config, chain, callInputs, signers) {
         chain: chain.id,
     };
 }
-async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, signers, sponsored) {
-    const { intentRoute } = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, sponsored ?? false);
+async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, signers, sponsored, settlementLayers, sourceAssets, feeAsset, lockFunds) {
+    const intentRoute = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, sponsored ?? false, undefined, settlementLayers, sourceAssets, feeAsset, lockFunds);
     if (!intentRoute) {
         throw new error_1.OrderPathRequiredForIntentsError();
     }
     const signature = await (0, utils_2.signIntent)(config, targetChain, intentRoute.intentOp, signers);
     const authorizations = config.eoa
-        ? await (0, utils_2.signAuthorizationsInternal)(config, {
-            type: 'intent',
-            intentRoute,
-        })
+        ? await (0, utils_2.signAuthorizationsInternal)(config, intentRoute)
         : [];
     return await (0, utils_2.submitIntentInternal)(config, sourceChains, targetChain, intentRoute.intentOp, signature, authorizations);
 }
@@ -110,17 +117,29 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
         case 'intent': {
             let intentStatus = null;
             while (intentStatus === null || !validStatuses.has(intentStatus.status)) {
-                const orchestrator = (0, utils_2.getOrchestratorByChain)(result.targetChain, config.rhinestoneApiKey, config.useDev);
+                const orchestrator = (0, utils_2.getOrchestratorByChain)(result.targetChain, config.apiKey, config.endpointUrl);
                 intentStatus = await orchestrator.getIntentOpStatus(result.id);
                 await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));
             }
             if (intentStatus.status === orchestrator_1.INTENT_STATUS_FAILED) {
                 throw new error_1.IntentFailedError();
             }
-            return intentStatus;
+            return {
+                fill: {
+                    hash: intentStatus.fillTransactionHash,
+                    chainId: result.targetChain,
+                },
+                claims: intentStatus.claims.map((claim) => ({
+                    hash: claim.claimTransactionHash,
+                    chainId: claim.chainId,
+                })),
+            };
         }
         case 'userop': {
             const targetChain = (0, registry_1.getChainById)(result.chain);
+            if (!targetChain) {
+                throw new Error(`Unsupported chain ID: ${result.chain}`);
+            }
             const publicClient = (0, viem_1.createPublicClient)({
                 chain: targetChain,
                 transport: (0, utils_1.createTransport)(targetChain, config.provider),
@@ -133,14 +152,14 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
         }
     }
 }
-async function getMaxSpendableAmount(config, chain, tokenAddress, gasUnits) {
+async function getMaxSpendableAmount(config, chain, tokenAddress, gasUnits, sponsored = false) {
     const address = (0, accounts_1.getAddress)(config);
-    const orchestrator = (0, utils_2.getOrchestratorByChain)(chain.id, config.rhinestoneApiKey, config.useDev);
-    return orchestrator.getMaxTokenAmount(address, chain.id, tokenAddress, gasUnits);
+    const orchestrator = (0, utils_2.getOrchestratorByChain)(chain.id, config.apiKey, config.endpointUrl);
+    return orchestrator.getMaxTokenAmount(address, chain.id, tokenAddress, gasUnits, sponsored);
 }
 async function getPortfolio(config, onTestnets) {
     const address = (0, accounts_1.getAddress)(config);
     const chainId = onTestnets ? chains_1.sepolia.id : chains_1.mainnet.id;
-    const orchestrator = (0, utils_2.getOrchestratorByChain)(chainId, config.rhinestoneApiKey, config.useDev);
+    const orchestrator = (0, utils_2.getOrchestratorByChain)(chainId, config.apiKey, config.endpointUrl);
     return orchestrator.getPortfolio(address);
 }

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

@@ -0,0 +1,148 @@
+import { type Address, type Chain } from 'viem';
+import type { IntentOp } from '../orchestrator/types';
+import type { RhinestoneConfig } from '../types';
+import type { BatchPermit2Result, MultiChainPermit2Config, MultiChainPermit2Result, TokenPermissions } from './types';
+declare function getTypedData(intentOp: IntentOp): {
+    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 Op: readonly [{
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly Mandate: readonly [{
+            readonly name: "target";
+            readonly type: "Target";
+        }, {
+            readonly name: "v";
+            readonly type: "uint8";
+        }, {
+            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 v: number;
+            readonly minGas: bigint;
+            readonly originOps: {
+                to: `0x${string}`;
+                value: bigint;
+                data: `0x${string}`;
+            }[];
+            readonly destOps: {
+                to: `0x${string}`;
+                value: bigint;
+                data: `0x${string}`;
+            }[];
+            readonly q: `0x${string}`;
+        };
+    };
+};
+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, };
+//# sourceMappingURL=permit2.d.ts.map

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

@@ -0,0 +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,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrD,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,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8FvC;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,CAiE7B;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,CAsD7B;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"}

package/dist/src/execution/permit2.js

@@ -0,0 +1,282 @@
+"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");
+const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
+function toToken(id) {
+    return `0x${(id & ((1n << 160n) - 1n)).toString(16).padStart(40, '0')}`;
+}
+function getTypedData(intentOp) {
+    const element = intentOp.elements[0];
+    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(intentOp.elements[0].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' },
+            ],
+            Op: [
+                { name: 'to', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'data', type: 'bytes' },
+            ],
+            Mandate: [
+                { name: 'target', type: 'Target' },
+                { name: 'v', type: 'uint8' },
+                { 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: BigInt(intentOp.nonce),
+            deadline: BigInt(intentOp.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),
+                },
+                v: mandate.v || 0,
+                minGas: BigInt(mandate.minGas || '0'),
+                originOps: mandate.preClaimOps.map((op) => ({
+                    to: op.to,
+                    value: BigInt(op.value),
+                    data: op.data,
+                })),
+                destOps: mandate.destinationOps.map((op) => ({
+                    to: op.to,
+                    value: BigInt(op.value),
+                    data: op.data,
+                })),
+                q: (0, viem_1.keccak256)(mandate.qualifier.encodedVal),
+            },
+        },
+    };
+    return typedData;
+}
+async function checkERC20AllowanceDirect(owner, spender, tokenAddress, publicClient) {
+    try {
+        const allowance = await publicClient.readContract({
+            address: tokenAddress,
+            abi: [
+                {
+                    name: 'allowance',
+                    type: 'function',
+                    stateMutability: 'view',
+                    inputs: [
+                        { name: 'owner', type: 'address' },
+                        { name: 'spender', type: 'address' },
+                    ],
+                    outputs: [{ name: '', type: 'uint256' }],
+                },
+            ],
+            functionName: 'allowance',
+            args: [owner, spender],
+        });
+        return BigInt(allowance.toString());
+    }
+    catch (error) {
+        console.error('Error checking ERC20 allowance:', error);
+        throw new Error('Failed to check ERC20 allowance');
+    }
+}
+async function checkERC20Allowance(tokenAddress, chain, config) {
+    try {
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain,
+            transport: (0, utils_1.createTransport)(chain, config.provider),
+        });
+        // Get the account owner from the config
+        const owner = config.eoa?.address;
+        if (!owner) {
+            throw new Error('No EOA address found in account config');
+        }
+        return await checkERC20AllowanceDirect(owner, PERMIT2_ADDRESS, tokenAddress, publicClient);
+    }
+    catch (error) {
+        console.error('Error checking ERC20 allowance:', error);
+        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 {
+            // Get typed data for this chain
+            const typedData = getTypedData(config.intentOp);
+            // Sign with EOA account
+            if (!config.eoaAccount.signTypedData) {
+                throw new Error('EOA account does not support typed data signing');
+            }
+            const signature = await config.eoaAccount.signTypedData(typedData);
+            const result = {
+                chainId: config.chain.id,
+                signature,
+                success: true,
+            };
+            successfulSignatures++;
+            return result;
+        }
+        catch (error) {
+            const result = {
+                chainId: config.chain.id,
+                signature: '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);
+    // Process results
+    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,
+                signature: '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 {
+            // Get typed data for this chain
+            const typedData = getTypedData(config.intentOp);
+            // Sign with EOA account
+            if (!config.eoaAccount.signTypedData) {
+                throw new Error('EOA account does not support typed data signing');
+            }
+            const signature = await config.eoaAccount.signTypedData(typedData);
+            const result = {
+                chainId: config.chain.id,
+                signature,
+                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,
+                signature: '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,
+    };
+}

package/dist/src/execution/smart-session.d.ts

@@ -1,15 +1,15 @@
 import { type Chain, type Hex } from 'viem';
 import { type ChainDigest, type EnableSessionData, type SmartSessionModeType } from '../modules/validators/smart-sessions';
-import type { RhinestoneAccountConfig, Session } from '../types';
+import type { RhinestoneConfig, Session } from '../types';
 interface SessionDetails {
     permissionEnableHash: Hex;
     mode: SmartSessionModeType;
     hashesAndChainIds: ChainDigest[];
     enableSessionData: EnableSessionData;
 }
-declare function getSessionDetails(config: RhinestoneAccountConfig, sessions: Session[], sessionIndex: number, signature?: Hex): Promise<SessionDetails>;
+declare function getSessionDetails(config: RhinestoneConfig, sessions: Session[], sessionIndex: number, signature?: Hex): Promise<SessionDetails>;
 declare function getMultichainDigest(chainDigests: ChainDigest[]): Hex;
-declare function enableSmartSession(chain: Chain, config: RhinestoneAccountConfig, session: Session): Promise<void>;
+declare function enableSmartSession(chain: Chain, config: RhinestoneConfig, session: Session): Promise<void>;
 export { enableSmartSession, getSessionDetails, getMultichainDigest };
 export type { SessionDetails };
 //# sourceMappingURL=smart-session.d.ts.map

package/dist/src/execution/smart-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../../execution/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAIV,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAmBb,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,iBAAiB,EAGtB,KAAK,oBAAoB,EAC1B,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAGV,uBAAuB,EACvB,OAAO,EACR,MAAM,UAAU,CAAA;AAGjB,UAAU,cAAc;IACtB,oBAAoB,EAAE,GAAG,CAAA;IACzB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,iBAAiB,EAAE,WAAW,EAAE,CAAA;IAChC,iBAAiB,EAAE,iBAAiB,CAAA;CACrC;AAED,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,cAAc,CAAC,CA4BzB;AAgGD,iBAAS,mBAAmB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,GAAG,CAgC7D;AAiLD,iBAAe,kBAAkB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,OAAO,iBA+BjB;AAED,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA;AACrE,YAAY,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../../execution/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAIV,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAmBb,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,iBAAiB,EAGtB,KAAK,oBAAoB,EAC1B,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAGV,gBAAgB,EAChB,OAAO,EACR,MAAM,UAAU,CAAA;AAGjB,UAAU,cAAc;IACtB,oBAAoB,EAAE,GAAG,CAAA;IACzB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,iBAAiB,EAAE,WAAW,EAAE,CAAA;IAChC,iBAAiB,EAAE,iBAAiB,CAAA;CACrC;AAED,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,cAAc,CAAC,CA4BzB;AAgGD,iBAAS,mBAAmB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,GAAG,CAgC7D;AAiLD,iBAAe,kBAAkB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,OAAO,iBA+BjB;AAED,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA;AACrE,YAAY,EAAE,cAAc,EAAE,CAAA"}

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

@@ -0,0 +1,35 @@
+import type { Account, Address, Chain, Hex } from 'viem';
+import type { IntentOp } from '../orchestrator/types';
+interface TokenPermissions {
+    token: Address;
+    amount: bigint;
+}
+/**
+ * Multi-chain permit2 signing configuration
+ */
+interface MultiChainPermit2Config {
+    chain: Chain;
+    intentOp: IntentOp;
+    eoaAccount: Account;
+}
+/**
+ * Result of a multi-chain permit2 signing operation
+ */
+interface MultiChainPermit2Result {
+    chainId: number;
+    signature: Hex;
+    success: boolean;
+    error?: Error;
+}
+/**
+ * Batch permit2 signing result
+ */
+interface BatchPermit2Result {
+    results: MultiChainPermit2Result[];
+    totalChains: number;
+    successfulSignatures: number;
+    failedSignatures: number;
+    allSuccessful: boolean;
+}
+export type { TokenPermissions, MultiChainPermit2Config, MultiChainPermit2Result, BatchPermit2Result, };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../execution/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAErD,UAAU,gBAAgB;IACxB,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,UAAU,uBAAuB;IAC/B,KAAK,EAAE,KAAK,CAAA;IACZ,QAAQ,EAAE,QAAQ,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;CACpB;AAED;;GAEG;AACH,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,GAAG,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,KAAK,CAAA;CACd;AAED;;GAEG;AACH,UAAU,kBAAkB;IAC1B,OAAO,EAAE,uBAAuB,EAAE,CAAA;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,YAAY,EACV,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,GACnB,CAAA"}

package/dist/src/execution/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });