@rhinestone/sdk 1.5.1 → 2.0.0-beta.1

package/dist/src/execution/utils.js

@@ -1,47 +1,19 @@
-"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.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;
-exports.hashErc7739TypedDataForSolady = hashErc7739TypedDataForSolady;
-exports.resolveSessionForChain = resolveSessionForChain;
-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 common_1 = require("../accounts/signing/common");
-const startale_1 = require("../accounts/startale");
-const utils_1 = require("../accounts/utils");
-const provider_1 = require("../auth/provider");
-const modules_1 = require("../modules");
-const validators_1 = require("../modules/validators");
-const core_1 = require("../modules/validators/core");
-const permit2_1 = require("../modules/validators/policies/claim/permit2");
-const orchestrator_1 = require("../orchestrator");
-const registry_1 = require("../orchestrator/registry");
-const types_1 = require("../orchestrator/types");
-const utils_2 = require("../orchestrator/utils");
-const compact_1 = require("./compact");
-const error_1 = require("./error");
-const permit2_2 = require("./permit2");
-const singleChainOps_1 = require("./singleChainOps");
+import { concat, createPublicClient, createWalletClient, encodeAbiParameters, encodePacked, hashDomain, hashMessage, hashStruct, hashTypedData, isAddress, keccak256, publicActions, toHex, } from 'viem';
+import { entryPoint07Address, getUserOperationHash, } from 'viem/account-abstraction';
+import { wrapTypedDataSignature } from 'viem/experimental/erc7739';
+import { EoaAccountMustHaveAccountError, EoaSigningMethodNotConfiguredError, FactoryArgsNotAvailableError, getAccountProvider, getAddress, getEip712Domain, getEip1271Signature, getEip7702InitCall, getEmissarySignature, getGuardianSmartAccount, getInitCode, getSmartAccount, getTypedDataPackedSignature, is7702, toErc6492Signature, } from '../accounts/index.js';
+import { convertOwnerSetToSignerSet } from '../accounts/signing/common.js';
+import { K1_DEFAULT_VALIDATOR_ADDRESS } from '../accounts/startale.js';
+import { createTransport, getBundlerClient, } from '../accounts/utils.js';
+import { createAuthProvider } from '../auth/provider.js';
+import { buildMockSignature, DUMMY_PRECLAIMOP_SELECTOR, DUMMY_PRECLAIMOP_TARGET, getOwnerValidator, getPermissionId, getSmartSessionValidator, isSessionEnabled, } from '../modules/validators/index.js';
+import { getMultiFactorValidator, getSocialRecoveryValidator, getWebAuthnValidator, supportsEip712, } from '../modules/validators/core.js';
+import { buildPermit2ClaimPolicyCalldata } from '../modules/validators/policies/claim/permit2.js';
+import { getOrchestrator, } from '../orchestrator/index.js';
+import { getChainById, getTokenAddress, resolveTokenAddress, } from '../orchestrator/registry.js';
+import { SIG_MODE_EMISSARY_EXECUTION_ERC1271, SIG_MODE_ERC1271_EMISSARY, } from '../orchestrator/types.js';
+import { convertBigIntFields } from '../orchestrator/utils.js';
+import { Eip7702InitSignatureRequiredError, QuoteNotInPreparedTransactionError, SignerNotSupportedError, } from './error.js';
 function isResolvedSessionSignerSet(signers) {
     return (signers?.type === 'experimental_session' && 'verifyExecutions' in signers);
 }
@@ -50,7 +22,7 @@ async function resolveSignersForChain(config, signers, chainId) {
         return signers;
     }
     const resolved = resolveSessionForChain(signers, chainId);
-    const enabled = await (0, validators_1.isSessionEnabled)((0, accounts_1.getAddress)(config), config.provider, resolved.session, config.useDevContracts);
+    const enabled = await isSessionEnabled(getAddress(config), config.provider, resolved.session, config.useDevContracts);
     const enableData = enabled ? undefined : resolved.enableData;
     const hasExplicitActions = !!resolved.session.actions?.length;
     const verifyExecutions = resolved.verifyExecutions ?? signers.verifyExecutions ?? hasExplicitActions;
@@ -72,15 +44,15 @@ function resolveSessionForChain(signers, chainId) {
     return { session: signers.session, enableData: signers.enableData };
 }
 async function prepareTransaction(config, transaction) {
-    const { sourceChains, targetChain, tokenRequests, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, auxiliaryFunds, account, recipient, } = getTransactionParams(transaction);
-    const accountAddress = (0, accounts_1.getAddress)(config);
+    const { sourceChains, targetChain, tokenRequests, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, auxiliaryFunds, account, recipient, } = getTransactionParams(transaction);
+    const accountAddress = getAddress(config);
     const isUserOpSigner = signers?.type === 'guardians';
     if (isUserOpSigner) {
-        throw new error_1.SignerNotSupportedError();
+        throw new SignerNotSupportedError();
     }
-    const prepared = await prepareTransactionAsIntent(config, sourceChains, targetChain, await resolveCallInputs(transaction.calls, config, targetChain, accountAddress), transaction.gasLimit, tokenRequests, recipient, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, auxiliaryFunds, account, signers);
+    const prepared = await prepareTransactionAsIntent(config, sourceChains, targetChain, await resolveCallInputs(transaction.calls, config, targetChain, accountAddress), transaction.gasLimit, tokenRequests, recipient, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, auxiliaryFunds, account, signers);
     return {
-        intentRoute: prepared.intentRoute,
+        quotes: prepared.quotes,
         intentInput: prepared.intentInput,
         transaction,
     };
@@ -88,7 +60,7 @@ async function prepareTransaction(config, transaction) {
 async function prepareUserOperation(config, transaction) {
     const chain = transaction.chain;
     const signers = transaction.signers;
-    const accountAddress = (0, accounts_1.getAddress)(config);
+    const accountAddress = getAddress(config);
     const data = await prepareTransactionAsUserOp(config, chain, await resolveCallInputs(transaction.calls, config, chain, accountAddress), signers, transaction.gasLimit);
     return {
         userOperation: data.userOp,
@@ -117,19 +89,21 @@ async function resolveCallInputs(inputs, config, chain, accountAddress) {
     }
     return resolved;
 }
-function getTransactionMessages(config, preparedTransaction) {
-    return getIntentMessages(config, preparedTransaction.intentRoute.intentOp);
+function getTransactionMessages(_config, preparedTransaction, options) {
+    const quote = resolveQuote(preparedTransaction.quotes, options);
+    return getIntentMessages(quote.signData);
 }
-async function signTransaction(config, preparedTransaction) {
+async function signTransaction(config, preparedTransaction, options) {
     const { signers } = getTransactionParams(preparedTransaction.transaction);
-    const intentRoute = preparedTransaction.intentRoute;
+    const quote = resolveQuote(preparedTransaction.quotes, options);
     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);
+    const { originSignatures, destinationSignature } = await signIntent(config, quote.signData, targetChain, signers, false);
+    const targetExecutionSignature = await getTargetExecutionSignature(config, quote.signData, targetChain, signers);
     return {
-        intentRoute,
+        quote,
+        quotes: preparedTransaction.quotes,
         intentInput: preparedTransaction.intentInput,
         transaction: preparedTransaction.transaction,
         originSignatures,
@@ -137,13 +111,22 @@ async function signTransaction(config, preparedTransaction) {
         targetExecutionSignature,
     };
 }
-async function getTargetExecutionSignature(config, intentOp, targetChain, signers) {
+function resolveQuote(quotes, options) {
+    if (!options)
+        return quotes.best;
+    const match = quotes.all.find((q) => q.intentId === options.intentId);
+    if (!match) {
+        throw new QuoteNotInPreparedTransactionError({
+            context: { intentId: options.intentId },
+        });
+    }
+    return match;
+}
+async function getTargetExecutionSignature(config, signData, targetChain, signers) {
     if (signers?.type !== 'experimental_session') {
         return undefined;
     }
-    const settlementLayers = intentOp.elements.map((e) => e.mandate.qualifier.settlementContext.settlementLayer);
-    const hasIntentExecutorOps = settlementLayers.some((l) => l === 'INTENT_EXECUTOR' || l === 'SAME_CHAIN');
-    if (!hasIntentExecutorOps) {
+    if (!signData.targetExecution) {
         return undefined;
     }
     const resolvedSigners = await resolveSignersForChain(config, signers, targetChain.id);
@@ -151,13 +134,13 @@ async function getTargetExecutionSignature(config, intentOp, targetChain, signer
         !resolvedSigners.verifyExecutions) {
         return undefined;
     }
-    const destination = getTargetExecutionMessage(config, intentOp);
     const validator = getValidator(config, signers);
     if (!validator) {
         throw new Error('Validator not available');
     }
-    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const ownerValidator = getOwnerValidator(config);
     const isRoot = validator.address === ownerValidator.address;
+    const destination = prepareTypedData(signData.targetExecution);
     const signature = await getDestinationSignature(config, resolvedSigners, validator, isRoot, targetChain, destination, [], true);
     return signature;
 }
@@ -175,28 +158,35 @@ async function signUserOperation(config, preparedUserOperation) {
     };
 }
 async function signAuthorizations(config, preparedTransaction) {
-    return await signAuthorizationsInternal(config, preparedTransaction.intentRoute);
+    const transaction = preparedTransaction.transaction;
+    const sourceChains = 'chain' in transaction ? [transaction.chain] : transaction.sourceChains;
+    const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
+    return await signAuthorizationsInternal(config, {
+        sourceChains,
+        targetChain,
+        eip7702InitSignature: transaction.eip7702InitSignature,
+    });
 }
 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 ownerValidator = 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, {
+    const hash = hashMessage(message);
+    const signature = await getEip1271Signature(config, signers, chain, {
         address: validator.address,
         isRoot,
     }, hash);
-    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+    return await 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 ownerValidator = getOwnerValidator(config);
     const isRoot = validator.address === ownerValidator.address;
     if (signers?.type === 'experimental_session') {
         const resolved = resolveSessionForChain(signers, chain.id);
@@ -205,31 +195,31 @@ async function signTypedData(config, parameters, chain, signers, options) {
             isRoot,
         }, resolved.session, parameters);
     }
-    const account = (0, accounts_1.getAccountProvider)(config);
-    if (account.type === 'startale' && (0, core_1.supportsEip712)(validator)) {
+    const account = getAccountProvider(config);
+    if (account.type === 'startale' && supportsEip712(validator)) {
         const isK1 = validator.address.toLowerCase() ===
-            startale_1.K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+            K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
         if (isK1) {
             const sig = await signErc7739TypedData(config, signers, validator, isRoot, parameters, chain);
             if (!options?.skipErc6492) {
-                return await (0, accounts_1.toErc6492Signature)(config, sig, chain);
+                return await toErc6492Signature(config, sig, chain);
             }
             return sig;
         }
     }
-    const signature = await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, {
+    const signature = await getTypedDataPackedSignature(config, signers, chain, {
         address: validator.address,
         isRoot,
     }, parameters);
     if (!options?.skipErc6492) {
-        return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+        return await toErc6492Signature(config, signature, chain);
     }
     return signature;
 }
 async function signTypedDataWithSession(config, chain, validator, session, parameters) {
-    const { name, version, chainId, verifyingContract, salt } = (0, accounts_1.getEip712Domain)(config, chain);
-    const signers = (0, common_1.convertOwnerSetToSignerSet)(session.owners);
-    const signature = await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, validator, {
+    const { name, version, chainId, verifyingContract, salt } = getEip712Domain(config, chain);
+    const signers = convertOwnerSetToSignerSet(session.owners);
+    const signature = await getTypedDataPackedSignature(config, signers, chain, validator, {
         domain: parameters.domain,
         primaryType: 'TypedDataSign',
         types: {
@@ -252,55 +242,58 @@ async function signTypedDataWithSession(config, chain, validator, session, param
             salt,
         },
     }, (signature) => {
-        const erc7739Signature = (0, erc7739_1.wrapTypedDataSignature)({
+        const erc7739Signature = 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)(session), erc7739Signature]);
+        return encodePacked(['bytes32', 'bytes'], [getPermissionId(session), erc7739Signature]);
     });
-    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+    return await toErc6492Signature(config, signature, chain);
 }
-async function signAuthorizationsInternal(config, data) {
+async function signAuthorizationsInternal(config, context) {
     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 eip7702InitSignature = context.eip7702InitSignature;
+    if (!eip7702InitSignature) {
+        return [];
+    }
+    const accountAddress = getAddress(config);
+    const { contract: eip7702Contract } = getEip7702InitCall(config, eip7702InitSignature);
+    const chains = new Map();
+    for (const chain of [...(context.sourceChains ?? []), context.targetChain]) {
+        chains.set(chain.id, chain);
+    }
     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)({
+    for (const chain of chains.values()) {
+        const walletClient = createWalletClient({
             chain,
             account: eoa,
-            transport: (0, utils_1.createTransport)(chain, config.provider),
-        }).extend(viem_1.publicActions);
+            transport: createTransport(chain, config.provider),
+        }).extend(publicActions);
         const code = await walletClient.getCode({
             address: accountAddress,
         });
-        const isDelegated = code === (0, viem_1.concat)(['0xef0100', delegation.contract.toLowerCase()]);
+        const isDelegated = code === concat(['0xef0100', eip7702Contract.toLowerCase()]);
         if (isDelegated) {
             continue;
         }
         const authorization = await walletClient.signAuthorization({
-            contractAddress: delegation.contract,
-            chainId: Number(chainId),
+            contractAddress: eip7702Contract,
+            chainId: chain.id,
         });
         authorizations.push(authorization);
     }
     return authorizations;
 }
 async function submitTransaction(config, signedTransaction, authorizations, dryRun = false) {
-    const { intentRoute, intentInput, transaction, originSignatures, destinationSignature, targetExecutionSignature, } = signedTransaction;
+    const { quote, intentInput, 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, intentInput);
+    return await submitIntentInternal(config, sourceChains, targetChain, quote, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput);
 }
 async function submitUserOperation(config, signedUserOperation) {
     const chain = signedUserOperation.transaction.chain;
@@ -320,7 +313,6 @@ function getTransactionParams(transaction) {
     const settlementLayers = transaction.settlementLayers;
     const sourceAssets = transaction.sourceAssets;
     const feeAsset = transaction.feeAsset;
-    const lockFunds = transaction.lockFunds;
     const auxiliaryFunds = transaction.auxiliaryFunds;
     const account = transaction.experimental_accountOverride;
     const recipient = transaction.recipient;
@@ -336,7 +328,6 @@ function getTransactionParams(transaction) {
         settlementLayers,
         sourceAssets,
         feeAsset,
-        lockFunds,
         auxiliaryFunds,
         account,
         recipient,
@@ -349,15 +340,15 @@ function getTokenRequests(targetChain, initialTokenRequests) {
     return initialTokenRequests ?? [];
 }
 async function prepareTransactionAsUserOp(config, chain, callInputs, signers, gasLimit) {
-    const publicClient = (0, viem_1.createPublicClient)({
+    const publicClient = createPublicClient({
         chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
+        transport: 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 bundlerClient = getBundlerClient(config, publicClient);
     const calls = parseCalls(callInputs, chain.id);
     const userOp = await bundlerClient.prepareUserOperation({
         account: validatorAccount,
@@ -366,10 +357,10 @@ async function prepareTransactionAsUserOp(config, chain, callInputs, signers, ga
     });
     return {
         userOp,
-        hash: (0, account_abstraction_1.getUserOperationHash)({
+        hash: getUserOperationHash({
             userOperation: userOp,
             chainId: chain.id,
-            entryPointAddress: account_abstraction_1.entryPoint07Address,
+            entryPointAddress: entryPoint07Address,
             entryPointVersion: '0.7',
         }),
     };
@@ -383,7 +374,7 @@ function getAccountType(accountConfig) {
     }
 }
 function getIntentAccount(config, eip7702InitSignature, account) {
-    const accountAddress = (0, accounts_1.getAddress)(config);
+    const accountAddress = getAddress(config);
     const accountType = getAccountType(config.account);
     const { setupOps, delegations } = getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSignature);
     return {
@@ -393,7 +384,7 @@ function getIntentAccount(config, eip7702InitSignature, account) {
         delegations,
     };
 }
-async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipientInput, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, auxiliaryFunds, account, signers) {
+async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipientInput, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, auxiliaryFunds, account, signers) {
     const calls = parseCalls(callInputs, targetChain.id);
     const accountAccessList = createAccountAccessList(sourceChains, sourceAssets);
     function getRecipient(recipient) {
@@ -414,8 +405,6 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
     const intentAccount = {
         ...getIntentAccount(config, eip7702InitSignature, account),
         ...(signers?.type === 'experimental_session' && {
-            // Global fallback: target-chain sig for backward-compat with older orchestrators
-            mockSignature: (0, validators_1.buildMockSignature)(resolveSessionForChain(signers, targetChain.id).session, config.useDevContracts, sourceChains?.length ?? 1),
             // Per-chain map: enables accurate per-chain session validation gas simulation
             mockSignatures: Object.fromEntries([
                 ...new Set([
@@ -424,14 +413,14 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
                 ]),
             ].map((chainId) => [
                 String(chainId),
-                (0, validators_1.buildMockSignature)(resolveSessionForChain(signers, chainId).session, config.useDevContracts, sourceChains?.length ?? 1, chainId),
+                buildMockSignature(resolveSessionForChain(signers, chainId).session, config.useDevContracts, sourceChains?.length ?? 1, chainId),
             ])),
         }),
     };
     const recipient = getRecipient(recipientInput);
     const signatureMode = signers?.type === 'experimental_session'
-        ? types_1.SIG_MODE_EMISSARY_EXECUTION_ERC1271
-        : types_1.SIG_MODE_ERC1271_EMISSARY;
+        ? SIG_MODE_EMISSARY_EXECUTION_ERC1271
+        : SIG_MODE_ERC1271_EMISSARY;
     // For session signers that need enabling, pass a dummy preclaimop per source chain
     // so the orchestrator bakes it into the bundle before computing its HMAC. The filler
     // executes the op via verifyExecution in ENABLE mode, enabling the session on-chain
@@ -451,9 +440,9 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
                 continue;
             preClaimExecutions[chainId] = [
                 {
-                    to: validators_1.DUMMY_PRECLAIMOP_TARGET,
+                    to: DUMMY_PRECLAIMOP_TARGET,
                     value: 0n,
-                    data: validators_1.DUMMY_PRECLAIMOP_SELECTOR,
+                    data: DUMMY_PRECLAIMOP_SELECTOR,
                 },
             ];
         }
@@ -461,7 +450,7 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
     const metaIntent = {
         destinationChainId: targetChain.id,
         tokenRequests: tokenRequests.map((tokenRequest) => ({
-            tokenAddress: (0, registry_1.resolveTokenAddress)(tokenRequest.address, targetChain.id),
+            tokenAddress: resolveTokenAddress(tokenRequest.address, targetChain.id),
             amount: tokenRequest.amount,
         })),
         recipient,
@@ -470,19 +459,18 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
         destinationGasUnits: gasLimit,
         accountAccessList,
         options: {
-            topupCompact: lockFunds ?? false,
             feeToken: feeAsset,
             sponsorSettings: sponsored
                 ? typeof sponsored === 'object'
                     ? {
-                        gasSponsored: sponsored.gas,
-                        bridgeFeesSponsored: sponsored.bridging,
-                        swapFeesSponsored: sponsored.swaps,
+                        gas: sponsored.gas,
+                        bridgeFees: sponsored.bridging,
+                        swapFees: sponsored.swaps,
                     }
                     : {
-                        gasSponsored: sponsored,
-                        bridgeFeesSponsored: sponsored,
-                        swapFeesSponsored: sponsored,
+                        gas: sponsored,
+                        bridgeFees: sponsored,
+                        swapFees: sponsored,
                     }
                 : undefined,
             settlementLayers,
@@ -491,17 +479,24 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
         },
         ...(Object.keys(preClaimExecutions).length > 0 && { preClaimExecutions }),
     };
-    const serializedIntent = (0, utils_2.convertBigIntFields)(metaIntent);
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(config._authProvider ?? (0, provider_1.createAuthProvider)(config), config.endpointUrl, config.headers);
-    const intentRoute = await orchestrator.getIntentRoute(metaIntent);
-    return { intentRoute, intentInput: serializedIntent };
+    const serializedIntent = convertBigIntFields(metaIntent);
+    const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
+    const { routes } = await orchestrator.createQuote(metaIntent);
+    const best = routes[0];
+    if (!best) {
+        throw new Error('Orchestrator returned no quote');
+    }
+    return {
+        quotes: { best, all: routes },
+        intentInput: serializedIntent,
+    };
 }
-async function signIntent(config, intentOp, targetChain, signers, targetExecution) {
-    const { origin, destination } = getIntentMessages(config, intentOp);
+async function signIntent(config, signData, targetChain, signers, targetExecution) {
+    const { origin, destination } = getIntentMessages(signData);
     if (config.account?.type === 'eoa') {
         const eoa = config.eoa;
         if (!eoa) {
-            throw new accounts_1.EoaAccountMustHaveAccountError();
+            throw new EoaAccountMustHaveAccountError();
         }
         const originSignatures = [];
         for (const typedData of origin) {
@@ -510,7 +505,7 @@ async function signIntent(config, intentOp, targetChain, signers, targetExecutio
                 originSignatures.push(signature);
             }
             else {
-                throw new accounts_1.EoaSigningMethodNotConfiguredError('signTypedData');
+                throw new EoaSigningMethodNotConfiguredError('signTypedData');
             }
         }
         const destinationSignature = originSignatures.at(-1);
@@ -523,11 +518,11 @@ async function signIntent(config, intentOp, targetChain, signers, targetExecutio
     if (!validator) {
         throw new Error('Validator not available');
     }
-    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const ownerValidator = 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 chain = getChainById(typedData.domain?.chainId);
         const originSigners = await resolveSignersForChain(config, signers, chain.id);
         const signature = await signIntentTypedData(config, originSigners, validator, isRoot, typedData, chain, targetExecution ?? false);
         originSignatures.push(signature);
@@ -549,8 +544,8 @@ async function getDestinationSignature(config, signers, validator, isRoot, targe
     // the account's eip712Domain() returns the target chain's chainId, which differs
     // from the origin chain used for the last origin signature
     const isK1Validator = validator.address.toLowerCase() ===
-        startale_1.K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
-    if (isK1Validator && (0, core_1.supportsEip712)(validator)) {
+        K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+    if (isK1Validator && supportsEip712(validator)) {
         return await signDestinationSeparately(config, signers, validator, isRoot, targetChain, destination, targetExecution);
     }
     const lastOriginSignature = originSignatures.at(-1);
@@ -559,50 +554,63 @@ async function getDestinationSignature(config, signers, validator, isRoot, targe
         : (lastOriginSignature ?? '0x');
 }
 async function signDestinationSeparately(config, signers, validator, isRoot, targetChain, destination, targetExecution) {
-    const destinationChain = (0, registry_1.getChainById)(targetChain.id);
+    const destinationChain = getChainById(targetChain.id);
     const destinationSignatures = await signIntentTypedData(config, signers, validator, isRoot, destination, destinationChain, targetExecution);
     return typeof destinationSignatures === 'object'
         ? destinationSignatures.preClaimSig
         : (destinationSignatures ?? '0x');
 }
-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_2.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);
+function getIntentMessages(signData) {
     return {
-        origin,
-        destination,
+        origin: signData.origin.map(prepareTypedData),
+        destination: prepareTypedData(signData.destination),
+        targetExecution: signData.targetExecution
+            ? prepareTypedData(signData.targetExecution)
+            : undefined,
     };
 }
-function getTargetExecutionMessage(config, intentOp) {
-    const address = (0, accounts_1.getAddress)(config);
-    const intentExecutor = (0, modules_1.getIntentExecutor)(config);
-    const lastElement = intentOp.elements.at(-1);
-    const typedData = (0, singleChainOps_1.getTypedData)(address, intentExecutor.address, lastElement, BigInt(intentOp.targetExecutionNonce));
-    typedData.message.gasRefund = typedData.message.gasRefund ?? {
-        token: '0x0000000000000000000000000000000000000000',
-        exchangeRate: 0n,
-        overhead: 0n,
+// Server emits uint*/int* values as decimal strings; viem's hashTypedData
+// expects bigint. Walk the message tree against the type schema and coerce
+// numeric fields back to bigint before signing.
+function prepareTypedData(td) {
+    const types = td.types;
+    return {
+        ...td,
+        message: coerceTypedDataMessage(types, td.primaryType, td.message),
     };
-    return typedData;
+}
+function coerceTypedDataMessage(types, primaryType, message) {
+    const fields = types[primaryType];
+    if (!fields)
+        return message;
+    const result = { ...message };
+    for (const { name, type } of fields) {
+        if (name in message) {
+            result[name] = coerceTypedDataValue(types, type, message[name]);
+        }
+    }
+    return result;
+}
+function coerceTypedDataValue(types, type, value) {
+    if (value === null || value === undefined)
+        return value;
+    const arrayMatch = type.match(/^(.+)\[\d*\]$/);
+    if (arrayMatch) {
+        const elementType = arrayMatch[1];
+        if (!Array.isArray(value))
+            return value;
+        return value.map((v) => coerceTypedDataValue(types, elementType, v));
+    }
+    if (/^u?int\d*$/.test(type)) {
+        if (typeof value === 'string' || typeof value === 'number') {
+            return BigInt(value);
+        }
+        return value;
+    }
+    if (types[type]) {
+        return coerceTypedDataMessage(types, type, value);
+    }
+    return value;
 }
 /** Computes claim policy calldata when parameters are Permit2 typed data with claim policies. */
 function resolveClaimPolicyData(signers, parameters) {
@@ -618,21 +626,21 @@ function resolveClaimPolicyData(signers, parameters) {
         typeof msg.deadline !== 'bigint') {
         return undefined;
     }
-    return (0, permit2_1.buildPermit2ClaimPolicyCalldata)(signers.session.claimPolicies[0], parameters.message);
+    return buildPermit2ClaimPolicyCalldata(signers.session.claimPolicies[0], parameters.message);
 }
 async function signIntentTypedData(config, signers, validator, isRoot, parameters, chain, targetExecution) {
-    if ((0, core_1.supportsEip712)(validator)) {
+    if (supportsEip712(validator)) {
         const isK1Validator = validator.address.toLowerCase() ===
-            startale_1.K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+            K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
         if (isK1Validator) {
             return await signErc7739TypedData(config, signers, validator, isRoot, parameters, chain);
         }
-        return await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, {
+        return await getTypedDataPackedSignature(config, signers, chain, {
             address: validator.address,
             isRoot,
         }, parameters);
     }
-    const hash = (0, viem_1.hashTypedData)(parameters);
+    const hash = hashTypedData(parameters);
     if (isResolvedSessionSignerSet(signers) && signers.verifyExecutions) {
         if (targetExecution) {
             const targetSigners = {
@@ -643,7 +651,7 @@ async function signIntentTypedData(config, signers, validator, isRoot, parameter
             };
             // signWithSession (called inside getEmissarySignature) already calls packSignature
             // internally, so no transform is needed here
-            return await (0, accounts_1.getEmissarySignature)(config, targetSigners, chain, hash);
+            return await getEmissarySignature(config, targetSigners, chain, hash);
         }
         const claimPolicyData = resolveClaimPolicyData(signers, parameters);
         const sessionSignersForEip1271 = {
@@ -653,11 +661,11 @@ async function signIntentTypedData(config, signers, validator, isRoot, parameter
             enableData: signers.enableData,
             claimPolicyData,
         };
-        const eip1271Signature = await (0, accounts_1.getEip1271Signature)(config, sessionSignersForEip1271, chain, {
+        const eip1271Signature = await getEip1271Signature(config, sessionSignersForEip1271, chain, {
             address: validator.address,
             isRoot,
         }, hash);
-        const emissarySignature = await (0, accounts_1.getEmissarySignature)(config, {
+        const emissarySignature = await getEmissarySignature(config, {
             type: 'experimental_session',
             session: signers.session,
             verifyExecutions: true,
@@ -670,12 +678,12 @@ async function signIntentTypedData(config, signers, validator, isRoot, parameter
     }
     if (isResolvedSessionSignerSet(signers)) {
         const claimPolicyData = resolveClaimPolicyData(signers, parameters);
-        return await (0, accounts_1.getEip1271Signature)(config, claimPolicyData !== undefined ? { ...signers, claimPolicyData } : signers, chain, {
+        return await getEip1271Signature(config, claimPolicyData !== undefined ? { ...signers, claimPolicyData } : signers, chain, {
             address: validator.address,
             isRoot,
         }, hash);
     }
-    return await (0, accounts_1.getEip1271Signature)(config, signers, chain, {
+    return await getEip1271Signature(config, signers, chain, {
         address: validator.address,
         isRoot,
     }, hash);
@@ -685,9 +693,9 @@ async function signUserOp(config, chain, signers, userOp) {
     if (!validator) {
         throw new Error('Validator not available');
     }
-    const publicClient = (0, viem_1.createPublicClient)({
+    const publicClient = createPublicClient({
         chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
+        transport: createTransport(chain, config.provider),
     });
     const account = await getValidatorAccount(config, signers, publicClient, chain);
     if (!account) {
@@ -696,36 +704,36 @@ async function signUserOp(config, chain, signers, userOp) {
     return await account.signUserOperation(userOp);
 }
 async function submitUserOp(config, chain, userOp, signature) {
-    const publicClient = (0, viem_1.createPublicClient)({
+    const publicClient = createPublicClient({
         chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
+        transport: createTransport(chain, config.provider),
     });
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const bundlerClient = getBundlerClient(config, publicClient);
     const hash = await bundlerClient.request({
         method: 'eth_sendUserOperation',
         params: [
             {
                 sender: userOp.sender,
-                nonce: (0, viem_1.toHex)(userOp.nonce),
+                nonce: 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),
+                callGasLimit: toHex(userOp.callGasLimit),
+                verificationGasLimit: toHex(userOp.verificationGasLimit),
+                preVerificationGas: toHex(userOp.preVerificationGas),
+                maxPriorityFeePerGas: toHex(userOp.maxPriorityFeePerGas),
+                maxFeePerGas: toHex(userOp.maxFeePerGas),
                 paymaster: userOp.paymaster,
                 paymasterVerificationGasLimit: userOp.paymasterVerificationGasLimit
-                    ? (0, viem_1.toHex)(userOp.paymasterVerificationGasLimit)
+                    ? toHex(userOp.paymasterVerificationGasLimit)
                     : undefined,
                 paymasterPostOpGasLimit: userOp.paymasterPostOpGasLimit
-                    ? (0, viem_1.toHex)(userOp.paymasterPostOpGasLimit)
+                    ? toHex(userOp.paymasterPostOpGasLimit)
                     : undefined,
                 paymasterData: userOp.paymasterData,
                 signature,
             },
-            account_abstraction_1.entryPoint07Address,
+            entryPoint07Address,
         ],
     });
     return {
@@ -734,54 +742,52 @@ async function submitUserOp(config, chain, userOp, signature) {
         chain: chain.id,
     };
 }
-async function submitIntent(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput) {
-    return submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput);
-}
-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, quote, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput) {
+    const request = {
+        intentId: quote.intentId,
+        signatures: {
+            origin: originSignatures,
+            destination: destinationSignature,
+            ...(targetExecutionSignature !== undefined && {
+                targetExecution: targetExecutionSignature,
+            }),
+        },
+        ...(authorizations.length > 0 && {
+            authorizations: {
+                sponsor: authorizations.map((authorization) => ({
+                    chainId: authorization.chainId,
+                    address: authorization.address,
+                    nonce: authorization.nonce,
+                    yParity: authorization.yParity ?? 0,
+                    r: authorization.r,
+                    s: authorization.s,
+                })),
+            },
+        }),
+        ...(dryRun && { options: { dryRun: true } }),
     };
-}
-async function submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput) {
-    const signedIntentOp = createSignedIntentOp(intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations);
     const isSponsored = !!intentInput?.options?.sponsorSettings;
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(config._authProvider ?? (0, provider_1.createAuthProvider)(config), config.endpointUrl, config.headers);
-    const intentResults = await orchestrator.submitIntent(signedIntentOp, dryRun, intentInput ? { intentInput, isSponsored } : undefined);
-    // Some settlement paths (e.g. SAME_CHAIN) may not return a result.id — fall
-    // back to the nonce which the orchestrator also accepts as an intent identifier.
-    const intentId = intentResults.result.id ?? intentOp.nonce;
+    const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
+    const response = await orchestrator.createIntent(request, intentInput ? { intentInput, isSponsored } : undefined);
     return {
         type: 'intent',
-        id: BigInt(intentId),
+        id: response.intentId,
         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);
+        return getSmartAccount(config, publicClient, chain);
     }
     // Owners
     const withOwner = signers.type === 'owner' ? signers : null;
     if (withOwner) {
-        return (0, accounts_1.getSmartAccount)(config, publicClient, chain);
+        return getSmartAccount(config, publicClient, chain);
     }
     const withGuardians = signers.type === 'guardians' ? signers : null;
     return withGuardians
-        ? await (0, accounts_1.getGuardianSmartAccount)(config, publicClient, chain, {
+        ? await getGuardianSmartAccount(config, publicClient, chain, {
             type: 'ecdsa',
             accounts: withGuardians.guardians,
         })
@@ -789,7 +795,7 @@ async function getValidatorAccount(config, signers, publicClient, chain) {
 }
 function getValidator(config, signers) {
     if (!signers) {
-        return (0, validators_1.getOwnerValidator)(config);
+        return getOwnerValidator(config);
     }
     // Owners
     const withOwner = signers.type === 'owner' ? signers : null;
@@ -797,29 +803,29 @@ function getValidator(config, signers) {
         // ECDSA
         if (withOwner.kind === 'ecdsa') {
             // Use the configured owner validator (e.g., ENS) rather than forcing Ownable
-            return (0, validators_1.getOwnerValidator)(config);
+            return getOwnerValidator(config);
         }
         // Passkeys (WebAuthn)
         if (withOwner.kind === 'passkey') {
-            return (0, core_1.getWebAuthnValidator)(1, withOwner.accounts.map((account) => ({
+            return 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);
+            return getMultiFactorValidator(1, withOwner.validators);
         }
     }
     // Smart sessions
     const withSession = signers.type === 'experimental_session';
     if (withSession) {
-        return (0, validators_1.getSmartSessionValidator)(config);
+        return getSmartSessionValidator(config);
     }
     // Guardians (social recovery)
     const withGuardians = signers.type === 'guardians' ? signers : null;
     if (withGuardians) {
-        return (0, core_1.getSocialRecoveryValidator)(withGuardians.guardians);
+        return getSocialRecoveryValidator(withGuardians.guardians);
     }
     // Fallback
     return undefined;
@@ -828,7 +834,7 @@ function parseCalls(calls, chainId) {
     return calls.map((call) => ({
         data: call.data ?? '0x',
         value: call.value ?? 0n,
-        to: (0, registry_1.resolveTokenAddress)(call.to, chainId),
+        to: resolveTokenAddress(call.to, chainId),
     }));
 }
 function createAccountAccessList(sourceChains, sourceAssets) {
@@ -840,12 +846,32 @@ function createAccountAccessList(sourceChains, sourceAssets) {
     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;
+            const chainTokens = {};
+            const chainTokenAmounts = {};
+            for (const config of sourceAssets) {
+                const chainId = config.chain.id;
+                const tokenAddress = resolveTokenAddress(config.address, config.chain.id);
+                if (config.amount !== undefined) {
+                    if (!chainTokenAmounts[chainId])
+                        chainTokenAmounts[chainId] = {};
+                    chainTokenAmounts[chainId][tokenAddress] = config.amount;
+                }
+                else {
+                    if (!chainTokens[chainId])
+                        chainTokens[chainId] = [];
+                    chainTokens[chainId].push(tokenAddress);
+                }
+            }
+            const out = {};
+            if (Object.keys(chainTokens).length > 0) {
+                out.chainTokens =
+                    chainTokens;
+            }
+            if (Object.keys(chainTokenAmounts).length > 0) {
+                out.chainTokenAmounts =
+                    chainTokenAmounts;
+            }
+            return out;
         }
         return chainIds
             ? { chainIds, tokens: sourceAssets }
@@ -854,18 +880,18 @@ function createAccountAccessList(sourceChains, sourceAssets) {
     return { chainTokens: sourceAssets };
 }
 function getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSignature) {
-    const initCode = (0, accounts_1.getInitCode)(config);
+    const initCode = getInitCode(config);
     if (config.account?.type === 'eoa') {
         return {
             setupOps: [],
         };
     }
-    else if ((0, accounts_1.is7702)(config)) {
+    else if (is7702(config)) {
         // EIP-7702 initialization is only needed for EOA accounts
         if (!eip7702InitSignature || eip7702InitSignature === '0x') {
-            throw new error_1.Eip7702InitSignatureRequiredError();
+            throw new Eip7702InitSignatureRequiredError();
         }
-        const { initData: eip7702InitData, contract: eip7702Contract } = (0, accounts_1.getEip7702InitCall)(config, eip7702InitSignature);
+        const { initData: eip7702InitData, contract: eip7702Contract } = getEip7702InitCall(config, eip7702InitSignature);
         return {
             setupOps: [
                 {
@@ -891,7 +917,7 @@ function getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSig
                     setupOps: [],
                 };
             }
-            throw new accounts_1.FactoryArgsNotAvailableError();
+            throw new FactoryArgsNotAvailableError();
         }
         // Contract account with init code
         return {
@@ -913,12 +939,12 @@ function getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSig
 function validateTokenSymbols(chain, tokenAddressOrSymbols) {
     function validateTokenSymbol(chain, addressOrSymbol) {
         // Address
-        if ((0, viem_1.isAddress)(addressOrSymbol, { strict: false })) {
+        if (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 });
+        const address = getTokenAddress(addressOrSymbol, chain.id);
+        return isAddress(address, { strict: false });
     }
     for (const addressOrSymbol of tokenAddressOrSymbols) {
         if (!validateTokenSymbol(chain, addressOrSymbol)) {
@@ -930,7 +956,7 @@ function validateTokenSymbols(chain, tokenAddressOrSymbols) {
 // Uses a Solady-compatible TypedDataSign hash and wraps the signature with
 // the app domain separator and contents hash for on-chain verification.
 async function signErc7739TypedData(config, signers, validator, isRoot, parameters, chain) {
-    const verifierDomain = (0, accounts_1.getEip712Domain)(config, chain);
+    const verifierDomain = getEip712Domain(config, chain);
     const hash = hashErc7739TypedDataForSolady({
         domain: parameters.domain,
         types: parameters.types,
@@ -938,10 +964,10 @@ async function signErc7739TypedData(config, signers, validator, isRoot, paramete
         message: parameters.message,
         verifierDomain,
     });
-    return await (0, accounts_1.getEip1271Signature)(config, signers, chain, {
+    return await getEip1271Signature(config, signers, chain, {
         address: validator.address,
         isRoot,
-    }, hash, (signature) => (0, erc7739_1.wrapTypedDataSignature)({
+    }, hash, (signature) => wrapTypedDataSignature({
         domain: parameters.domain,
         primaryType: parameters.primaryType,
         types: parameters.types,
@@ -979,15 +1005,15 @@ function hashErc7739TypedDataForSolady({ domain, types, primaryType, message, ve
     // Construct TypedDataSign type string matching Solady's on-chain encoding:
     // TypedDataSign(<contentsName> contents,...salt) + contentsType
     const typedDataSignTypeString = `TypedDataSign(${contentsName} contents,string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)${contentsType}`;
-    const typedDataSignTypeHash = (0, viem_1.keccak256)((0, viem_1.toHex)(typedDataSignTypeString));
+    const typedDataSignTypeHash = keccak256(toHex(typedDataSignTypeString));
     // Hash the original content struct
-    const contentsHash = (0, viem_1.hashStruct)({
+    const contentsHash = hashStruct({
         data: message,
         primaryType,
         types: types,
     });
     // Compute the TypedDataSign struct hash
-    const structHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+    const structHash = keccak256(encodeAbiParameters([
         { type: 'bytes32' },
         { type: 'bytes32' },
         { type: 'bytes32' },
@@ -998,8 +1024,8 @@ function hashErc7739TypedDataForSolady({ domain, types, primaryType, message, ve
     ], [
         typedDataSignTypeHash,
         contentsHash,
-        (0, viem_1.keccak256)((0, viem_1.toHex)(verifierDomain.name)),
-        (0, viem_1.keccak256)((0, viem_1.toHex)(verifierDomain.version)),
+        keccak256(toHex(verifierDomain.name)),
+        keccak256(toHex(verifierDomain.version)),
         BigInt(verifierDomain.chainId),
         verifierDomain.verifyingContract,
         verifierDomain.salt,
@@ -1016,10 +1042,11 @@ function hashErc7739TypedDataForSolady({ domain, types, primaryType, message, ve
         domainTypes.push({ name: 'verifyingContract', type: 'address' });
     if (domain.salt)
         domainTypes.push({ name: 'salt', type: 'bytes32' });
-    const appDomainSeparator = (0, viem_1.hashDomain)({
+    const appDomainSeparator = hashDomain({
         domain,
         types: { EIP712Domain: domainTypes },
     });
     // Final hash: keccak256("\x19\x01" || appDomainSep || structHash)
-    return (0, viem_1.keccak256)((0, viem_1.concat)(['0x1901', appDomainSeparator, structHash]));
+    return keccak256(concat(['0x1901', appDomainSeparator, structHash]));
 }
+export { prepareTransaction, getTransactionMessages, signTransaction, signAuthorizations, signAuthorizationsInternal, signMessage, signTypedData, submitTransaction, prepareUserOperation, signUserOperation, submitUserOperation, signIntent, prepareTransactionAsIntent, submitIntentInternal, getValidatorAccount, parseCalls, getTokenRequests, resolveCallInputs, getIntentAccount, getTargetExecutionSignature, hashErc7739TypedDataForSolady, resolveSessionForChain, };