@rhinestone/sdk 0.0.0-dev-20260204114155

package/dist/src/execution/utils.js

@@ -0,0 +1,783 @@
+"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;
+exports.getTargetExecutionSignature = getTargetExecutionSignature;
+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 types_1 = require("../orchestrator/types");
+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';
+    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, signers);
+    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, false);
+}
+async function signTransaction(config, preparedTransaction) {
+    const { signers } = getTransactionParams(preparedTransaction.transaction);
+    const intentRoute = preparedTransaction.intentRoute;
+    const targetChain = 'targetChain' in preparedTransaction.transaction
+        ? preparedTransaction.transaction.targetChain
+        : preparedTransaction.transaction.chain;
+    const { originSignatures, destinationSignature } = await signIntent(config, intentRoute.intentOp, targetChain, signers, false);
+    const targetExecutionSignature = await getTargetExecutionSignature(config, intentRoute.intentOp, targetChain, signers);
+    return {
+        intentRoute,
+        transaction: preparedTransaction.transaction,
+        originSignatures,
+        destinationSignature,
+        targetExecutionSignature,
+    };
+}
+async function getTargetExecutionSignature(config, intentOp, targetChain, signers) {
+    if (signers?.type !== 'experimental_session') {
+        return undefined;
+    }
+    const targetExecutionIntentOp = {
+        ...intentOp,
+        nonce: intentOp.targetExecutionNonce,
+    };
+    const { destinationSignature: targetExecutionSignature } = await signIntent(config, targetExecutionIntentOp, targetChain, signers, true);
+    return targetExecutionSignature;
+}
+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.getEip1271Signature)(config, signers, chain, {
+        address: validator.address,
+        isRoot,
+    }, hash);
+    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+}
+async function signTypedData(config, parameters, chain, signers, options) {
+    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 === 'experimental_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);
+    if (!options?.skipErc6492) {
+        return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+    }
+    return signature;
+}
+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, targetExecutionSignature, } = signedTransaction;
+    const { sourceChains, targetChain } = getTransactionParams(transaction);
+    const intentOp = intentRoute.intentOp;
+    return await submitIntent(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, 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, signers) {
+    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 signatureMode = signers?.type === 'experimental_session'
+        ? types_1.SIG_MODE_EMISSARY_EXECUTION_ERC1271
+        : types_1.SIG_MODE_ERC1271_EMISSARY;
+    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,
+        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,
+            signatureMode,
+        },
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.apiKey, config.endpointUrl);
+    const intentRoute = await orchestrator.getIntentRoute(metaIntent);
+    return intentRoute;
+}
+async function signIntent(config, intentOp, targetChain, signers, targetExecution) {
+    const { origin, destination } = getIntentMessages(config, intentOp, targetExecution ?? false);
+    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);
+        // For same chain transactions, we need to modify the origin signers
+        // Specifically, we need to remove the enable data in this case
+        const matchesTargetChain = chain.id === targetChain.id;
+        const originSigners = signers?.type === 'experimental_session'
+            ? {
+                type: 'experimental_session',
+                session: signers.session,
+                verifyExecutions: matchesTargetChain
+                    ? signers.verifyExecutions
+                    : undefined,
+                enableData: matchesTargetChain ? signers.enableData : undefined,
+            }
+            : signers;
+        const signature = await signIntentTypedData(config, originSigners, validator, isRoot, typedData, chain, targetExecution ?? false);
+        originSignatures.push(signature);
+    }
+    const destinationSignature = await getDestinationSignature(config, signers, validator, isRoot, targetChain, destination, originSignatures, targetExecution ?? false);
+    return {
+        originSignatures,
+        destinationSignature,
+    };
+}
+async function getDestinationSignature(config, signers, validator, isRoot, targetChain, destination, originSignatures, targetExecution) {
+    // For smart sessions, we need to provide a separate destination signature for the target chain
+    if (signers?.type === 'experimental_session') {
+        const destinationChain = (0, registry_1.getChainById)(targetChain.id);
+        const destinationSignatures = await signIntentTypedData(config, signers, validator, isRoot, destination, destinationChain, targetExecution);
+        return typeof destinationSignatures === 'object'
+            ? destinationSignatures.preClaimSig
+            : (destinationSignatures ?? '0x');
+    }
+    const lastOriginSignature = originSignatures.at(-1);
+    return typeof lastOriginSignature === 'object'
+        ? lastOriginSignature.preClaimSig
+        : (lastOriginSignature ?? '0x');
+}
+function getIntentMessages(config, intentOp, targetExecution) {
+    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 = targetExecution ||
+        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, targetExecution) {
+    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);
+    if (signers?.type === 'experimental_session' && signers.verifyExecutions) {
+        if (targetExecution) {
+            return await (0, accounts_1.getEmissarySignature)(config, {
+                type: 'experimental_session',
+                session: signers.session,
+                verifyExecutions: true,
+            }, chain, hash);
+        }
+        const eip1271Signature = await (0, accounts_1.getEip1271Signature)(config, {
+            type: 'experimental_session',
+            session: signers.session,
+            verifyExecutions: false,
+            enableData: signers.enableData,
+        }, chain, {
+            address: validator.address,
+            isRoot,
+        }, hash);
+        const emissarySignature = await (0, accounts_1.getEmissarySignature)(config, {
+            type: 'experimental_session',
+            session: signers.session,
+            verifyExecutions: true,
+            enableData: signers.enableData,
+        }, chain, hash);
+        return {
+            preClaimSig: emissarySignature,
+            notarizedClaimSig: eip1271Signature,
+        };
+    }
+    return await (0, accounts_1.getEip1271Signature)(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, targetExecutionSignature, authorizations, dryRun) {
+    return submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, 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, targetExecutionSignature, authorizations) {
+    return {
+        ...intentOp,
+        originSignatures,
+        destinationSignature,
+        targetExecutionSignature,
+        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, targetExecutionSignature, authorizations, dryRun) {
+    const signedIntentOp = createSignedIntentOp(intentOp, originSignatures, destinationSignature, targetExecutionSignature, 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 withGuardians = signers.type === 'guardians' ? signers : null;
+    return 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 === 'experimental_session';
+    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)) {
+        const isExactConfig = sourceAssets.length > 0 && typeof sourceAssets[0] !== 'string';
+        if (isExactConfig) {
+            const resolvedConfigs = sourceAssets.map((config) => ({
+                chainId: config.chain.id,
+                tokenAddress: (0, registry_1.resolveTokenAddress)(config.address, config.chain.id),
+                amount: config.amount,
+            }));
+            return resolvedConfigs;
+        }
+        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}`);
+        }
+    }
+}