@rhinestone/sdk 0.0.0-dev-20260917224650 → 0.0.0-dev-20260921165705

package/dist/src/api/account.js

@@ -1,45 +1,25 @@
-import { isAddress } from 'viem';
-import { asSwigNamespace, locateSwig } from '../accounts/solana/address.js';
-import { formatCaip2, parseCaip2, toEvmChainReference } from '../chains/caip2.js';
+import { parseCaip2, toEvmChainReference } from '../chains/caip2.js';
 import { getChainById, getChainReference } from '../chains/catalog.js';
-import { solanaAddress, } from '../chains/non-evm.js';
 import { normalizeTokenAddress, validateTokenAddresses } from '../chains/tokens.js';
 import { createStaticAccountRuntime } from '../config/account-runtime.js';
 import { materializeAccountInvocationContext, resolveAccountConfig, } from '../config/resolve.js';
-import { AccountVmNotConfiguredError, ManagedSolanaAccountNotSupportedError, UnsupportedAccountCapabilityError, } from '../errors/capability.js';
-import { IndependentSigningNotSupportedError, InvalidSolanaTransactionArtifactError, MismatchedOwnerSignaturesError, QuoteNotInPreparedTransactionError, } from '../errors/execution.js';
+import { IndependentSigningNotSupportedError, MismatchedOwnerSignaturesError, QuoteNotInPreparedTransactionError, } from '../errors/execution.js';
 import { resolveHyperCoreAction } from '../hypercore/resolve.js';
 import { ecdsaSignerId, webauthnSignerId, } from '../modules/validators/signer-id.js';
 import { projectIntentAccount, projectIntentRecipient, } from '../transactions/intents/account.js';
 import { projectCompatibleIntentInput, projectCompatibleQuote, } from '../transactions/intents/compatibility.js';
 import { normalizeIntentQuote } from '../transactions/intents/normalize.js';
-import { solanaChainId, } from '../transactions/intents/solana.js';
-import { normalizeSolanaAddressLookupTables, normalizeSolanaInstructions, } from '../transactions/intents/solana-instructions.js';
 import { adaptSignerSelection, adaptUserOperationSignerSelection, } from './signer-selection.js';
-function cloneArtifactValue(value) {
-    if (Array.isArray(value)) {
-        return value.map(cloneArtifactValue);
-    }
-    if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-            key,
-            cloneArtifactValue(item),
-        ]));
-    }
-    return value;
-}
 function toPublicQuote(quote) {
     const compatible = projectCompatibleQuote(quote);
-    return cloneArtifactValue({
+    return {
         intentId: compatible.intentId,
         expiresAt: compatible.expiresAt,
         estimatedFillTime: compatible.estimatedFillTime,
         settlementLayer: compatible.settlementLayer,
         signData: {
             origin: [...compatible.signData.origin],
-            ...(compatible.signData.destination
-                ? { destination: compatible.signData.destination }
-                : {}),
+            destination: compatible.signData.destination,
             ...(compatible.signData.targetExecution
                 ? { targetExecution: compatible.signData.targetExecution }
                 : {}),
@@ -49,7 +29,7 @@ function toPublicQuote(quote) {
             ? { tokenRequirements: compatible.tokenRequirements }
             : {}),
         ...(compatible.bridgeFill ? { bridgeFill: compatible.bridgeFill } : {}),
-    });
+    };
 }
 function toPreparedTransactionData(prepared, transaction, cache) {
     const data = {
@@ -64,51 +44,6 @@ function toPreparedTransactionData(prepared, transaction, cache) {
     cache.set(data, prepared);
     return data;
 }
-function solanaMetadata(input) {
-    const binding = {
-        namespace: input.namespace,
-        endpoint: input.endpoint,
-        chain: solanaChainId(input.chain),
-        caip2: input.chain.caip2,
-        accountAddress: input.accountAddress,
-        accountType: input.accountType,
-        authority: input.authority,
-        swigAddress: input.swigAddress,
-        walletAddress: input.walletAddress,
-    };
-    const action = input.action;
-    if (action.kind === 'instructions') {
-        return { kind: 'solana-instructions', ...binding };
-    }
-    const delivery = action.delivery;
-    return delivery.kind === 'cross-chain'
-        ? {
-            kind: 'solana-cross-chain',
-            ...binding,
-            mint: action.mint,
-            destinationChain: delivery.chainId,
-            destinationToken: delivery.token,
-            recipient: delivery.recipient,
-        }
-        : {
-            kind: 'solana',
-            ...binding,
-            mint: action.mint,
-            recipient: delivery.recipient,
-        };
-}
-function toPreparedSolanaTransactionData(prepared, transaction) {
-    return {
-        quotes: {
-            traceId: prepared.traceId,
-            best: toPublicQuote(prepared.quote),
-            all: prepared.quotes.map(toPublicQuote),
-        },
-        execution: solanaMetadata(prepared.input),
-        intentInput: projectCompatibleIntentInput(prepared.request),
-        transaction,
-    };
-}
 function selectedPublicQuote(prepared, intentId) {
     if (!intentId)
         return prepared.quotes.best;
@@ -129,9 +64,8 @@ function reconstructInput(context, prepared, intentId) {
             : normalizeIntentQuote(candidate)),
         // The public prepared data only carries the serialized request, so the
         // reconstructed request holds decimal strings where the internal type
-        // declares bigints. Sound because submission only re-serializes it (a no-op
-        // on strings, keeping the sponsorship digest stable) and reads
-        // `options.sponsorSettings`.
+        // declares bigints. Sound because nothing after preparation reads it: the
+        // sponsorship digest was taken at quote time.
         request: prepared.intentInput,
         intentInput: adaptTransaction(context, prepared.transaction),
     };
@@ -141,12 +75,8 @@ function toSignedTransactionData(prepared, signed, cache) {
         ...prepared,
         quote: toPublicQuote(signed.prepared.quote),
         originSignatures: signed.originSignatures,
-        ...(signed.destinationSignature
-            ? { destinationSignature: signed.destinationSignature }
-            : {}),
-        ...(signed.targetSignature
-            ? { targetExecutionSignature: signed.targetSignature }
-            : {}),
+        destinationSignature: signed.destinationSignature,
+        targetExecutionSignature: signed.targetSignature,
     };
     cache.set(data, signed);
     return data;
@@ -156,143 +86,21 @@ function referenceChain() {
     // needs some EVM chain reference. With no bundled chain set, use mainnet.
     return toEvmChainReference(1);
 }
-export function createAccountFacade(compatibilityConfig, publicConfig, composition) {
+export function createAccountFacade(compatibilityConfig, composition) {
     // Intent identity caches are facade-scoped. Values crossing account/SDK
     // instances are reconstructed and validated by the receiving account.
     const preparedIntents = new WeakMap();
     const signedIntents = new WeakMap();
     const context = (method) => materializeAccountInvocationContext(composition.config, compatibilityConfig, method);
     const workflowsFor = (ctx) => composition.createAccount(ctx).workflows;
-    const hasManagedSolana = Boolean(publicConfig.solana && 'owner' in publicConfig.solana);
-    const capturedSolanaContext = hasManagedSolana
-        ? context('get-address')
-        : undefined;
-    const capturedSolanaIdentity = capturedSolanaContext
-        ? workflowsFor(capturedSolanaContext).getAddress(capturedSolanaContext, referenceChain())
-        : undefined;
-    const capturedSolanaEndpoint = capturedSolanaContext?.sdk.orchestratorUrl;
-    const capturedSolanaAccountType = capturedSolanaContext
-        ? capturedSolanaContext.account.account.kind === 'eoa'
-            ? 'EOA'
-            : capturedSolanaContext.account.account.kind === 'hca'
-                ? 'GENERIC'
-                : 'ERC7579'
-        : undefined;
-    const solanaOwner = () => {
-        const branch = publicConfig.solana;
-        if (!branch || !('owner' in branch) || !branch.owner) {
-            throw new UnsupportedAccountCapabilityError('A managed Solana source is not configured on this account.', { vm: 'solana' });
-        }
-        return branch.owner.account;
-    };
-    const solanaTransfer = (ctx, transaction) => {
-        assertSupportedTransaction(transaction, publicConfig);
-        if (ctx.sdk.environment !== 'development' ||
-            ctx.sdk.orchestratorUrl !== capturedSolanaEndpoint) {
-            throw new ManagedSolanaAccountNotSupportedError('Managed Solana execution remains bound to the development environment and endpoint captured when the account was created.');
-        }
-        if (!isSolanaOrigin(transaction)) {
-            throw new InvalidSolanaTransactionArtifactError('the transaction is not a Solana-origin transfer');
-        }
-        const accountAddress = capturedSolanaIdentity;
-        if (!accountAddress || !capturedSolanaAccountType) {
-            throw new UnsupportedAccountCapabilityError('A managed Solana source is not configured on this account.', { vm: 'solana' });
-        }
-        const location = locateSwig(asSwigNamespace('dev-v1'), accountAddress);
-        const common = {
-            accountAddress,
-            accountType: capturedSolanaAccountType,
-            authority: solanaOwner().address,
-            walletAddress: location.wallet,
-            swigAddress: location.swig,
-            namespace: 'dev-v1',
-            endpoint: ctx.sdk.orchestratorUrl,
-            ...(transaction.appFees ? { appFees: transaction.appFees } : {}),
-            ...(transaction.protocolFees
-                ? { protocolFees: transaction.protocolFees }
-                : {}),
-            ...(() => {
-                const sponsorSettings = toSponsorSettings(transaction.sponsored);
-                return sponsorSettings ? { sponsorSettings } : {};
-            })(),
-        };
-        if (isCrossChainSolanaOrigin(transaction)) {
-            return {
-                ...common,
-                chain: transaction.sourceChains[0],
-                action: {
-                    kind: 'transfer',
-                    mint: transaction.sourceTokens[0].address,
-                    ...(transaction.tokenRequests[0].amount === undefined
-                        ? {}
-                        : { amount: transaction.tokenRequests[0].amount }),
-                    delivery: {
-                        kind: 'cross-chain',
-                        chainId: transaction.targetChain.id,
-                        token: transaction.tokenRequests[0].address,
-                        // Resolved here rather than in `normalizeTransaction` so the
-                        // prepare and reconstruct paths agree on the same recipient.
-                        recipient: transaction.recipient ?? accountAddress,
-                    },
-                },
-            };
-        }
-        if (isSolanaInstructionExecution(transaction)) {
-            return {
-                ...common,
-                chain: transaction.chain,
-                action: {
-                    kind: 'instructions',
-                    instructions: normalizeSolanaInstructions(transaction.instructions),
-                    ...(transaction.addressLookupTables
-                        ? { addressLookupTables: transaction.addressLookupTables }
-                        : {}),
-                },
-            };
-        }
-        return {
-            ...common,
-            chain: transaction.chain,
-            action: {
-                kind: 'transfer',
-                mint: transaction.tokenRequests[0].address,
-                ...(transaction.tokenRequests[0].amount === undefined
-                    ? {}
-                    : { amount: transaction.tokenRequests[0].amount }),
-                delivery: { kind: 'same-chain', recipient: transaction.recipient },
-            },
-        };
-    };
-    const assertSolanaMetadata = (actual, expected) => {
-        const expectedEntries = Object.entries(solanaMetadata(expected));
-        if (!actual ||
-            Object.keys(actual).length !== expectedEntries.length ||
-            expectedEntries.some(([key, value]) => actual[key] !== value)) {
-            throw new InvalidSolanaTransactionArtifactError('the execution binding does not match this account, environment, chain, recipient, or mint');
-        }
-    };
-    const resolveSolanaPrepared = (ctx, prepared, intentId, explicitQuote) => {
-        const transfer = solanaTransfer(ctx, prepared.transaction);
-        assertSolanaMetadata(prepared.execution, transfer);
-        const quote = explicitQuote ?? selectedPublicQuote(prepared, intentId);
-        return workflowsFor(ctx).reconstructSolanaIntent({
-            traceId: prepared.quotes.traceId,
-            transfer,
-            intentInput: prepared.intentInput,
-            quote: normalizeIntentQuote(quote),
-            quotes: prepared.quotes.all.map((candidate) => normalizeIntentQuote(candidate)),
-        });
-    };
     const resolvePrepared = (ctx, prepared, intentId) => {
-        assertSupportedTransaction(prepared.transaction, publicConfig);
-        assertSupportedSignData(selectedPublicQuote(prepared, intentId).signData);
         const cached = preparedIntents.get(prepared);
         if (cached && !intentId)
             return Promise.resolve(cached);
         return workflowsFor(ctx).reconstructPreparedIntent(ctx, reconstructInput(ctx, prepared, intentId));
     };
     const account = {
-        config: publicConfig,
+        config: compatibilityConfig,
         deploy(chain, params) {
             const ctx = context('deploy');
             return workflowsFor(ctx).deploy(ctx, toEvmChainReference(chain.id), {
@@ -320,106 +128,49 @@ export function createAccountFacade(compatibilityConfig, publicConfig, compositi
         },
         async prepareTransaction(transaction) {
             const ctx = context('prepare-intent');
-            const initiallyNormalized = normalizeTransaction(transaction, publicConfig);
-            const normalized = 'targetChain' in initiallyNormalized &&
-                initiallyNormalized.targetChain !== undefined &&
-                'kind' in initiallyNormalized.targetChain &&
-                initiallyNormalized.targetChain.kind === 'svm' &&
-                initiallyNormalized.recipient === undefined &&
-                capturedSolanaIdentity
-                ? Object.freeze({
-                    ...initiallyNormalized,
-                    recipient: locateSwig(asSwigNamespace('dev-v1'), capturedSolanaIdentity).wallet,
-                })
-                : initiallyNormalized;
-            if (isSolanaOrigin(normalized)) {
-                const prepared = await workflowsFor(ctx).prepareSolanaIntent(solanaTransfer(ctx, normalized));
-                return toPreparedSolanaTransactionData(prepared, normalized);
-            }
             // Before the quote, not after: the quote's `signData` registers an agent
             // derived from the action's bytes, so the action has to be concrete here.
             const hyperCoreAction = await resolveHyperCoreAction({
-                options: normalized.hyperCore,
-                account: workflowsFor(ctx).getAddress(ctx, referenceChain()),
+                options: transaction.hyperCore,
+                account: account.getAddress(),
                 ...(ctx.sdk.hyperliquid ? { hyperliquid: ctx.sdk.hyperliquid } : {}),
             });
-            const automaticSources = 'targetChain' in normalized &&
-                normalized.targetChain !== undefined &&
-                normalized.sourceChains === undefined
-                ? await workflowsFor(ctx).getEligibleEvmSourceChains(destinationChainReference(normalized.targetChain))
-                : undefined;
-            if (automaticSources && automaticSources.length === 0) {
-                throw new UnsupportedAccountCapabilityError('No managed EVM source chains are eligible for this destination.');
-            }
-            const prepared = await workflowsFor(ctx).prepareIntent(ctx, adaptTransaction(ctx, normalized, hyperCoreAction, automaticSources?.map(({ id }) => id)));
-            return toPreparedTransactionData(prepared, normalized, preparedIntents);
+            const prepared = await workflowsFor(ctx).prepareIntent(ctx, adaptTransaction(ctx, transaction, hyperCoreAction));
+            return toPreparedTransactionData(prepared, transaction, preparedIntents);
         },
         getTransactionMessages(preparedTransaction, options) {
-            assertSupportedTransaction(preparedTransaction.transaction, publicConfig);
             const quote = selectedPublicQuote(preparedTransaction, options?.intentId);
-            if (!isSolanaOrigin(preparedTransaction.transaction)) {
-                assertSupportedSignData(quote.signData);
-            }
-            else {
-                const ctx = context('get-intent-messages');
-                resolveSolanaPrepared(ctx, preparedTransaction, options?.intentId);
-            }
             return {
                 origin: [...quote.signData.origin],
-                ...(quote.signData.destination
-                    ? { destination: quote.signData.destination }
-                    : {}),
+                destination: quote.signData.destination,
                 ...(quote.signData.targetExecution
                     ? { targetExecution: quote.signData.targetExecution }
                     : {}),
             };
         },
-        signTransaction: (async (preparedTransaction, options) => {
+        signTransaction: ((preparedTransaction, options) => {
             const ctx = context('sign-intent');
             const workflows = workflowsFor(ctx);
-            if (isSolanaOrigin(preparedTransaction.transaction)) {
-                if (options && 'owner' in options) {
-                    throw new IndependentSigningNotSupportedError({
-                        context: { vm: 'solana' },
-                    });
-                }
-                const prepared = resolveSolanaPrepared(ctx, preparedTransaction, options?.intentId);
-                const signed = await workflows.signSolanaIntent({
-                    prepared,
-                    owner: solanaOwner(),
-                });
-                return {
-                    ...preparedTransaction,
-                    quote: toPublicQuote(signed.prepared.quote),
-                    originSignatures: [signed.signature],
-                };
-            }
             if (options && 'owner' in options) {
                 // Independent owner signing is unsupported for smart-session intents;
                 // reject before resolving sessions (which would issue an RPC read),
                 // matching the legacy fast-fail.
                 if (preparedTransaction.transaction.signers?.type === 'session') {
-                    throw new IndependentSigningNotSupportedError();
+                    return Promise.reject(new IndependentSigningNotSupportedError());
                 }
                 const signerId = signerIdForOwner(options.owner);
-                const internal = await resolvePrepared(ctx, preparedTransaction, options.intentId);
-                return workflows.signIntentAsOwner(ctx, internal, {
+                return resolvePrepared(ctx, preparedTransaction, options.intentId).then((internal) => workflows.signIntentAsOwner(ctx, internal, {
                     signerId,
                     ...(options.validatorId === undefined
                         ? {}
                         : { validatorId: options.validatorId }),
-                });
+                }));
             }
-            const internal = await resolvePrepared(ctx, preparedTransaction, options?.intentId);
-            const { intent } = await workflows.signIntent(ctx, internal);
-            return toSignedTransactionData(preparedTransaction, intent, signedIntents);
+            return resolvePrepared(ctx, preparedTransaction, options?.intentId)
+                .then((internal) => workflows.signIntent(ctx, internal))
+                .then(({ intent }) => toSignedTransactionData(preparedTransaction, intent, signedIntents));
         }),
         async assembleTransaction(preparedTransaction, signatures) {
-            if (isSolanaOrigin(preparedTransaction.transaction)) {
-                throw new IndependentSigningNotSupportedError({
-                    context: { vm: 'solana' },
-                });
-            }
             const ctx = context('assemble-intent');
             const workflows = workflowsFor(ctx);
             const intentIds = [...new Set(signatures.map(({ intentId }) => intentId))];
@@ -431,10 +182,6 @@ export function createAccountFacade(compatibilityConfig, publicConfig, compositi
             return toSignedTransactionData(preparedTransaction, signed, signedIntents);
         },
         async signAuthorizations(preparedTransaction) {
-            assertSupportedTransaction(preparedTransaction.transaction, publicConfig);
-            if (isSolanaOrigin(preparedTransaction.transaction)) {
-                throw new UnsupportedAccountCapabilityError('EIP-7702 authorizations are unavailable for Solana-origin transactions.', { vm: 'solana' });
-            }
             const ctx = context('sign-authorizations');
             const intentInput = adaptTransaction(ctx, preparedTransaction.transaction);
             const chains = authorizationChains(intentInput);
@@ -469,7 +216,6 @@ export function createAccountFacade(compatibilityConfig, publicConfig, compositi
             return result.signature;
         },
         async signIntent(signData, targetChain, signers) {
-            assertSupportedSignData(signData);
             const ctx = context('sign-intent');
             const result = await workflowsFor(ctx).signIntentFromSignData(ctx, {
                 signData: {
@@ -491,35 +237,8 @@ export function createAccountFacade(compatibilityConfig, publicConfig, compositi
             };
         },
         async submitTransaction(signedTransaction, options) {
-            assertSupportedTransaction(signedTransaction.transaction, publicConfig);
             const ctx = context('submit-intent');
             const workflows = workflowsFor(ctx);
-            if (isSolanaOrigin(signedTransaction.transaction)) {
-                if (options && Object.keys(options).length > 0) {
-                    throw new UnsupportedAccountCapabilityError('Solana submission does not accept EVM authorizations or dry-run options.', { vm: 'solana' });
-                }
-                if (signedTransaction.originSignatures.length !== 1 ||
-                    typeof signedTransaction.originSignatures[0] !== 'string' ||
-                    signedTransaction.destinationSignature !== undefined ||
-                    signedTransaction.targetExecutionSignature !== undefined) {
-                    throw new InvalidSolanaTransactionArtifactError('submission requires exactly one raw origin signature and no destination or target signature', { intentId: signedTransaction.quote.intentId });
-                }
-                const prepared = resolveSolanaPrepared(ctx, signedTransaction, signedTransaction.quote.intentId, signedTransaction.quote);
-                const submitted = await workflows.submitSolanaIntent({
-                    prepared,
-                    signature: signedTransaction.originSignatures[0],
-                });
-                return {
-                    type: 'intent',
-                    id: submitted.intentId,
-                    traceId: submitted.traceId,
-                    ...(submitted.sourceChains
-                        ? { sourceChains: [...submitted.sourceChains] }
-                        : {}),
-                    targetChain: submitted.targetChain,
-                };
-            }
-            assertSupportedSignData(signedTransaction.quote.signData);
             // Fast path for the same-instance signed object; otherwise (cross-instance
             // replay or caller-tampered signatures) rebuild from the public shape.
             const cached = signedIntents.get(signedTransaction);
@@ -641,25 +360,10 @@ export function createAccountFacade(compatibilityConfig, publicConfig, compositi
             })
                 .then((status) => status.receipt);
         }),
-        getAddress: ((vm) => {
-            if (vm === 'solana') {
-                if (publicConfig.solana &&
-                    'address' in publicConfig.solana &&
-                    publicConfig.solana.address) {
-                    return publicConfig.solana.address;
-                }
-                if (capturedSolanaIdentity) {
-                    return locateSwig(asSwigNamespace('dev-v1'), capturedSolanaIdentity)
-                        .wallet;
-                }
-                throw new AccountVmNotConfiguredError('solana');
-            }
-            if (vm !== 'evm' || !publicConfig.evm) {
-                throw new AccountVmNotConfiguredError(String(vm));
-            }
+        getAddress() {
             const ctx = context('get-address');
             return workflowsFor(ctx).getAddress(ctx, referenceChain());
-        }),
+        },
         getPortfolio(onTestnets = false) {
             const ctx = context('get-portfolio');
             return workflowsFor(ctx)
@@ -828,369 +532,6 @@ chainIds) {
  * authorise. With no session scope there is nothing to narrow against and the
  * explicit filter stands on its own.
  */
-function assertSupportedSignData(signData) {
-    const payloads = [
-        ...signData.origin,
-        signData.destination,
-        ...(signData.targetExecution ? [signData.targetExecution] : []),
-    ];
-    for (const payload of payloads) {
-        if (!payload ||
-            typeof payload !== 'object' ||
-            (payload.kind !== undefined &&
-                payload.kind !== 'eip712') ||
-            typeof payload.primaryType !== 'string' ||
-            !payload.domain ||
-            typeof payload.types !== 'object' ||
-            typeof payload.message !== 'object') {
-            throw new UnsupportedAccountCapabilityError('Only EIP-712 intent signing data is supported by this account.', { capability: 'intent-signing' });
-        }
-    }
-}
-function isSameChainSolanaOrigin(transaction) {
-    return ('chain' in transaction &&
-        typeof transaction.chain === 'object' &&
-        transaction.chain !== null &&
-        'kind' in transaction.chain &&
-        transaction.chain.kind === 'svm');
-}
-function isCrossChainSolanaOrigin(transaction) {
-    const source = transaction
-        .sourceChains?.[0];
-    return (typeof source === 'object' &&
-        source !== null &&
-        'kind' in source &&
-        source.kind === 'svm');
-}
-function isSolanaInstructionExecution(transaction) {
-    return (isSameChainSolanaOrigin(transaction) &&
-        transaction.instructions !== undefined);
-}
-function isSolanaOrigin(transaction) {
-    return (isSameChainSolanaOrigin(transaction) ||
-        isCrossChainSolanaOrigin(transaction));
-}
-function assertSolanaObjectKeys(value, allowed, label) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new UnsupportedAccountCapabilityError(`Managed Solana ${label} must be an object.`, { vm: 'solana', field: label });
-    }
-    const unsupported = Object.keys(value).find((key) => !allowed.includes(key));
-    if (unsupported) {
-        throw new UnsupportedAccountCapabilityError(`Solana-origin transfers do not support \`${label}.${unsupported}\`.`, { vm: 'solana', field: `${label}.${unsupported}` });
-    }
-}
-function assertSupportedSolanaTransaction(input, config) {
-    const runsInstructions = input.instructions !== undefined;
-    const allowed = new Set(runsInstructions
-        ? ['chain', 'instructions', 'addressLookupTables', 'sponsored']
-        : [
-            'chain',
-            'tokenRequests',
-            'recipient',
-            'sponsored',
-            'appFees',
-            'protocolFees',
-        ]);
-    const unsupported = Object.keys(input).find((key) => !allowed.has(key));
-    if (unsupported) {
-        throw new UnsupportedAccountCapabilityError(`Solana-origin transfers do not support \`${unsupported}\`.`, { vm: 'solana', field: unsupported });
-    }
-    if (!config.solana || !('owner' in config.solana)) {
-        throw new UnsupportedAccountCapabilityError('A managed Solana source is required for Solana-origin transfers.', { vm: 'solana' });
-    }
-    solanaChainId(input.chain);
-    if (runsInstructions) {
-        // Shape and limits are enforced by the normalizer, which also produces the
-        // canonical form `normalizeTransaction` stores.
-        normalizeSolanaInstructions(input.instructions);
-        normalizeSolanaAddressLookupTables(input.addressLookupTables);
-        return;
-    }
-    if (!Array.isArray(input.tokenRequests) || input.tokenRequests.length !== 1) {
-        throw new UnsupportedAccountCapabilityError('Managed Solana transfers require exactly one SPL token request.', { vm: 'solana' });
-    }
-    const request = input.tokenRequests[0];
-    assertSolanaObjectKeys(request, ['address', 'amount'], 'tokenRequests[0]');
-    if (typeof request.address !== 'string') {
-        throw new UnsupportedAccountCapabilityError('Managed Solana transfers require one valid SPL mint address.', { vm: 'solana' });
-    }
-    try {
-        solanaAddress(request.address);
-    }
-    catch {
-        throw new UnsupportedAccountCapabilityError('Managed Solana transfers require one valid SPL mint address.', { vm: 'solana' });
-    }
-    if (request.amount !== undefined &&
-        (typeof request.amount !== 'bigint' || request.amount <= 0n)) {
-        throw new UnsupportedAccountCapabilityError('A Solana token amount must be a positive bigint when provided.', { vm: 'solana' });
-    }
-    if (input.appFees !== undefined) {
-        assertSolanaObjectKeys(input.appFees, ['feeBps'], 'appFees');
-    }
-    if (input.protocolFees !== undefined) {
-        assertSolanaObjectKeys(input.protocolFees, ['feeBps'], 'protocolFees');
-    }
-    if (typeof input.recipient !== 'string') {
-        throw new UnsupportedAccountCapabilityError('Managed Solana transfers require an explicit recipient wallet.', { vm: 'solana' });
-    }
-    try {
-        solanaAddress(input.recipient);
-    }
-    catch {
-        throw new UnsupportedAccountCapabilityError('Managed Solana transfers require a valid recipient wallet.', { vm: 'solana' });
-    }
-}
-function assertSupportedSolanaOriginDelivery(input, config) {
-    const allowed = new Set([
-        'sourceChains',
-        'sourceTokens',
-        'targetChain',
-        'tokenRequests',
-        'recipient',
-        'sponsored',
-        'appFees',
-        'protocolFees',
-    ]);
-    const unsupported = Object.keys(input).find((key) => !allowed.has(key));
-    if (unsupported) {
-        throw new UnsupportedAccountCapabilityError(`Solana-origin transfers do not support \`${unsupported}\`.`, { vm: 'solana', field: unsupported });
-    }
-    if (!config.solana || !('owner' in config.solana)) {
-        throw new UnsupportedAccountCapabilityError('A managed Solana source is required for Solana-origin transfers.', { vm: 'solana' });
-    }
-    const sources = input.sourceChains;
-    if (sources.length !== 1) {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery spends exactly one Solana cluster.', { vm: 'solana', field: 'sourceChains' });
-    }
-    solanaChainId(sources[0]);
-    if (!Array.isArray(input.sourceTokens) || input.sourceTokens.length !== 1) {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery requires exactly one source SPL mint.', { vm: 'solana', field: 'sourceTokens' });
-    }
-    const sourceToken = input.sourceTokens[0];
-    assertSolanaObjectKeys(sourceToken, ['address'], 'sourceTokens[0]');
-    try {
-        solanaAddress(sourceToken.address);
-    }
-    catch {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery requires one valid SPL mint address.', { vm: 'solana', field: 'sourceTokens[0].address' });
-    }
-    const target = input.targetChain;
-    if (!target ||
-        typeof target !== 'object' ||
-        'kind' in target ||
-        'caip2' in target ||
-        typeof target.id !== 'number' ||
-        !Number.isSafeInteger(target.id) ||
-        target.id < 0 ||
-        !formatCaip2(target.id).startsWith('eip155:')) {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery requires a viem EVM destination chain.', { vm: 'solana', field: 'targetChain' });
-    }
-    if (!Array.isArray(input.tokenRequests) || input.tokenRequests.length !== 1) {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery requires exactly one destination token request.', { vm: 'solana', field: 'tokenRequests' });
-    }
-    const request = input.tokenRequests[0];
-    assertSolanaObjectKeys(request, ['address', 'amount'], 'tokenRequests[0]');
-    if (typeof request.address !== 'string' || !isAddress(request.address)) {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery requires an EVM destination token address.', { vm: 'solana', field: 'tokenRequests[0].address' });
-    }
-    if (request.amount !== undefined &&
-        (typeof request.amount !== 'bigint' || request.amount <= 0n)) {
-        throw new UnsupportedAccountCapabilityError('A delivery amount must be a positive bigint when provided.', { vm: 'solana', field: 'tokenRequests[0].amount' });
-    }
-    if (input.recipient !== undefined &&
-        (typeof input.recipient !== 'string' || !isAddress(input.recipient))) {
-        throw new UnsupportedAccountCapabilityError('A Solana-origin delivery recipient must be an EVM address.', { vm: 'solana', field: 'recipient' });
-    }
-    if (input.appFees !== undefined) {
-        assertSolanaObjectKeys(input.appFees, ['feeBps'], 'appFees');
-    }
-    if (input.protocolFees !== undefined) {
-        assertSolanaObjectKeys(input.protocolFees, ['feeBps'], 'protocolFees');
-    }
-}
-function assertSupportedTransaction(transaction, config) {
-    const input = transaction;
-    if (isCrossChainSolanaOrigin(transaction)) {
-        assertSupportedSolanaOriginDelivery(input, config);
-        return;
-    }
-    const hasChain = Object.hasOwn(input, 'chain') && input.chain !== undefined;
-    const hasTarget = Object.hasOwn(input, 'targetChain') && input.targetChain !== undefined;
-    if (hasChain === hasTarget) {
-        throw new UnsupportedAccountCapabilityError('A transaction must set exactly one of `chain` or `targetChain`.');
-    }
-    if (hasChain && typeof input.chain === 'object' && input.chain !== null) {
-        const chain = input.chain;
-        if (chain.kind === 'svm') {
-            assertSupportedSolanaTransaction(input, config);
-            return;
-        }
-    }
-    if (hasTarget && typeof input.targetChain === 'object' && input.targetChain) {
-        const target = input.targetChain;
-        if (!('kind' in target || 'caip2' in target) &&
-            (typeof target.id !== 'number' ||
-                !Number.isSafeInteger(target.id) ||
-                target.id < 0 ||
-                !formatCaip2(target.id).startsWith('eip155:'))) {
-            throw new UnsupportedAccountCapabilityError('A viem EVM destination must use an eip155 chain ID.');
-        }
-        if (('kind' in target || 'caip2' in target) &&
-            !((target.kind === 'svm' &&
-                typeof target.caip2 === 'string' &&
-                target.caip2.startsWith('solana:')) ||
-                (target.kind === 'tvm' &&
-                    typeof target.caip2 === 'string' &&
-                    target.caip2.startsWith('tron:')) ||
-                (target.kind === 'stellar' &&
-                    typeof target.caip2 === 'string' &&
-                    target.caip2.startsWith('stellar:')) ||
-                (target.kind === 'hypercore' &&
-                    (target.caip2 === 'hypercore:spot' ||
-                        target.caip2 === 'hypercore:perp')))) {
-            throw new UnsupportedAccountCapabilityError('The destination chain descriptor has mismatched VM and CAIP-2 fields.');
-        }
-        if (target.kind === 'svm') {
-            if (!Array.isArray(input.tokenRequests) ||
-                input.tokenRequests.length === 0) {
-                throw new UnsupportedAccountCapabilityError('Solana destinations require at least one token request.', { vm: 'solana' });
-            }
-            for (const request of input.tokenRequests) {
-                if (typeof request.address !== 'string') {
-                    throw new UnsupportedAccountCapabilityError('Solana token requests require a Solana address.');
-                }
-                solanaAddress(request.address);
-                if (request.amount !== undefined &&
-                    (typeof request.amount !== 'bigint' || request.amount <= 0n)) {
-                    throw new UnsupportedAccountCapabilityError('Solana token request amounts must be positive.');
-                }
-            }
-            // Anything other than a Solana address string would slip past both
-            // recipient defaults and then be dropped downstream, quoting a delivery
-            // with no receiver at all.
-            if (input.recipient !== undefined) {
-                if (typeof input.recipient !== 'string') {
-                    throw new UnsupportedAccountCapabilityError('A Solana delivery recipient must be a Solana address.', { vm: 'solana' });
-                }
-                solanaAddress(input.recipient);
-            }
-            if (input.calls !== undefined ||
-                input.instructions !== undefined ||
-                input.hyperCore !== undefined) {
-                throw new UnsupportedAccountCapabilityError('Solana destinations support token delivery only; calls, custom instructions and HyperCore actions are unavailable.', { vm: 'solana' });
-            }
-            if (input.recipient === undefined && !config.solana) {
-                throw new AccountVmNotConfiguredError('solana');
-            }
-        }
-    }
-    if (input.sourceChains !== undefined) {
-        if (!Array.isArray(input.sourceChains)) {
-            throw new UnsupportedAccountCapabilityError('`sourceChains` must be an array of managed source chains.');
-        }
-        if (input.sourceChains.length === 0) {
-            throw new UnsupportedAccountCapabilityError('`sourceChains` must contain at least one managed source.');
-        }
-        const ids = input.sourceChains.map((value) => typeof value === 'object' && value
-            ? value.id
-            : null);
-        const invalidSource = input.sourceChains.some((value) => {
-            if (!value || typeof value !== 'object')
-                return true;
-            const source = value;
-            return (typeof source.id !== 'number' ||
-                !Number.isSafeInteger(source.id) ||
-                source.id < 0 ||
-                Object.hasOwn(source, 'kind') ||
-                Object.hasOwn(source, 'caip2') ||
-                !formatCaip2(source.id).startsWith('eip155:'));
-        });
-        if (invalidSource) {
-            throw new UnsupportedAccountCapabilityError('Only viem EVM chains from the managed EVM account can be used as sources.');
-        }
-        if (new Set(ids).size !== ids.length) {
-            throw new UnsupportedAccountCapabilityError('`sourceChains` cannot contain duplicate chains.');
-        }
-    }
-    const calls = input.calls;
-    if (input.recipient !== undefined) {
-        if (Array.isArray(calls) && calls.length > 0) {
-            throw new UnsupportedAccountCapabilityError('An explicit delivery recipient cannot execute destination calls. Omit `recipient` to execute with the invoking managed EVM account.');
-        }
-        if (!Array.isArray(input.tokenRequests) ||
-            input.tokenRequests.length === 0) {
-            throw new UnsupportedAccountCapabilityError('An explicit delivery recipient requires at least one token request.');
-        }
-    }
-}
-function freezeSponsorship(sponsored) {
-    if (sponsored === undefined || typeof sponsored === 'boolean')
-        return {};
-    return { sponsored: Object.freeze({ ...sponsored }) };
-}
-export function normalizeTransaction(transaction, config) {
-    assertSupportedTransaction(transaction, config);
-    if (isCrossChainSolanaOrigin(transaction)) {
-        return Object.freeze({
-            ...transaction,
-            sourceChains: [
-                Object.freeze({ ...transaction.sourceChains[0] }),
-            ],
-            sourceTokens: [
-                Object.freeze({ ...transaction.sourceTokens[0] }),
-            ],
-            tokenRequests: [
-                Object.freeze({ ...transaction.tokenRequests[0] }),
-            ],
-            ...(transaction.appFees
-                ? { appFees: Object.freeze({ ...transaction.appFees }) }
-                : {}),
-            ...(transaction.protocolFees
-                ? { protocolFees: Object.freeze({ ...transaction.protocolFees }) }
-                : {}),
-            ...freezeSponsorship(transaction.sponsored),
-        });
-    }
-    if (isSolanaInstructionExecution(transaction)) {
-        const lookupTables = normalizeSolanaAddressLookupTables(transaction.addressLookupTables);
-        const { addressLookupTables: _tables, ...rest } = transaction;
-        return Object.freeze({
-            ...rest,
-            chain: Object.freeze({ ...transaction.chain }),
-            instructions: normalizeSolanaInstructions(transaction.instructions),
-            ...(lookupTables ? { addressLookupTables: lookupTables } : {}),
-            ...freezeSponsorship(transaction.sponsored),
-        });
-    }
-    if (isSameChainSolanaOrigin(transaction)) {
-        const request = transaction.tokenRequests[0];
-        return Object.freeze({
-            ...transaction,
-            chain: Object.freeze({ ...transaction.chain }),
-            tokenRequests: [Object.freeze({ ...request })],
-            ...(transaction.appFees
-                ? { appFees: Object.freeze({ ...transaction.appFees }) }
-                : {}),
-            ...(transaction.protocolFees
-                ? { protocolFees: Object.freeze({ ...transaction.protocolFees }) }
-                : {}),
-            ...freezeSponsorship(transaction.sponsored),
-        });
-    }
-    if ('targetChain' in transaction &&
-        transaction.targetChain !== undefined &&
-        'kind' in transaction.targetChain &&
-        transaction.targetChain.kind === 'svm' &&
-        transaction.recipient === undefined &&
-        config.solana &&
-        'address' in config.solana) {
-        return Object.freeze({
-            ...transaction,
-            recipient: config.solana.address,
-        });
-    }
-    return Object.freeze({ ...transaction });
-}
 function narrowQuoterPin(derived, explicit) {
     if (!explicit)
         return derived;
@@ -1202,39 +543,7 @@ function narrowQuoterPin(derived, explicit) {
         : derived.include.filter((quoter) => !explicit.exclude.includes(quoter));
     return { include: narrowed };
 }
-/**
- * Translates the public `sponsored` input into the wire's `sponsorSettings`.
- * Shared by both VMs so the two cannot drift.
- */
-function toSponsorSettings(sponsored) {
-    if (!sponsored)
-        return undefined;
-    if (typeof sponsored === 'boolean') {
-        return {
-            gas: sponsored,
-            bridgeFees: sponsored,
-            swapFees: sponsored,
-            protocolFees: sponsored,
-        };
-    }
-    return {
-        gas: sponsored.gas,
-        bridgeFees: sponsored.bridging,
-        swapFees: sponsored.swaps,
-        protocolFees: sponsored.protocolFees ?? false,
-        // Omitted rather than sent false when unset: the field rides the
-        // server-signature surface, so a key that is present-but-false is not the
-        // same bytes as absent.
-        ...(sponsored.swapValue ? { swapValue: true } : {}),
-    };
-}
-export function adaptTransaction(context, transaction, hyperCoreAction, automaticSourceChainIds) {
-    const nonEvmOrigin = 'chain' in transaction && transaction.chain && 'kind' in transaction.chain
-        ? transaction.chain.kind
-        : transaction.sourceChains?.find((chain) => 'kind' in chain)?.kind;
-    if (nonEvmOrigin) {
-        throw new UnsupportedAccountCapabilityError('Non-EVM origin execution is not supported yet. Use a viem EVM chain as the managed source.', { vm: nonEvmOrigin });
-    }
+export function adaptTransaction(context, transaction, hyperCoreAction) {
     const destination = 'chain' in transaction
         ? getChainReference(transaction.chain.id)
         : 'kind' in transaction.targetChain
@@ -1243,7 +552,7 @@ export function adaptTransaction(context, transaction, hyperCoreAction, automati
     const destinationChainId = destination.kind === 'evm' ? destination.id : undefined;
     const sourceChains = 'chain' in transaction
         ? [getChainReference(transaction.chain.id)]
-        : (transaction.sourceChains?.map((chain) => getChainReference(chain.id)) ?? automaticSourceChainIds?.map(getChainReference));
+        : transaction.sourceChains?.map((chain) => getChainReference(chain.id));
     const evmSources = sourceChains?.flatMap((chain) => chain.kind === 'evm' ? [chain] : []);
     return {
         destination,
@@ -1279,10 +588,23 @@ export function adaptTransaction(context, transaction, hyperCoreAction, automati
             ...('chain' in transaction && transaction.customDeadline !== undefined
                 ? { customDeadline: transaction.customDeadline }
                 : {}),
-            ...(() => {
-                const sponsorSettings = toSponsorSettings(transaction.sponsored);
-                return sponsorSettings ? { sponsorSettings } : {};
-            })(),
+            ...(transaction.sponsored
+                ? {
+                    sponsorSettings: typeof transaction.sponsored === 'boolean'
+                        ? {
+                            gas: transaction.sponsored,
+                            bridgeFees: transaction.sponsored,
+                            swapFees: transaction.sponsored,
+                            protocolFees: transaction.sponsored,
+                        }
+                        : {
+                            gas: transaction.sponsored.gas,
+                            bridgeFees: transaction.sponsored.bridging,
+                            swapFees: transaction.sponsored.swaps,
+                            protocolFees: transaction.sponsored.protocolFees ?? false,
+                        },
+                }
+                : {}),
             ...(transaction.settlementLayers
                 ? { settlementLayers: transaction.settlementLayers }
                 : {}),
@@ -1399,12 +721,9 @@ function adaptSessionSelection(transaction, chains) {
         ]));
     }
     const chainIds = new Set(chains.flatMap((chain) => chain.kind === 'evm' && chain.id !== undefined ? [chain.id] : []));
-    if ('chain' in transaction && !('kind' in transaction.chain)) {
+    if ('chain' in transaction)
         chainIds.add(transaction.chain.id);
-    }
-    if ('targetChain' in transaction &&
-        transaction.targetChain &&
-        'id' in transaction.targetChain) {
+    if ('targetChain' in transaction && 'id' in transaction.targetChain) {
         chainIds.add(transaction.targetChain.id);
     }
     return Object.fromEntries([...chainIds].map((chainId) => [
@@ -1418,18 +737,11 @@ function adaptSessionSelection(transaction, chains) {
 function adaptSourceAssets(sourceAssets, chainIds) {
     if (!sourceAssets)
         return chainIds ? { chainIds } : undefined;
-    const eligible = chainIds ? new Set(chainIds) : undefined;
-    const assertEligible = (chainId) => {
-        if (eligible && !eligible.has(chainId)) {
-            throw new UnsupportedAccountCapabilityError(`Source assets reference chain ${chainId}, which is outside the eligible source scope.`, { chainId });
-        }
-    };
     if (Array.isArray(sourceAssets)) {
         if (sourceAssets.length > 0 && typeof sourceAssets[0] === 'object') {
             const chainTokens = {};
             const chainTokenAmounts = {};
             for (const item of sourceAssets) {
-                assertEligible(item.chain.id);
                 const token = normalizeTokenAddress(item.address, item.chain.id, false);
                 if (item.amount === undefined)
                     (chainTokens[item.chain.id] ??= []).push(token);
@@ -1452,8 +764,7 @@ function adaptSourceAssets(sourceAssets, chainIds) {
     }
     // ChainTokenMap: validate every per-chain list too, so symbols can't slip
     // through this input the way they can't through tokenRequests / ExactInputConfig.
-    for (const [chainId, tokens] of Object.entries(sourceAssets)) {
-        assertEligible(Number(chainId));
+    for (const tokens of Object.values(sourceAssets)) {
         validateTokenAddresses(tokens);
     }
     return { chainTokens: sourceAssets };