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

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

@@ -1,143 +0,0 @@
-import { type Address, type Chain } from 'viem';
-import type { IntentOpElement } from '../orchestrator/types.js';
-import type { RhinestoneConfig } from '../types.js';
-import type { BatchPermit2Result, MultiChainPermit2Config, MultiChainPermit2Result, TokenPermissions } from './types.js';
-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.js").Op;
-            readonly destOps: import("../orchestrator/types.js").Op;
-            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

@@ -1 +0,0 @@
-{"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"}

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 {};