@rhinestone/sdk 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/src/execution/permit2.js

@@ -1,280 +0,0 @@
-import { createPublicClient, keccak256, } 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: 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 = createPublicClient({
-            chain,
-            transport: 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,
-    };
-}
-export { getTypedData, checkERC20Allowance, checkERC20AllowanceDirect, getPermit2Address, 
-// Multi-chain permit2 signing methods
-signPermit2Batch, signPermit2Sequential, };

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

@@ -1,41 +0,0 @@
-import type { Address } from 'viem';
-import type { IntentOpElement } from '../orchestrator/types.js';
-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;
-        }[];
-        GasRefund: {
-            name: string;
-            type: string;
-        }[];
-        Ops: {
-            name: string;
-            type: string;
-        }[];
-    };
-    primaryType: "SingleChainOps";
-    message: {
-        account: `0x${string}`;
-        nonce: bigint;
-        op: import("../orchestrator/types.js").Op;
-        gasRefund: {
-            token: Address;
-            exchangeRate: bigint;
-            overhead: bigint;
-        } | undefined;
-    };
-};
-export { getTypedData };
-//# sourceMappingURL=singleChainOps.d.ts.map

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

@@ -1 +0,0 @@
-{"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,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,iBAAS,YAAY,CACnB,OAAO,EAAE,OAAO,EAChB,qBAAqB,EAAE,OAAO,EAC9B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Cd;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/src/execution/singleChainOps.js

@@ -1,42 +0,0 @@
-function getTypedData(account, intentExecutorAddress, element, nonce) {
-    const { destinationChainId, destinationOps } = element.mandate;
-    const gasRefund = element.mandate.qualifier.settlementContext.gasRefund;
-    return {
-        domain: {
-            name: 'IntentExecutor',
-            version: 'v0.0.1',
-            chainId: Number(destinationChainId),
-            verifyingContract: intentExecutorAddress,
-        },
-        types: {
-            SingleChainOps: [
-                { name: 'account', type: 'address' },
-                { name: 'nonce', type: 'uint256' },
-                { name: 'op', type: 'Op' },
-                { name: 'gasRefund', type: 'GasRefund' },
-            ],
-            Op: [
-                { name: 'vt', type: 'bytes32' },
-                { name: 'ops', type: 'Ops[]' },
-            ],
-            GasRefund: [
-                { name: 'token', type: 'address' },
-                { name: 'exchangeRate', type: 'uint256' },
-                { name: 'overhead', type: 'uint256' },
-            ],
-            Ops: [
-                { name: 'to', type: 'address' },
-                { name: 'value', type: 'uint256' },
-                { name: 'data', type: 'bytes' },
-            ],
-        },
-        primaryType: 'SingleChainOps',
-        message: {
-            account,
-            nonce,
-            op: destinationOps,
-            gasRefund,
-        },
-    };
-}
-export { getTypedData };

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

@@ -1,36 +0,0 @@
-import type { Account, Address, Chain, Hex } from 'viem';
-import type { IntentOp } from '../orchestrator/types.js';
-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;
-    originSignatures: Hex[];
-    destinationSignature: 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

@@ -1 +0,0 @@
-{"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,gBAAgB,EAAE,GAAG,EAAE,CAAA;IACvB,oBAAoB,EAAE,GAAG,CAAA;IACzB,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

@@ -1 +0,0 @@
-export {};