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

package/dist/src/execution/utils.js

@@ -6,18 +6,16 @@ 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 { buildPermit2ClaimPolicyCalldata, } from '../modules/validators/policies/claim/permit2.js';
+import { resolvePermit2ClaimPolicy, } from '../modules/validators/smart-sessions.js';
 import { getOrchestrator, } from '../orchestrator/index.js';
+import { getChainId, isNonEvmChain, } from '../orchestrator/destinations.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';
+import { Eip7702InitSignatureRequiredError, QuoteNotInPreparedTransactionError, SignerNotSupportedError, } from './error.js';
 function isResolvedSessionSignerSet(signers) {
     return (signers?.type === 'experimental_session' && 'verifyExecutions' in signers);
 }
@@ -28,8 +26,9 @@ async function resolveSignersForChain(config, signers, chainId) {
     const resolved = resolveSessionForChain(signers, chainId);
     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;
+    const verifyExecutions = resolved.verifyExecutions ??
+        signers.verifyExecutions ??
+        resolved.session.hasExplicitPermissions;
     return {
         type: 'experimental_session',
         session: resolved.session,
@@ -48,15 +47,29 @@ 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 { 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 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);
+    // Destination calls (transaction.calls on a cross-chain transaction) are
+    // executed on the destination chain by the solver/account. For non-EVM
+    // destinations we can't resolve arbitrary EVM calls; assert there are
+    // none and route an empty list through.
+    let resolvedCalls;
+    if (isNonEvmChain(targetChain)) {
+        if (transaction.calls && transaction.calls.length > 0) {
+            throw new Error(`Destination calls are not supported for non-EVM target chain ${targetChain.name} (${targetChain.caip2})`);
+        }
+        resolvedCalls = [];
+    }
+    else {
+        resolvedCalls = await resolveCallInputs(transaction.calls, config, targetChain, accountAddress);
+    }
+    const prepared = await prepareTransactionAsIntent(config, sourceChains, targetChain, resolvedCalls, transaction.gasLimit, tokenRequests, recipient, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, auxiliaryFunds, account, signers);
     return {
-        intentRoute: prepared.intentRoute,
+        quotes: prepared.quotes,
         intentInput: prepared.intentInput,
         transaction,
     };
@@ -93,19 +106,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,
@@ -113,13 +128,27 @@ 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;
+    }
+    // Target executions are EVM-only (smart-session validator on destination).
+    // Non-EVM destinations don't have a validator there to verify the sig.
+    if (isNonEvmChain(targetChain)) {
         return undefined;
     }
     const resolvedSigners = await resolveSignersForChain(config, signers, targetChain.id);
@@ -127,13 +156,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 = 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;
 }
@@ -151,7 +180,14 @@ 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);
@@ -239,19 +275,29 @@ async function signTypedDataWithSession(config, chain, validator, session, param
     });
     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 eip7702InitSignature = context.eip7702InitSignature;
+    if (!eip7702InitSignature) {
+        return [];
+    }
     const accountAddress = getAddress(config);
-    const requiredDelegations = 'intentOp' in data
-        ? data.intentOp.signedMetadata.account.requiredDelegations || {}
-        : {};
+    const { contract: eip7702Contract } = getEip7702InitCall(config, eip7702InitSignature);
+    // EIP-7702 authorization is EVM-only — there's no contract to delegate
+    // to on Solana / Tron. Skip the destination chain entirely when it's
+    // non-EVM; source chains are always EVM by construction.
+    const chains = new Map();
+    for (const chain of context.sourceChains ?? []) {
+        chains.set(chain.id, chain);
+    }
+    if (!isNonEvmChain(context.targetChain)) {
+        chains.set(context.targetChain.id, context.targetChain);
+    }
     const authorizations = [];
-    for (const chainId in requiredDelegations) {
-        const delegation = requiredDelegations[chainId];
-        const chain = getChainById(Number(chainId));
+    for (const chain of chains.values()) {
         const walletClient = createWalletClient({
             chain,
             account: eoa,
@@ -260,23 +306,22 @@ async function signAuthorizationsInternal(config, data) {
         const code = await walletClient.getCode({
             address: accountAddress,
         });
-        const isDelegated = code === 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;
@@ -296,7 +341,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;
@@ -312,15 +356,21 @@ function getTransactionParams(transaction) {
         settlementLayers,
         sourceAssets,
         feeAsset,
-        lockFunds,
         auxiliaryFunds,
         account,
         recipient,
     };
 }
 function getTokenRequests(targetChain, initialTokenRequests) {
-    if (initialTokenRequests) {
-        validateTokenSymbols(targetChain, initialTokenRequests.map((tokenRequest) => tokenRequest.address));
+    // Non-EVM destinations carry SPL mint / Tron T-prefixed addresses that
+    // aren't valid 0x-hex; skip symbol/EVM-address validation here and let
+    // the orchestrator validate per its own schema. EVM destinations keep
+    // the existing strict check so a typo on Optimism still fails fast.
+    if (initialTokenRequests && !isNonEvmChain(targetChain)) {
+        // Inside this branch targetChain is a viem `Chain`, which excludes the
+        // non-EVM transaction variant — token requests are EVM-typed here.
+        const evmRequests = initialTokenRequests;
+        validateTokenSymbols(targetChain, evmRequests.map((tokenRequest) => tokenRequest.address));
     }
     return initialTokenRequests ?? [];
 }
@@ -369,12 +419,19 @@ 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) {
-    const calls = parseCalls(callInputs, targetChain.id);
+async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipientInput, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, auxiliaryFunds, account, signers) {
+    const targetChainId = getChainId(targetChain);
+    const calls = parseCalls(callInputs, targetChainId);
     const accountAccessList = createAccountAccessList(sourceChains, sourceAssets);
     function getRecipient(recipient) {
         if (typeof recipient === 'string') {
-            // Passed as an address, assume it's an EOA
+            // Non-EVM recipients (Solana base58 / Tron T-prefix) carry no
+            // EVM smart-account semantics; orchestrator schema requires
+            // accountType / setupOps to be unset. Emit just the address.
+            if (isNonEvmChain(targetChain)) {
+                return { address: recipient };
+            }
+            // EVM passthrough — assume EOA.
             return {
                 address: recipient,
                 accountType: 'EOA',
@@ -390,13 +447,15 @@ 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: buildMockSignature(resolveSessionForChain(signers, targetChain.id).session, config.useDevContracts, sourceChains?.length ?? 1),
-            // Per-chain map: enables accurate per-chain session validation gas simulation
+            // Per-chain map: enables accurate per-chain session validation gas
+            // simulation. Non-EVM destinations are excluded — they have no
+            // destination-side session validator, so adding the synthetic chain
+            // id would force users to configure a session that's never used and
+            // make `resolveSessionForChain` throw for per-chain session signers.
             mockSignatures: Object.fromEntries([
                 ...new Set([
                     ...(sourceChains ?? []).map((c) => c.id),
-                    targetChain.id,
+                    ...(isNonEvmChain(targetChain) ? [] : [targetChainId]),
                 ]),
             ].map((chainId) => [
                 String(chainId),
@@ -435,9 +494,9 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
         }
     }
     const metaIntent = {
-        destinationChainId: targetChain.id,
+        destinationChainId: targetChainId,
         tokenRequests: tokenRequests.map((tokenRequest) => ({
-            tokenAddress: resolveTokenAddress(tokenRequest.address, targetChain.id),
+            tokenAddress: resolveTokenAddress(tokenRequest.address, targetChainId),
             amount: tokenRequest.amount,
         })),
         recipient,
@@ -446,19 +505,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,
@@ -469,11 +527,18 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
     };
     const serializedIntent = convertBigIntFields(metaIntent);
     const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
-    const intentRoute = await orchestrator.getIntentRoute(metaIntent);
-    return { intentRoute, intentInput: serializedIntent };
+    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) {
@@ -508,7 +573,14 @@ async function signIntent(config, intentOp, targetChain, signers, targetExecutio
         const signature = await signIntentTypedData(config, originSigners, validator, isRoot, typedData, chain, targetExecution ?? false);
         originSignatures.push(signature);
     }
-    const destinationSigners = await resolveSignersForChain(config, signers, targetChain.id);
+    // Non-EVM destinations have no destination-side validator, so there's no
+    // session to resolve and no signer to derive. Skipping here matters for
+    // per-chain experimental sessions: `resolveSessionForChain` would throw
+    // `No session configured for chain {synthetic-id}` since users never
+    // configure a session keyed by the synthetic Solana/Tron chain id.
+    const destinationSigners = isNonEvmChain(targetChain)
+        ? undefined
+        : await resolveSignersForChain(config, signers, targetChain.id);
     const destinationSignature = await getDestinationSignature(config, destinationSigners, validator, isRoot, targetChain, destination, originSignatures, targetExecution ?? false);
     return {
         originSignatures,
@@ -516,18 +588,25 @@ async function signIntent(config, intentOp, targetChain, signers, targetExecutio
     };
 }
 async function getDestinationSignature(config, signers, validator, isRoot, targetChain, destination, originSignatures, targetExecution) {
-    // Smart sessions require a separate destination signature because the
-    // session enable data differs per chain
-    if (signers?.type === 'experimental_session') {
-        return await signDestinationSeparately(config, signers, validator, isRoot, targetChain, destination, targetExecution);
-    }
-    // ERC-7739 with K1 validator requires a separate destination signature because
-    // 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() ===
-        K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
-    if (isK1Validator && supportsEip712(validator)) {
-        return await signDestinationSeparately(config, signers, validator, isRoot, targetChain, destination, targetExecution);
+    // Non-EVM destinations have no destination-side validator, no
+    // eip712Domain(), no smart session enable data. Settlement is solver-
+    // mediated on the orchestrator side and the origin signatures alone
+    // authorize the bundle. Fall through to the "reuse last origin sig"
+    // branch instead of trying to sign on Solana / Tron.
+    if (!isNonEvmChain(targetChain)) {
+        // Smart sessions require a separate destination signature because the
+        // session enable data differs per chain
+        if (signers?.type === 'experimental_session') {
+            return await signDestinationSeparately(config, signers, validator, isRoot, targetChain, destination, targetExecution);
+        }
+        // ERC-7739 with K1 validator requires a separate destination signature because
+        // 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() ===
+            K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+        if (isK1Validator && supportsEip712(validator)) {
+            return await signDestinationSeparately(config, signers, validator, isRoot, targetChain, destination, targetExecution);
+        }
     }
     const lastOriginSignature = originSignatures.at(-1);
     return typeof lastOriginSignature === 'object'
@@ -541,49 +620,62 @@ async function signDestinationSeparately(config, signers, validator, isRoot, tar
         ? destinationSignatures.preClaimSig
         : (destinationSignatures ?? '0x');
 }
-function getIntentMessages(config, intentOp) {
-    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 = getSingleChainOpsTypedData(address, intentExecutor.address, element, BigInt(intentOp.nonce));
-            origin.push(typedData);
-        }
-        else if (withPermit2) {
-            const typedData = getPermit2TypedData(element, BigInt(intentOp.nonce), BigInt(intentOp.expires));
-            origin.push(typedData);
-        }
-        else {
-            const typedData = 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 = getAddress(config);
-    const intentExecutor = getIntentExecutor(config);
-    const lastElement = intentOp.elements.at(-1);
-    const typedData = getSingleChainOpsTypedData(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) {
     if (parameters.primaryType !== 'PermitBatchWitnessTransferFrom' ||
-        !signers.session.claimPolicies?.length) {
+        !signers.session.claimPolicies.length) {
         return undefined;
     }
     const msg = parameters.message;
@@ -594,7 +686,7 @@ function resolveClaimPolicyData(signers, parameters) {
         typeof msg.deadline !== 'bigint') {
         return undefined;
     }
-    return buildPermit2ClaimPolicyCalldata(signers.session.claimPolicies[0], parameters.message);
+    return buildPermit2ClaimPolicyCalldata(resolvePermit2ClaimPolicy(signers.session.claimPolicies[0]), parameters.message);
 }
 async function signIntentTypedData(config, signers, validator, isRoot, parameters, chain, targetExecution) {
     if (supportsEip712(validator)) {
@@ -710,40 +802,39 @@ 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 = 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;
+    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,
+        targetChain: getChainId(targetChain),
+        expiresAt: quote.expiresAt,
     };
 }
 async function getValidatorAccount(config, signers, publicClient, chain) {
@@ -801,6 +892,8 @@ function getValidator(config, signers) {
     return undefined;
 }
 function parseCalls(calls, chainId) {
+    // Destination calls only run on EVM chains (non-EVM destinations reject
+    // calls upstream), so the resolved `to` is always a viem `Address` here.
     return calls.map((call) => ({
         data: call.data ?? '0x',
         value: call.value ?? 0n,
@@ -816,12 +909,34 @@ 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: 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;
+                // Source assets live on viem `Chain`s, which are always EVM, so the
+                // resolved value is a viem `Address`.
+                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 }