@rhinestone/sdk 1.4.2 → 2.0.0-beta.0

package/dist/src/execution/utils.js

@@ -1,45 +1,23 @@
-"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 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 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 { getIntentExecutor } from '../modules/index.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 { getCompactTypedData } from './compact.js';
+import { Eip7702InitSignatureRequiredError, SignerNotSupportedError, } from './error.js';
+import { getTypedData as getPermit2TypedData } from './permit2.js';
+import { getTypedData as getSingleChainOpsTypedData } from './singleChainOps.js';
 function isResolvedSessionSignerSet(signers) {
     return (signers?.type === 'experimental_session' && 'verifyExecutions' in signers);
 }
@@ -48,7 +26,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;
@@ -71,21 +49,22 @@ function resolveSessionForChain(signers, chainId) {
 }
 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 accountAddress = getAddress(config);
     const isUserOpSigner = signers?.type === 'guardians';
     if (isUserOpSigner) {
-        throw new error_1.SignerNotSupportedError();
+        throw new 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, 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, lockFunds, auxiliaryFunds, account, signers);
     return {
-        intentRoute,
+        intentRoute: prepared.intentRoute,
+        intentInput: prepared.intentInput,
         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,
@@ -127,6 +106,7 @@ async function signTransaction(config, preparedTransaction) {
     const targetExecutionSignature = await getTargetExecutionSignature(config, intentRoute.intentOp, targetChain, signers);
     return {
         intentRoute,
+        intentInput: preparedTransaction.intentInput,
         transaction: preparedTransaction.transaction,
         originSignatures,
         destinationSignature,
@@ -152,7 +132,7 @@ async function getTargetExecutionSignature(config, intentOp, targetChain, signer
     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 signature = await getDestinationSignature(config, resolvedSigners, validator, isRoot, targetChain, destination, [], true);
     return signature;
@@ -178,21 +158,21 @@ async function signMessage(config, message, chain, 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);
@@ -201,31 +181,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: {
@@ -248,39 +228,39 @@ 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) {
     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 accountAddress = 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)({
+        const chain = getChainById(Number(chainId));
+        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', delegation.contract.toLowerCase()]);
         if (isDelegated) {
             continue;
         }
@@ -293,10 +273,10 @@ async function signAuthorizationsInternal(config, data) {
     return authorizations;
 }
 async function submitTransaction(config, signedTransaction, authorizations, dryRun = false) {
-    const { intentRoute, transaction, originSignatures, destinationSignature, targetExecutionSignature, } = signedTransaction;
+    const { intentRoute, 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);
+    return await submitIntent(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput);
 }
 async function submitUserOperation(config, signedUserOperation) {
     const chain = signedUserOperation.transaction.chain;
@@ -345,15 +325,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,
@@ -362,10 +342,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',
         }),
     };
@@ -379,7 +359,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 {
@@ -410,13 +390,24 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
     const intentAccount = {
         ...getIntentAccount(config, eip7702InitSignature, account),
         ...(signers?.type === 'experimental_session' && {
-            mockSignature: (0, validators_1.buildMockSignature)(resolveSessionForChain(signers, targetChain.id).session, config.useDevContracts, sourceChains?.length),
+            // Global fallback: target-chain sig for backward-compat with older orchestrators
+            mockSignature: 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([
+                    ...(sourceChains ?? []).map((c) => c.id),
+                    targetChain.id,
+                ]),
+            ].map((chainId) => [
+                String(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
@@ -436,9 +427,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,
                 },
             ];
         }
@@ -446,7 +437,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,
@@ -476,16 +467,17 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
         },
         ...(Object.keys(preClaimExecutions).length > 0 && { preClaimExecutions }),
     };
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(config.apiKey, config.endpointUrl, config.headers);
+    const serializedIntent = convertBigIntFields(metaIntent);
+    const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
     const intentRoute = await orchestrator.getIntentRoute(metaIntent);
-    return intentRoute;
+    return { intentRoute, intentInput: serializedIntent };
 }
 async function signIntent(config, intentOp, targetChain, signers, targetExecution) {
     const { origin, destination } = getIntentMessages(config, intentOp);
     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) {
@@ -494,7 +486,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);
@@ -507,11 +499,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);
@@ -533,8 +525,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);
@@ -543,30 +535,30 @@ 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 address = getAddress(config);
+    const intentExecutor = 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));
+            const typedData = getSingleChainOpsTypedData(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));
+            const typedData = getPermit2TypedData(element, BigInt(intentOp.nonce), BigInt(intentOp.expires));
             origin.push(typedData);
         }
         else {
-            const typedData = (0, compact_1.getCompactTypedData)(intentOp);
+            const typedData = getCompactTypedData(intentOp);
             origin.push(typedData);
         }
     }
@@ -577,10 +569,10 @@ function getIntentMessages(config, intentOp) {
     };
 }
 function getTargetExecutionMessage(config, intentOp) {
-    const address = (0, accounts_1.getAddress)(config);
-    const intentExecutor = (0, modules_1.getIntentExecutor)(config);
+    const address = getAddress(config);
+    const intentExecutor = getIntentExecutor(config);
     const lastElement = intentOp.elements.at(-1);
-    const typedData = (0, singleChainOps_1.getTypedData)(address, intentExecutor.address, lastElement, BigInt(intentOp.targetExecutionNonce));
+    const typedData = getSingleChainOpsTypedData(address, intentExecutor.address, lastElement, BigInt(intentOp.targetExecutionNonce));
     typedData.message.gasRefund = typedData.message.gasRefund ?? {
         token: '0x0000000000000000000000000000000000000000',
         exchangeRate: 0n,
@@ -602,21 +594,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 = {
@@ -627,7 +619,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 = {
@@ -637,11 +629,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,
@@ -654,12 +646,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);
@@ -669,9 +661,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) {
@@ -680,36 +672,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 {
@@ -718,8 +710,8 @@ async function submitUserOp(config, chain, userOp, signature) {
         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);
+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 {
@@ -739,29 +731,33 @@ function createSignedIntentOp(intentOp, originSignatures, destinationSignature,
             : undefined,
     };
 }
-async function submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun) {
+async function submitIntentInternal(config, sourceChains, targetChain, intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, dryRun, intentInput) {
     const signedIntentOp = createSignedIntentOp(intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations);
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(config.apiKey, config.endpointUrl, config.headers);
-    const intentResults = await orchestrator.submitIntent(signedIntentOp, dryRun);
+    const isSponsored = !!intentInput?.options?.sponsorSettings;
+    const orchestrator = getOrchestrator(config._authProvider ?? 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;
     return {
         type: 'intent',
-        id: BigInt(intentResults.result.id),
+        id: BigInt(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,
         })
@@ -769,7 +765,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;
@@ -777,29 +773,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;
@@ -808,7 +804,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) {
@@ -822,7 +818,7 @@ function createAccountAccessList(sourceChains, sourceAssets) {
         if (isExactConfig) {
             const resolvedConfigs = sourceAssets.map((config) => ({
                 chainId: config.chain.id,
-                tokenAddress: (0, registry_1.resolveTokenAddress)(config.address, config.chain.id),
+                tokenAddress: resolveTokenAddress(config.address, config.chain.id),
                 amount: config.amount,
             }));
             return resolvedConfigs;
@@ -834,18 +830,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: [
                 {
@@ -871,7 +867,7 @@ function getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSig
                     setupOps: [],
                 };
             }
-            throw new accounts_1.FactoryArgsNotAvailableError();
+            throw new FactoryArgsNotAvailableError();
         }
         // Contract account with init code
         return {
@@ -893,12 +889,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)) {
@@ -910,7 +906,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,
@@ -918,10 +914,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,
@@ -959,15 +955,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' },
@@ -978,8 +974,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,
@@ -996,10 +992,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, };