@rhinestone/sdk 1.0.41-alpha.0 → 1.0.41

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

@@ -0,0 +1,148 @@
+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 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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8FhB;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"}

package/dist/src/execution/permit2.js

@@ -0,0 +1,291 @@
+"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(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' },
+            ],
+            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: 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),
+                },
+                v: mandate.v,
+                minGas: BigInt(mandate.minGas),
+                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 {
+            // 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,
+    };
+}

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

@@ -0,0 +1,28 @@
+import type { Address } from 'viem';
+import type { Execution, IntentOpElement } from '../orchestrator/types';
+declare function getTypedData(account: Address, intentExecutorAddress: Address, element: IntentOpElement, nonce: bigint): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        SingleChainOps: {
+            name: string;
+            type: string;
+        }[];
+        Op: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: "SingleChainOps";
+    message: {
+        account: `0x${string}`;
+        nonce: bigint;
+        ops: Execution[];
+    };
+};
+export { getTypedData };
+//# sourceMappingURL=singleChainOps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"singleChainOps.d.ts","sourceRoot":"","sources":["../../../execution/singleChainOps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvE,iBAAS,YAAY,CACnB,OAAO,EAAE,OAAO,EAChB,qBAAqB,EAAE,OAAO,EAC9B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;EA8Bd;AACD,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/src/execution/singleChainOps.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypedData = getTypedData;
+function getTypedData(account, intentExecutorAddress, element, nonce) {
+    const ops = element.mandate.destinationOps;
+    return {
+        domain: {
+            name: 'IntentExecutor',
+            version: 'v0.0.1',
+            chainId: Number(element.mandate.destinationChainId),
+            verifyingContract: intentExecutorAddress,
+        },
+        types: {
+            SingleChainOps: [
+                { name: 'account', type: 'address' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'ops', type: 'Op[]' },
+            ],
+            Op: [
+                { name: 'to', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'data', type: 'bytes' },
+            ],
+        },
+        primaryType: 'SingleChainOps',
+        message: {
+            account,
+            nonce,
+            ops,
+        },
+    };
+}

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

@@ -0,0 +1,13 @@
+import { type Chain, type Hex } from 'viem';
+import { type EnableSessionData } from '../modules/validators/smart-sessions';
+import type { RhinestoneConfig, Session } from '../types';
+interface SessionDetails {
+    signature: Hex;
+    nonces: bigint[];
+    enableSessionData: EnableSessionData;
+}
+declare function getSessionDetails(config: RhinestoneConfig, sessions: Session[], sessionIndex: number, initialNonces?: bigint[], signature?: Hex): Promise<SessionDetails>;
+declare function enableSmartSession(chain: Chain, config: RhinestoneConfig, session: Session): Promise<void>;
+export { enableSmartSession, getSessionDetails };
+export type { SessionDetails };
+//# sourceMappingURL=smart-session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../../execution/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAEV,KAAK,GAAG,EAIT,MAAM,MAAM,CAAA;AAiBb,OAAO,EACL,KAAK,iBAAiB,EAKvB,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGzD,UAAU,cAAc;IACtB,SAAS,EAAE,GAAG,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,iBAAiB,EAAE,iBAAiB,CAAA;CACrC;AA6CD,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,EAAE,EACxB,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,cAAc,CAAC,CAiHzB;AA+BD,iBAAe,kBAAkB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,OAAO,iBA2BjB;AAED,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,CAAA;AAChD,YAAY,EAAE,cAAc,EAAE,CAAA"}