@rhinestone/sdk 1.0.40 → 1.0.41-alpha.0

package/dist/src/execution/utils.js

@@ -1,705 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareTransaction = prepareTransaction;
-exports.getTransactionMessages = getTransactionMessages;
-exports.signTransaction = signTransaction;
-exports.signAuthorizations = signAuthorizations;
-exports.signAuthorizationsInternal = signAuthorizationsInternal;
-exports.signMessage = signMessage;
-exports.signTypedData = signTypedData;
-exports.submitTransaction = submitTransaction;
-exports.prepareUserOperation = prepareUserOperation;
-exports.signUserOperation = signUserOperation;
-exports.submitUserOperation = submitUserOperation;
-exports.getOrchestratorByChain = getOrchestratorByChain;
-exports.signIntent = signIntent;
-exports.prepareTransactionAsIntent = prepareTransactionAsIntent;
-exports.submitIntentInternal = submitIntentInternal;
-exports.getValidatorAccount = getValidatorAccount;
-exports.parseCalls = parseCalls;
-exports.getTokenRequests = getTokenRequests;
-exports.resolveCallInputs = resolveCallInputs;
-exports.getIntentAccount = getIntentAccount;
-const viem_1 = require("viem");
-const account_abstraction_1 = require("viem/account-abstraction");
-const erc7739_1 = require("viem/experimental/erc7739");
-const accounts_1 = require("../accounts");
-const utils_1 = require("../accounts/utils");
-const modules_1 = require("../modules");
-const validators_1 = require("../modules/validators");
-const core_1 = require("../modules/validators/core");
-const orchestrator_1 = require("../orchestrator");
-const consts_1 = require("../orchestrator/consts");
-const registry_1 = require("../orchestrator/registry");
-const compact_1 = require("./compact");
-const error_1 = require("./error");
-const permit2_1 = require("./permit2");
-const singleChainOps_1 = require("./singleChainOps");
-async function prepareTransaction(config, transaction) {
-    const { sourceChains, targetChain, tokenRequests, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, account, recipient, } = getTransactionParams(transaction);
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const isUserOpSigner = signers?.type === 'guardians' || signers?.type === 'session';
-    if (isUserOpSigner) {
-        throw new error_1.SignerNotSupportedError();
-    }
-    const intentRoute = await prepareTransactionAsIntent(config, sourceChains, targetChain, await resolveCallInputs(transaction.calls, config, targetChain, accountAddress), transaction.gasLimit, tokenRequests, recipient, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, account);
-    return {
-        intentRoute,
-        transaction,
-    };
-}
-async function prepareUserOperation(config, transaction) {
-    const chain = transaction.chain;
-    const signers = transaction.signers;
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const data = await prepareTransactionAsUserOp(config, chain, await resolveCallInputs(transaction.calls, config, chain, accountAddress), signers, transaction.gasLimit);
-    return {
-        userOperation: data.userOp,
-        hash: data.hash,
-        transaction,
-    };
-}
-async function resolveCallInputs(inputs, config, chain, accountAddress) {
-    const resolved = [];
-    if (!inputs) {
-        return resolved;
-    }
-    for (const intent of inputs) {
-        if ('resolve' in intent) {
-            const result = await intent.resolve({ config, chain, accountAddress });
-            if (Array.isArray(result)) {
-                resolved.push(...result);
-            }
-            else if (result) {
-                resolved.push(result);
-            }
-        }
-        else {
-            resolved.push(intent);
-        }
-    }
-    return resolved;
-}
-function getTransactionMessages(config, preparedTransaction) {
-    return getIntentMessages(config, preparedTransaction.intentRoute.intentOp);
-}
-async function signTransaction(config, preparedTransaction) {
-    const { signers } = getTransactionParams(preparedTransaction.transaction);
-    const intentRoute = preparedTransaction.intentRoute;
-    const { originSignatures, destinationSignature } = await signIntent(config, intentRoute.intentOp, signers);
-    return {
-        intentRoute,
-        transaction: preparedTransaction.transaction,
-        originSignatures,
-        destinationSignature,
-    };
-}
-async function signUserOperation(config, preparedUserOperation) {
-    const chain = preparedUserOperation.transaction.chain;
-    const userOp = preparedUserOperation.userOperation;
-    const signers = preparedUserOperation.transaction.signers;
-    // Smart sessions require a UserOp flow
-    const signature = await signUserOp(config, chain, signers, userOp);
-    return {
-        userOperation: preparedUserOperation.userOperation,
-        hash: preparedUserOperation.hash,
-        transaction: preparedUserOperation.transaction,
-        signature,
-    };
-}
-async function signAuthorizations(config, preparedTransaction) {
-    return await signAuthorizationsInternal(config, preparedTransaction.intentRoute);
-}
-async function signMessage(config, message, chain, signers) {
-    const validator = getValidator(config, signers);
-    if (!validator) {
-        throw new Error('Validator not available');
-    }
-    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
-    const isRoot = validator.address === ownerValidator.address;
-    const hash = (0, viem_1.hashMessage)(message);
-    const signature = await (0, accounts_1.getPackedSignature)(config, signers, chain, {
-        address: validator.address,
-        isRoot,
-    }, hash);
-    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
-}
-async function signTypedData(config, parameters, chain, signers) {
-    const validator = getValidator(config, signers);
-    if (!validator) {
-        throw new Error('Validator not available');
-    }
-    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
-    const isRoot = validator.address === ownerValidator.address;
-    if (signers?.type === 'session') {
-        return await signTypedDataWithSession(config, chain, {
-            address: validator.address,
-            isRoot,
-        }, signers, parameters);
-    }
-    const signature = await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, {
-        address: validator.address,
-        isRoot,
-    }, parameters);
-    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
-}
-async function signTypedDataWithSession(config, chain, validator, signers, parameters) {
-    const { name, version, chainId, verifyingContract, salt } = (0, accounts_1.getEip712Domain)(config, chain);
-    const signature = await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, validator, {
-        domain: parameters.domain,
-        primaryType: 'TypedDataSign',
-        types: {
-            ...parameters.types,
-            TypedDataSign: [
-                { name: 'contents', type: parameters.primaryType },
-                { name: 'name', type: 'string' },
-                { name: 'version', type: 'string' },
-                { name: 'chainId', type: 'uint256' },
-                { name: 'verifyingContract', type: 'address' },
-                { name: 'salt', type: 'bytes32' },
-            ],
-        },
-        message: {
-            contents: parameters.message,
-            name,
-            version,
-            chainId,
-            verifyingContract,
-            salt,
-        },
-    }, (signature) => {
-        const erc7739Signature = (0, erc7739_1.wrapTypedDataSignature)({
-            domain: parameters.domain,
-            primaryType: parameters.primaryType,
-            types: parameters.types,
-            message: parameters.message,
-            signature,
-        });
-        return (0, viem_1.encodePacked)(['bytes32', 'bytes'], [(0, validators_1.getPermissionId)(signers.session), erc7739Signature]);
-    });
-    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
-}
-async function signAuthorizationsInternal(config, data) {
-    const eoa = config.eoa;
-    if (!eoa) {
-        throw new Error('EIP-7702 initialization is required for EOA accounts');
-    }
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const requiredDelegations = 'intentOp' in data
-        ? data.intentOp.signedMetadata.account.requiredDelegations || {}
-        : {};
-    const authorizations = [];
-    for (const chainId in requiredDelegations) {
-        const delegation = requiredDelegations[chainId];
-        const chain = (0, registry_1.getChainById)(Number(chainId));
-        const walletClient = (0, viem_1.createWalletClient)({
-            chain,
-            account: eoa,
-            transport: (0, utils_1.createTransport)(chain, config.provider),
-        }).extend(viem_1.publicActions);
-        const code = await walletClient.getCode({
-            address: accountAddress,
-        });
-        const isDelegated = code === (0, viem_1.concat)(['0xef0100', delegation.contract.toLowerCase()]);
-        if (isDelegated) {
-            continue;
-        }
-        const authorization = await walletClient.signAuthorization({
-            contractAddress: delegation.contract,
-            chainId: Number(chainId),
-        });
-        authorizations.push(authorization);
-    }
-    return authorizations;
-}
-async function submitTransaction(config, signedTransaction, authorizations, dryRun = false) {
-    const { intentRoute, transaction, originSignatures, destinationSignature } = signedTransaction;
-    const { sourceChains, targetChain } = getTransactionParams(transaction);
-    const intentOp = intentRoute.intentOp;
-    return await submitIntent(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, authorizations, dryRun);
-}
-async function submitUserOperation(config, signedUserOperation) {
-    const chain = signedUserOperation.transaction.chain;
-    const userOp = signedUserOperation.userOperation;
-    const signature = signedUserOperation.signature;
-    // Smart sessions require a UserOp flow
-    return await submitUserOp(config, chain, userOp, signature);
-}
-function getTransactionParams(transaction) {
-    const sourceChains = 'chain' in transaction ? [transaction.chain] : transaction.sourceChains;
-    const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
-    const initialTokenRequests = transaction.tokenRequests;
-    const signers = transaction.signers;
-    const eip7702InitSignature = transaction.eip7702InitSignature;
-    const sponsored = transaction.sponsored;
-    const gasLimit = transaction.gasLimit;
-    const settlementLayers = transaction.settlementLayers;
-    const sourceAssets = transaction.sourceAssets;
-    const feeAsset = transaction.feeAsset;
-    const lockFunds = transaction.lockFunds;
-    const account = transaction.experimental_accountOverride;
-    const recipient = transaction.recipient;
-    const tokenRequests = getTokenRequests(sourceChains || [], targetChain, initialTokenRequests, settlementLayers);
-    return {
-        sourceChains,
-        targetChain,
-        tokenRequests,
-        signers,
-        sponsored,
-        eip7702InitSignature,
-        gasLimit,
-        settlementLayers,
-        sourceAssets,
-        feeAsset,
-        lockFunds,
-        account,
-        recipient,
-    };
-}
-function getTokenRequests(sourceChains, targetChain, initialTokenRequests, settlementLayers) {
-    if (initialTokenRequests) {
-        validateTokenSymbols(targetChain, initialTokenRequests.map((tokenRequest) => tokenRequest.address));
-    }
-    // Across requires passing some value to repay the solvers
-    const defaultTokenRequest = {
-        address: viem_1.zeroAddress,
-        amount: 1n,
-    };
-    const isSameChain = (settlementLayers?.length === 1 && settlementLayers[0] === 'SAME_CHAIN') ||
-        (sourceChains &&
-            sourceChains.length === 1 &&
-            sourceChains[0].id === targetChain.id);
-    const tokenRequests = !initialTokenRequests || initialTokenRequests.length === 0
-        ? isSameChain
-            ? []
-            : [defaultTokenRequest]
-        : initialTokenRequests;
-    return tokenRequests;
-}
-async function prepareTransactionAsUserOp(config, chain, callInputs, signers, gasLimit) {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
-    });
-    const validatorAccount = await getValidatorAccount(config, signers, publicClient, chain);
-    if (!validatorAccount) {
-        throw new Error('No validator account found');
-    }
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    const calls = parseCalls(callInputs, chain.id);
-    const userOp = await bundlerClient.prepareUserOperation({
-        account: validatorAccount,
-        calls,
-        callGasLimit: gasLimit,
-    });
-    return {
-        userOp,
-        hash: (0, account_abstraction_1.getUserOperationHash)({
-            userOperation: userOp,
-            chainId: chain.id,
-            entryPointAddress: account_abstraction_1.entryPoint07Address,
-            entryPointVersion: '0.7',
-        }),
-    };
-}
-function getAccountType(accountConfig) {
-    if (accountConfig?.type === 'eoa') {
-        return 'EOA';
-    }
-    else {
-        return 'ERC7579';
-    }
-}
-function getIntentAccount(config, eip7702InitSignature, account) {
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const accountType = getAccountType(config.account);
-    const { setupOps, delegations } = getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSignature);
-    return {
-        address: accountAddress,
-        accountType: accountType,
-        setupOps: account?.setupOps ?? setupOps,
-        delegations,
-    };
-}
-async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipientInput, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, account) {
-    if (config.account?.type === 'eoa') {
-        if (callInputs.length > 0) {
-            throw new error_1.CallsNotSupportedError();
-        }
-    }
-    const calls = parseCalls(callInputs, targetChain.id);
-    const accountAccessList = createAccountAccessList(sourceChains, sourceAssets);
-    function getRecipient(recipient) {
-        if (typeof recipient === 'string') {
-            // Passed as an address, assume it's an EOA
-            return {
-                address: recipient,
-                accountType: 'EOA',
-                setupOps: [],
-                delegations: undefined,
-            };
-        }
-        if (!recipient) {
-            return undefined;
-        }
-        return getIntentAccount(recipient, eip7702InitSignature, account);
-    }
-    const intentAccount = getIntentAccount(config, eip7702InitSignature, account);
-    const recipient = getRecipient(recipientInput);
-    const metaIntent = {
-        destinationChainId: targetChain.id,
-        tokenRequests: tokenRequests.map((tokenRequest) => ({
-            tokenAddress: (0, registry_1.resolveTokenAddress)(tokenRequest.address, targetChain.id),
-            amount: tokenRequest.amount,
-        })),
-        recipient,
-        account: intentAccount,
-        destinationExecutions: calls.map((call) => ({
-            to: call.to,
-            value: call.value.toString(),
-            data: call.data,
-        })),
-        destinationGasUnits: gasLimit,
-        accountAccessList,
-        options: {
-            topupCompact: lockFunds ?? false,
-            feeToken: feeAsset,
-            sponsorSettings: sponsored
-                ? typeof sponsored === 'object'
-                    ? {
-                        gasSponsored: sponsored.gas,
-                        bridgeFeesSponsored: sponsored.bridging,
-                        swapFeesSponsored: sponsored.swaps,
-                    }
-                    : {
-                        gasSponsored: sponsored,
-                        bridgeFeesSponsored: sponsored,
-                        swapFeesSponsored: sponsored,
-                    }
-                : undefined,
-            settlementLayers,
-        },
-    };
-    const orchestrator = getOrchestratorByChain(targetChain.id, config.apiKey, config.endpointUrl);
-    const intentRoute = await orchestrator.getIntentRoute(metaIntent);
-    return intentRoute;
-}
-async function signIntent(config, intentOp, signers) {
-    const { origin } = getIntentMessages(config, intentOp);
-    if (config.account?.type === 'eoa') {
-        const eoa = config.eoa;
-        if (!eoa) {
-            throw new accounts_1.EoaAccountMustHaveAccountError();
-        }
-        const originSignatures = [];
-        for (const typedData of origin) {
-            if (eoa.signTypedData) {
-                const signature = await eoa.signTypedData(typedData);
-                originSignatures.push(signature);
-            }
-            else {
-                throw new accounts_1.EoaSigningMethodNotConfiguredError('signTypedData');
-            }
-        }
-        const destinationSignature = originSignatures.at(-1);
-        return {
-            originSignatures,
-            destinationSignature,
-        };
-    }
-    const validator = getValidator(config, signers);
-    if (!validator) {
-        throw new Error('Validator not available');
-    }
-    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
-    const isRoot = validator.address === ownerValidator.address;
-    const originSignatures = [];
-    for (const typedData of origin) {
-        const chain = (0, registry_1.getChainById)(typedData.domain?.chainId);
-        const signature = await signIntentTypedData(config, signers, validator, isRoot, typedData, chain);
-        originSignatures.push(signature);
-    }
-    const destinationSignature = originSignatures.at(-1);
-    return {
-        originSignatures,
-        destinationSignature,
-    };
-}
-function getIntentMessages(config, intentOp) {
-    const address = (0, accounts_1.getAddress)(config);
-    const intentExecutor = (0, modules_1.getIntentExecutor)(config);
-    const withPermit2 = intentOp.elements.some((element) => element.mandate.qualifier.settlementContext.fundingMethod === 'PERMIT2');
-    const withIntentExecutorOps = intentOp.elements.some((element) => element.mandate.qualifier.settlementContext.settlementLayer ===
-        'INTENT_EXECUTOR');
-    const origin = [];
-    for (const element of intentOp.elements) {
-        if (withIntentExecutorOps) {
-            const typedData = (0, singleChainOps_1.getTypedData)(address, intentExecutor.address, element, BigInt(intentOp.nonce));
-            origin.push(typedData);
-        }
-        else if (withPermit2) {
-            const typedData = (0, permit2_1.getTypedData)(element, BigInt(intentOp.nonce), BigInt(intentOp.expires));
-            origin.push(typedData);
-        }
-        else {
-            const typedData = (0, compact_1.getCompactTypedData)(intentOp);
-            origin.push(typedData);
-        }
-    }
-    const destination = origin.at(-1);
-    return {
-        origin,
-        destination,
-    };
-}
-async function signIntentTypedData(config, signers, validator, isRoot, parameters, chain) {
-    if ((0, core_1.supportsEip712)(validator)) {
-        return await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, {
-            address: validator.address,
-            isRoot,
-        }, parameters);
-    }
-    const hash = (0, viem_1.hashTypedData)(parameters);
-    return await (0, accounts_1.getPackedSignature)(config, signers, chain, {
-        address: validator.address,
-        isRoot,
-    }, hash);
-}
-async function signUserOp(config, chain, signers, userOp) {
-    const validator = getValidator(config, signers);
-    if (!validator) {
-        throw new Error('Validator not available');
-    }
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
-    });
-    const account = await getValidatorAccount(config, signers, publicClient, chain);
-    if (!account) {
-        throw new Error('No account found');
-    }
-    return await account.signUserOperation(userOp);
-}
-async function submitUserOp(config, chain, userOp, signature) {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
-    });
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    const hash = await bundlerClient.request({
-        method: 'eth_sendUserOperation',
-        params: [
-            {
-                sender: userOp.sender,
-                nonce: (0, viem_1.toHex)(userOp.nonce),
-                factory: userOp.factory,
-                factoryData: userOp.factoryData,
-                callData: userOp.callData,
-                callGasLimit: (0, viem_1.toHex)(userOp.callGasLimit),
-                verificationGasLimit: (0, viem_1.toHex)(userOp.verificationGasLimit),
-                preVerificationGas: (0, viem_1.toHex)(userOp.preVerificationGas),
-                maxPriorityFeePerGas: (0, viem_1.toHex)(userOp.maxPriorityFeePerGas),
-                maxFeePerGas: (0, viem_1.toHex)(userOp.maxFeePerGas),
-                paymaster: userOp.paymaster,
-                paymasterVerificationGasLimit: userOp.paymasterVerificationGasLimit
-                    ? (0, viem_1.toHex)(userOp.paymasterVerificationGasLimit)
-                    : undefined,
-                paymasterPostOpGasLimit: userOp.paymasterPostOpGasLimit
-                    ? (0, viem_1.toHex)(userOp.paymasterPostOpGasLimit)
-                    : undefined,
-                paymasterData: userOp.paymasterData,
-                signature,
-            },
-            account_abstraction_1.entryPoint07Address,
-        ],
-    });
-    return {
-        type: 'userop',
-        hash,
-        chain: chain.id,
-    };
-}
-async function submitIntent(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, authorizations, dryRun) {
-    return submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, authorizations, dryRun);
-}
-function getOrchestratorByChain(chainId, apiKey, orchestratorUrl) {
-    if (orchestratorUrl) {
-        return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
-    }
-    const defaultOrchestratorUrl = (0, registry_1.isTestnet)(chainId)
-        ? consts_1.STAGING_ORCHESTRATOR_URL
-        : consts_1.PROD_ORCHESTRATOR_URL;
-    return (0, orchestrator_1.getOrchestrator)(apiKey, defaultOrchestratorUrl);
-}
-function createSignedIntentOp(intentOp, originSignatures, destinationSignature, authorizations) {
-    return {
-        ...intentOp,
-        originSignatures,
-        destinationSignature,
-        signedAuthorizations: authorizations.length > 0
-            ? authorizations.map((authorization) => ({
-                chainId: authorization.chainId,
-                address: authorization.address,
-                nonce: authorization.nonce,
-                yParity: authorization.yParity ?? 0,
-                r: authorization.r,
-                s: authorization.s,
-            }))
-            : undefined,
-    };
-}
-async function submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, authorizations, dryRun) {
-    const signedIntentOp = createSignedIntentOp(intentOp, originSignatures, destinationSignature, authorizations);
-    const orchestrator = getOrchestratorByChain(targetChain.id, config.apiKey, config.endpointUrl);
-    const intentResults = await orchestrator.submitIntent(signedIntentOp, dryRun);
-    return {
-        type: 'intent',
-        id: BigInt(intentResults.result.id),
-        sourceChains: sourceChains?.map((chain) => chain.id),
-        targetChain: targetChain.id,
-    };
-}
-async function getValidatorAccount(config, signers, publicClient, chain) {
-    if (!signers) {
-        return (0, accounts_1.getSmartAccount)(config, publicClient, chain);
-    }
-    // Owners
-    const withOwner = signers.type === 'owner' ? signers : null;
-    if (withOwner) {
-        return (0, accounts_1.getSmartAccount)(config, publicClient, chain);
-    }
-    const withSession = signers.type === 'session' ? signers : null;
-    const withGuardians = signers.type === 'guardians' ? signers : null;
-    return withSession
-        ? await (0, accounts_1.getSmartSessionSmartAccount)(config, publicClient, chain, withSession.session, withSession.enableData || null)
-        : withGuardians
-            ? await (0, accounts_1.getGuardianSmartAccount)(config, publicClient, chain, {
-                type: 'ecdsa',
-                accounts: withGuardians.guardians,
-            })
-            : null;
-}
-function getValidator(config, signers) {
-    if (!signers) {
-        return (0, validators_1.getOwnerValidator)(config);
-    }
-    // Owners
-    const withOwner = signers.type === 'owner' ? signers : null;
-    if (withOwner) {
-        // ECDSA
-        if (withOwner.kind === 'ecdsa') {
-            // Use the configured owner validator (e.g., ENS) rather than forcing Ownable
-            return (0, validators_1.getOwnerValidator)(config);
-        }
-        // Passkeys (WebAuthn)
-        if (withOwner.kind === 'passkey') {
-            return (0, core_1.getWebAuthnValidator)(1, withOwner.accounts.map((account) => ({
-                pubKey: account.publicKey,
-                authenticatorId: account.id,
-            })));
-        }
-        // Multi-factor
-        if (withOwner.kind === 'multi-factor') {
-            return (0, core_1.getMultiFactorValidator)(1, withOwner.validators);
-        }
-    }
-    // Smart sessions
-    const withSession = signers.type === 'session' ? signers.session : null;
-    if (withSession) {
-        return (0, validators_1.getSmartSessionValidator)(config);
-    }
-    // Guardians (social recovery)
-    const withGuardians = signers.type === 'guardians' ? signers : null;
-    if (withGuardians) {
-        return (0, core_1.getSocialRecoveryValidator)(withGuardians.guardians);
-    }
-    // Fallback
-    return undefined;
-}
-function parseCalls(calls, chainId) {
-    return calls.map((call) => ({
-        data: call.data ?? '0x',
-        value: call.value ?? 0n,
-        to: (0, registry_1.resolveTokenAddress)(call.to, chainId),
-    }));
-}
-function createAccountAccessList(sourceChains, sourceAssets) {
-    if (!sourceChains && !sourceAssets)
-        return undefined;
-    const chainIds = sourceChains?.map((chain) => chain.id);
-    if (!sourceAssets) {
-        return { chainIds };
-    }
-    if (Array.isArray(sourceAssets)) {
-        return chainIds
-            ? { chainIds, tokens: sourceAssets }
-            : { tokens: sourceAssets };
-    }
-    return { chainTokens: sourceAssets };
-}
-function getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSignature) {
-    const initCode = (0, accounts_1.getInitCode)(config);
-    if (config.account?.type === 'eoa') {
-        return {
-            setupOps: [],
-        };
-    }
-    else if ((0, accounts_1.is7702)(config)) {
-        // EIP-7702 initialization is only needed for EOA accounts
-        if (!eip7702InitSignature || eip7702InitSignature === '0x') {
-            throw new Error('EIP-7702 initialization signature is required for EOA accounts');
-        }
-        const { initData: eip7702InitData, contract: eip7702Contract } = (0, accounts_1.getEip7702InitCall)(config, eip7702InitSignature);
-        return {
-            setupOps: [
-                {
-                    to: accountAddress,
-                    data: eip7702InitData,
-                },
-            ],
-            delegations: {
-                0: {
-                    contract: eip7702Contract,
-                },
-            },
-        };
-    }
-    else if (initCode) {
-        const to = 'factory' in initCode ? initCode.factory : undefined;
-        const data = 'factory' in initCode ? initCode.factoryData : undefined;
-        if (!to || !data) {
-            throw new accounts_1.FactoryArgsNotAvailableError();
-        }
-        // Contract account with init code
-        return {
-            setupOps: [
-                {
-                    to,
-                    data,
-                },
-            ],
-        };
-    }
-    else {
-        // Already deployed contract account
-        return {
-            setupOps: [],
-        };
-    }
-}
-function validateTokenSymbols(chain, tokenAddressOrSymbols) {
-    function validateTokenSymbol(chain, addressOrSymbol) {
-        // Address
-        if ((0, viem_1.isAddress)(addressOrSymbol, { strict: false })) {
-            return true;
-        }
-        // Token symbol
-        const address = (0, registry_1.getTokenAddress)(addressOrSymbol, chain.id);
-        return (0, viem_1.isAddress)(address, { strict: false });
-    }
-    for (const addressOrSymbol of tokenAddressOrSymbols) {
-        if (!validateTokenSymbol(chain, addressOrSymbol)) {
-            throw new Error(`Invalid token symbol: ${addressOrSymbol}`);
-        }
-    }
-}