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

package/dist/src/actions/compact.js

@@ -1,200 +0,0 @@
-import { concat, encodeFunctionData, erc20Abi, zeroAddress, } from 'viem';
-import { COMPACT_ADDRESS } from '../execution/compact.js';
-const ALLOCATOR_ADDRESS = '0xc7732071e3a1be6cfce6d13bb05699a31a457679';
-const DEFAULT_RESET_PERIOD = 6;
-const DEFAULT_SCOPE = 0;
-function depositEther(value) {
-    return {
-        async resolve({ accountAddress }) {
-            return {
-                to: COMPACT_ADDRESS,
-                data: encodeFunctionData({
-                    abi: [
-                        {
-                            type: 'function',
-                            name: 'depositNative',
-                            inputs: [
-                                { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
-                                { name: 'recipient', type: 'address', internalType: 'address' },
-                            ],
-                            outputs: [
-                                { name: 'id', type: 'uint256', internalType: 'uint256' },
-                            ],
-                            stateMutability: 'payable',
-                        },
-                    ],
-                    functionName: 'depositNative',
-                    args: [lockTag(), accountAddress],
-                }),
-                value,
-            };
-        },
-    };
-}
-function enableEtherWithdrawal() {
-    const id = concat([lockTag(), zeroAddress]);
-    return enableForcedWithdrawal(BigInt(id));
-}
-function disableEtherWithdrawal() {
-    const id = concat([lockTag(), zeroAddress]);
-    return disableForcedWithdrawal(BigInt(id));
-}
-function withdrawEther(value) {
-    return {
-        async resolve({ accountAddress }) {
-            const id = concat([lockTag(), zeroAddress]);
-            return forcedWithdrawal(BigInt(id), accountAddress, value);
-        },
-    };
-}
-function depositErc20(tokenAddress, amount) {
-    return {
-        async resolve({ accountAddress }) {
-            return {
-                to: COMPACT_ADDRESS,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: [
-                        {
-                            type: 'function',
-                            name: 'depositERC20',
-                            inputs: [
-                                { name: 'token', type: 'address', internalType: 'address' },
-                                { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
-                                { name: 'amount', type: 'uint256', internalType: 'uint256' },
-                                { name: 'recipient', type: 'address', internalType: 'address' },
-                            ],
-                            outputs: [
-                                { name: 'id', type: 'uint256', internalType: 'uint256' },
-                            ],
-                            stateMutability: 'nonpayable',
-                        },
-                    ],
-                    functionName: 'depositERC20',
-                    args: [tokenAddress, lockTag(), amount, accountAddress],
-                }),
-            };
-        },
-    };
-}
-function enableErc20Withdrawal(tokenAddress) {
-    const id = concat([lockTag(), tokenAddress]);
-    return enableForcedWithdrawal(BigInt(id));
-}
-function disableErc20Withdrawal(tokenAddress) {
-    const id = concat([lockTag(), tokenAddress]);
-    return disableForcedWithdrawal(BigInt(id));
-}
-function withdrawErc20(tokenAddress, amount) {
-    return {
-        async resolve({ accountAddress }) {
-            const id = concat([lockTag(), tokenAddress]);
-            return forcedWithdrawal(BigInt(id), accountAddress, amount);
-        },
-    };
-}
-function enableForcedWithdrawal(id) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: encodeFunctionData({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'enableForcedWithdrawal',
-                    inputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
-                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'enableForcedWithdrawal',
-            args: [id],
-        }),
-        value: 0n,
-    };
-}
-function disableForcedWithdrawal(id) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: encodeFunctionData({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'disableForcedWithdrawal',
-                    inputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
-                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'disableForcedWithdrawal',
-            args: [id],
-        }),
-        value: 0n,
-    };
-}
-function forcedWithdrawal(id, recipient, amount) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: encodeFunctionData({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'forcedWithdrawal',
-                    inputs: [
-                        { name: 'id', type: 'uint256', internalType: 'uint256' },
-                        { name: 'recipient', type: 'address', internalType: 'address' },
-                        { name: 'amount', type: 'uint256', internalType: 'uint256' },
-                    ],
-                    outputs: [{ name: '', type: 'bool', internalType: 'bool' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'forcedWithdrawal',
-            args: [id, recipient, amount],
-        }),
-        value: 0n,
-    };
-}
-function approveErc20(tokenAddress, amount) {
-    return {
-        to: tokenAddress,
-        value: 0n,
-        data: encodeFunctionData({
-            abi: erc20Abi,
-            functionName: 'approve',
-            args: [COMPACT_ADDRESS, amount],
-        }),
-    };
-}
-function toCompactFlag(allocator) {
-    const addrBytes = Buffer.from(allocator.slice(2), 'hex');
-    let leadingZeroNibbles = 0;
-    for (const byte of addrBytes) {
-        if (byte === 0) {
-            leadingZeroNibbles += 2;
-        }
-        else {
-            if (byte >> 4 === 0)
-                leadingZeroNibbles += 1;
-            break;
-        }
-    }
-    if (leadingZeroNibbles >= 18)
-        return 15;
-    if (leadingZeroNibbles >= 4)
-        return leadingZeroNibbles - 3;
-    return 0;
-}
-function usingAllocatorId(allocator = ALLOCATOR_ADDRESS) {
-    const compactFlag = BigInt(toCompactFlag(allocator));
-    const last88Bits = BigInt(`0x${allocator.slice(-22)}`); // Extract last 88 bits (11 bytes * 2 hex chars per byte)
-    return (compactFlag << 88n) | last88Bits;
-}
-function lockTag() {
-    const allocatorId = usingAllocatorId(ALLOCATOR_ADDRESS);
-    const tagBig = (BigInt(DEFAULT_SCOPE) << 255n) |
-        (BigInt(DEFAULT_RESET_PERIOD) << 252n) |
-        (allocatorId << 160n);
-    const hex = tagBig.toString(16).slice(0, 24);
-    return `0x${hex}`;
-}
-export { ALLOCATOR_ADDRESS, depositEther, enableEtherWithdrawal, disableEtherWithdrawal, withdrawEther, depositErc20, enableErc20Withdrawal, disableErc20Withdrawal, withdrawErc20, approveErc20, lockTag, };

package/dist/src/actions/deployment.d.ts

@@ -1,19 +0,0 @@
-import type { Address, Chain } from 'viem';
-import type { AccountProviderConfig, RhinestoneSDKConfig } from '../types.js';
-/**
- * Deploy smart accounts for multiple users from a backend using a sponsor wallet.
- * The sponsor pays for gas, but users own and control their accounts.
- */
-declare function deployAccountsForOwners(params: {
-    sponsorAccount: import('viem').Account;
-    ownerAddresses: Address[];
-    accountConfig: AccountProviderConfig;
-    chain: Chain;
-    sdkConfig?: RhinestoneSDKConfig;
-    sponsored?: boolean;
-}): Promise<Array<{
-    owner: Address;
-    account: Address;
-}>>;
-export { deployAccountsForOwners };
-//# sourceMappingURL=deployment.d.ts.map

package/dist/src/actions/deployment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../../actions/deployment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAO,MAAM,MAAM,CAAA;AAQ/C,OAAO,KAAK,EACV,qBAAqB,EAErB,mBAAmB,EACpB,MAAM,UAAU,CAAA;AAyCjB;;;GAGG;AACH,iBAAe,uBAAuB,CAAC,MAAM,EAAE;IAC7C,cAAc,EAAE,OAAO,MAAM,EAAE,OAAO,CAAA;IACtC,cAAc,EAAE,OAAO,EAAE,CAAA;IACzB,aAAa,EAAE,qBAAqB,CAAA;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,SAAS,CAAC,EAAE,mBAAmB,CAAA;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,GAAG,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,CAmDvD;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/src/actions/deployment.js

@@ -1,76 +0,0 @@
-import { createPublicClient, createWalletClient } from 'viem';
-import { getAddress as getAddressInternal, getInitCode as getInitCodeInternal, isDeployed as isDeployedInternal, } from '../accounts/index.js';
-import { createTransport } from '../accounts/utils.js';
-async function deployWithCustomFactory(sponsorConfig, chain, factoryArgs) {
-    const sponsorOwners = sponsorConfig.owners;
-    if (!sponsorOwners ||
-        sponsorOwners.type !== 'ecdsa' ||
-        sponsorOwners.accounts.length === 0) {
-        throw new Error('Sponsor must have an ECDSA account');
-    }
-    const sponsorAccount = sponsorOwners.accounts[0];
-    if (!('signTransaction' in sponsorAccount)) {
-        throw new Error('Sponsor account must be able to sign transactions');
-    }
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, sponsorConfig.provider),
-    });
-    const walletClient = createWalletClient({
-        account: sponsorAccount,
-        chain,
-        transport: createTransport(chain, sponsorConfig.provider),
-    });
-    const hash = await walletClient.sendTransaction({
-        to: factoryArgs.factory,
-        data: factoryArgs.factoryData,
-        value: 0n,
-    });
-    await publicClient.waitForTransactionReceipt({ hash });
-}
-/**
- * Deploy smart accounts for multiple users from a backend using a sponsor wallet.
- * The sponsor pays for gas, but users own and control their accounts.
- */
-async function deployAccountsForOwners(params) {
-    const { sponsorAccount, ownerAddresses, accountConfig, chain, sdkConfig } = params;
-    const results = [];
-    for (const ownerAddress of ownerAddresses) {
-        const ownerAccountRef = {
-            address: ownerAddress,
-            type: 'json-rpc',
-        };
-        const userConfig = {
-            account: accountConfig,
-            owners: {
-                type: 'ecdsa',
-                accounts: [ownerAccountRef],
-                threshold: 1,
-            },
-            ...sdkConfig,
-        };
-        const accountAddress = getAddressInternal(userConfig);
-        const isAlreadyDeployed = await isDeployedInternal(userConfig, chain);
-        if (isAlreadyDeployed) {
-            results.push({ owner: ownerAddress, account: accountAddress });
-            continue;
-        }
-        const sponsorConfig = {
-            account: accountConfig,
-            owners: {
-                type: 'ecdsa',
-                accounts: [sponsorAccount],
-                threshold: 1,
-            },
-            ...sdkConfig,
-        };
-        const initCode = getInitCodeInternal(userConfig);
-        if (!initCode || !('factory' in initCode)) {
-            throw new Error('Failed to get init code for account deployment');
-        }
-        await deployWithCustomFactory(sponsorConfig, chain, initCode);
-        results.push({ owner: ownerAddress, account: accountAddress });
-    }
-    return results;
-}
-export { deployAccountsForOwners };

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"}