@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/api/account.js

@@ -0,0 +1,637 @@
+import { parseCaip2, toEvmChainReference } from '../chains/caip2.js';
+import { getChainById, getChainReference } from '../chains/catalog.js';
+import { normalizeTokenAddress, validateTokenAddresses } from '../chains/tokens.js';
+import { createStaticAccountRuntime } from '../config/account-runtime.js';
+import { materializeAccountInvocationContext, resolveAccountConfig, } from '../config/resolve.js';
+import { IndependentSigningNotSupportedError, MismatchedOwnerSignaturesError, QuoteNotInPreparedTransactionError, } from '../errors/execution.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 { adaptSignerSelection } from './signer-selection.js';
+function toPublicQuote(quote) {
+    const compatible = projectCompatibleQuote(quote);
+    return {
+        intentId: compatible.intentId,
+        expiresAt: compatible.expiresAt,
+        estimatedFillTime: compatible.estimatedFillTime,
+        settlementLayer: compatible.settlementLayer,
+        signData: {
+            origin: [...compatible.signData.origin],
+            destination: compatible.signData.destination,
+            ...(compatible.signData.targetExecution
+                ? { targetExecution: compatible.signData.targetExecution }
+                : {}),
+        },
+        cost: compatible.cost,
+        ...(compatible.tokenRequirements
+            ? { tokenRequirements: compatible.tokenRequirements }
+            : {}),
+        ...(compatible.bridgeFill ? { bridgeFill: compatible.bridgeFill } : {}),
+    };
+}
+function toPreparedTransactionData(prepared, transaction, cache) {
+    const data = {
+        quotes: {
+            traceId: prepared.traceId,
+            best: toPublicQuote(prepared.quote),
+            all: prepared.quotes.map(toPublicQuote),
+        },
+        intentInput: projectCompatibleIntentInput(prepared.request),
+        transaction,
+    };
+    cache.set(data, prepared);
+    return data;
+}
+function selectedPublicQuote(prepared, intentId) {
+    if (!intentId)
+        return prepared.quotes.best;
+    const quote = prepared.quotes.all.find((candidate) => candidate.intentId === intentId);
+    if (!quote) {
+        throw new QuoteNotInPreparedTransactionError({ context: { intentId } });
+    }
+    return quote;
+}
+function reconstructInput(context, prepared, intentId) {
+    const selected = selectedPublicQuote(prepared, intentId);
+    const quote = normalizeIntentQuote(selected);
+    return {
+        traceId: prepared.quotes.traceId,
+        quote,
+        quotes: prepared.quotes.all.map((candidate) => candidate.intentId === quote.intentId
+            ? quote
+            : normalizeIntentQuote(candidate)),
+        request: prepared.intentInput,
+        intentInput: adaptTransaction(context, prepared.transaction),
+    };
+}
+function toSignedTransactionData(prepared, signed, cache) {
+    const data = {
+        ...prepared,
+        quote: toPublicQuote(signed.prepared.quote),
+        originSignatures: signed.originSignatures,
+        destinationSignature: signed.destinationSignature,
+        targetExecutionSignature: signed.targetSignature,
+    };
+    cache.set(data, signed);
+    return data;
+}
+function referenceChain() {
+    // Account addresses are CREATE2 and chain-independent, so initialization only
+    // needs some EVM chain reference. With no bundled chain set, use mainnet.
+    return toEvmChainReference(1);
+}
+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 resolvePrepared = (ctx, prepared, intentId) => {
+        const cached = preparedIntents.get(prepared);
+        if (cached && !intentId)
+            return Promise.resolve(cached);
+        return workflowsFor(ctx).reconstructPreparedIntent(ctx, reconstructInput(ctx, prepared, intentId));
+    };
+    const account = {
+        config: compatibilityConfig,
+        deploy(chain, params) {
+            const ctx = context('deploy');
+            return workflowsFor(ctx).deploy(ctx, toEvmChainReference(chain.id), {
+                ...(params?.sponsored !== undefined
+                    ? { sponsored: params.sponsored }
+                    : {}),
+            });
+        },
+        isDeployed(chain) {
+            const ctx = context('is-deployed');
+            return workflowsFor(ctx).isDeployed(ctx, toEvmChainReference(chain.id));
+        },
+        setup(chain) {
+            const ctx = context('setup');
+            return workflowsFor(ctx).setup(ctx, toEvmChainReference(chain.id));
+        },
+        getInitData() {
+            const ctx = context('get-init-data');
+            return workflowsFor(ctx).getInitData(ctx);
+        },
+        async signEip7702InitData() {
+            const ctx = context('sign-eip7702-init-data');
+            const result = await workflowsFor(ctx).signEip7702InitData(ctx);
+            return result.signature;
+        },
+        async prepareTransaction(transaction) {
+            const ctx = context('prepare-intent');
+            const prepared = await workflowsFor(ctx).prepareIntent(ctx, adaptTransaction(ctx, transaction));
+            return toPreparedTransactionData(prepared, transaction, preparedIntents);
+        },
+        getTransactionMessages(preparedTransaction, options) {
+            const quote = selectedPublicQuote(preparedTransaction, options?.intentId);
+            return {
+                origin: [...quote.signData.origin],
+                destination: quote.signData.destination,
+                ...(quote.signData.targetExecution
+                    ? { targetExecution: quote.signData.targetExecution }
+                    : {}),
+            };
+        },
+        signTransaction: ((preparedTransaction, options) => {
+            const ctx = context('sign-intent');
+            const workflows = workflowsFor(ctx);
+            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') {
+                    return Promise.reject(new IndependentSigningNotSupportedError());
+                }
+                const signerId = signerIdForOwner(options.owner);
+                return resolvePrepared(ctx, preparedTransaction, options.intentId).then((internal) => workflows.signIntentAsOwner(ctx, internal, {
+                    signerId,
+                    ...(options.validatorId === undefined
+                        ? {}
+                        : { validatorId: options.validatorId }),
+                }));
+            }
+            return resolvePrepared(ctx, preparedTransaction, options?.intentId)
+                .then((internal) => workflows.signIntent(ctx, internal))
+                .then(({ intent }) => toSignedTransactionData(preparedTransaction, intent, signedIntents));
+        }),
+        async assembleTransaction(preparedTransaction, signatures) {
+            const ctx = context('assemble-intent');
+            const workflows = workflowsFor(ctx);
+            const intentIds = [...new Set(signatures.map(({ intentId }) => intentId))];
+            if (intentIds.length > 1) {
+                throw new MismatchedOwnerSignaturesError({ context: { intentIds } });
+            }
+            const internal = await resolvePrepared(ctx, preparedTransaction, intentIds[0]);
+            const signed = await workflows.assembleIntent(ctx, internal, signatures);
+            return toSignedTransactionData(preparedTransaction, signed, signedIntents);
+        },
+        async signAuthorizations(preparedTransaction) {
+            const ctx = context('sign-authorizations');
+            const intentInput = adaptTransaction(ctx, preparedTransaction.transaction);
+            const chains = authorizationChains(intentInput);
+            const result = await workflowsFor(ctx).signAuthorizations(ctx, {
+                chains,
+                ...(intentInput.eip7702InitSignature
+                    ? { eip7702InitSignature: intentInput.eip7702InitSignature }
+                    : {}),
+            });
+            return result.authorizations;
+        },
+        async signMessage(message, chain, signers) {
+            const ctx = context('sign-message');
+            const result = await workflowsFor(ctx).signMessage(ctx, {
+                message,
+                chain: toEvmChainReference(chain.id),
+                ...(signers
+                    ? { signers: adaptSignerSelection(ctx.account, signers) }
+                    : {}),
+            });
+            return result.signature;
+        },
+        async signTypedData(parameters, chain, signers) {
+            const ctx = context('sign-typed-data');
+            const result = await workflowsFor(ctx).signTypedData(ctx, {
+                typedData: parameters,
+                chain: toEvmChainReference(chain.id),
+                ...(signers
+                    ? { signers: adaptSignerSelection(ctx.account, signers) }
+                    : {}),
+            });
+            return result.signature;
+        },
+        async signIntent(signData, targetChain, signers) {
+            const ctx = context('sign-intent');
+            const result = await workflowsFor(ctx).signIntentFromSignData(ctx, {
+                signData: {
+                    origin: signData.origin,
+                    destination: signData.destination,
+                    ...(signData.targetExecution
+                        ? { targetExecution: signData.targetExecution }
+                        : {}),
+                },
+                targetChain: destinationChainReference(targetChain),
+                ...(signers
+                    ? { signers: adaptSignerSelection(ctx.account, signers) }
+                    : {}),
+            });
+            return {
+                originSignatures: result.originSignatures,
+                destinationSignature: result.destinationSignature,
+                targetExecutionSignature: result.targetExecutionSignature,
+            };
+        },
+        async submitTransaction(signedTransaction, options) {
+            const ctx = context('submit-intent');
+            const workflows = workflowsFor(ctx);
+            // 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);
+            const base = cached ?? {
+                prepared: await resolvePrepared(ctx, signedTransaction, signedTransaction.quote.intentId),
+                originSignatures: signedTransaction.originSignatures,
+                destinationSignature: signedTransaction.destinationSignature,
+                ...(signedTransaction.targetExecutionSignature
+                    ? { targetSignature: signedTransaction.targetExecutionSignature }
+                    : {}),
+                transcript: { planKind: 'intent-full', payloadId: '0x', stages: [] },
+            };
+            const signed = {
+                ...base,
+                ...(options?.authorizations
+                    ? { authorizations: options.authorizations }
+                    : {}),
+                ...(options?.internal_dryRun ? { dryRun: true } : {}),
+            };
+            const submitted = await workflows.submitIntent(ctx, signed);
+            return {
+                type: 'intent',
+                id: submitted.intentId,
+                traceId: submitted.traceId,
+                ...(submitted.sourceChains
+                    ? { sourceChains: [...submitted.sourceChains] }
+                    : {}),
+                targetChain: submitted.targetChain,
+            };
+        },
+        async prepareUserOperation(transaction) {
+            const ctx = context('prepare-user-operation');
+            const signers = userOperationSignerSelection(ctx, transaction);
+            const prepared = await workflowsFor(ctx).prepareUserOperation(ctx, {
+                chain: toEvmChainReference(transaction.chain.id),
+                calls: transaction.calls.map((call) => adaptCall(call, transaction.chain.id)),
+                ...(transaction.gasLimit === undefined
+                    ? {}
+                    : { gasLimit: transaction.gasLimit }),
+                ...(signers ? { signers } : {}),
+            });
+            const data = {
+                userOperation: prepared.operation,
+                hash: prepared.hash,
+                transaction,
+            };
+            return data;
+        },
+        async signUserOperation(preparedUserOperation) {
+            const ctx = context('sign-user-operation');
+            const signers = userOperationSignerSelection(ctx, preparedUserOperation.transaction);
+            // Recompute from the current public operation and live owners.
+            const internal = await workflowsFor(ctx).reconstructPreparedUserOperation(ctx, {
+                chain: toEvmChainReference(preparedUserOperation.transaction.chain.id),
+                operation: preparedUserOperation.userOperation,
+                ...(signers ? { signers } : {}),
+            });
+            const signed = await workflowsFor(ctx).signUserOperation(ctx, internal);
+            const data = {
+                ...preparedUserOperation,
+                signature: signed.signature,
+            };
+            return data;
+        },
+        async submitUserOperation(signedUserOperation) {
+            const ctx = context('submit-user-operation');
+            const signers = userOperationSignerSelection(ctx, signedUserOperation.transaction);
+            // The public operation and top-level signature remain authoritative.
+            const internal = await workflowsFor(ctx).reconstructSignedUserOperation(ctx, {
+                chain: toEvmChainReference(signedUserOperation.transaction.chain.id),
+                operation: signedUserOperation.userOperation,
+                signature: signedUserOperation.signature,
+                ...(signers ? { signers } : {}),
+            });
+            const submitted = await workflowsFor(ctx).submitUserOperation(ctx, internal);
+            return {
+                type: 'userop',
+                hash: submitted.hash,
+                chain: submitted.chain.id,
+            };
+        },
+        async sendUserOperation(transaction) {
+            const ctx = context('send-user-operation');
+            const signers = userOperationSignerSelection(ctx, transaction);
+            const submitted = await workflowsFor(ctx).sendUserOperation(ctx, {
+                chain: toEvmChainReference(transaction.chain.id),
+                calls: transaction.calls.map((call) => adaptCall(call, transaction.chain.id)),
+                ...(transaction.gasLimit === undefined
+                    ? {}
+                    : { gasLimit: transaction.gasLimit }),
+                ...(signers ? { signers } : {}),
+            });
+            return {
+                type: 'userop',
+                hash: submitted.hash,
+                chain: submitted.chain.id,
+            };
+        },
+        waitForExecution: ((result) => {
+            if (result.type === 'intent') {
+                const ctx = context('wait-for-execution');
+                return workflowsFor(ctx)
+                    .waitForIntentStatus(ctx, result.id)
+                    .then((status) => ({
+                    traceId: status.traceId,
+                    status: status.status,
+                    accountAddress: status.account,
+                    operations: status.operations,
+                }));
+            }
+            const ctx = context('wait-for-execution');
+            return workflowsFor(ctx)
+                .waitForUserOperationStatus(ctx, {
+                type: 'userop',
+                chain: toEvmChainReference(result.chain),
+                hash: result.hash,
+            })
+                .then((status) => status.receipt);
+        }),
+        getAddress() {
+            const ctx = context('get-address');
+            return workflowsFor(ctx).getAddress(ctx, referenceChain());
+        },
+        getPortfolio(onTestnets = false) {
+            const ctx = context('get-portfolio');
+            return workflowsFor(ctx)
+                .getPortfolio(ctx, onTestnets)
+                .then((portfolio) => portfolio.tokens);
+        },
+        getSessionDetails(sessions) {
+            const ctx = context('get-session-details');
+            return workflowsFor(ctx).getSessionDetails(ctx, sessions);
+        },
+        isSessionEnabled(session) {
+            const ctx = context('is-session-enabled');
+            return workflowsFor(ctx).isSessionEnabled(ctx, session);
+        },
+        signEnableSession(details) {
+            const ctx = context('sign-enable-session');
+            return workflowsFor(ctx).signEnableSession(ctx, details);
+        },
+        getOwners(chain) {
+            const ctx = context('get-owners');
+            return workflowsFor(ctx)
+                .getOwners(ctx, toEvmChainReference(chain.id))
+                .then((owners) => owners
+                ? { accounts: [...owners.accounts], threshold: owners.threshold }
+                : null);
+        },
+        getValidators(chain) {
+            const ctx = context('get-validators');
+            return workflowsFor(ctx)
+                .getValidators(ctx, toEvmChainReference(chain.id))
+                .then((addresses) => [...addresses]);
+        },
+        getExecutors(chain) {
+            const ctx = context('get-executors');
+            return workflowsFor(ctx)
+                .getExecutors(ctx, toEvmChainReference(chain.id))
+                .then((addresses) => [...addresses]);
+        },
+    };
+    return account;
+}
+function signerIdForOwner(owner) {
+    // ECDSA local accounts also expose `publicKey`, so discriminate on the
+    // account type rather than the presence of a public key.
+    if (owner.type === 'webAuthn') {
+        return webauthnSignerId(owner.publicKey);
+    }
+    return ecdsaSignerId(owner.address);
+}
+function userOperationSignerSelection(context, transaction) {
+    if (!transaction.signers)
+        return undefined;
+    if (transaction.signers?.type === 'session') {
+        throw new Error('No account found');
+    }
+    const selection = adaptSignerSelection(context.account, transaction.signers);
+    if (selection.kind !== 'owner')
+        throw new Error('No account found');
+    return selection;
+}
+function destinationChainReference(targetChain) {
+    if ('kind' in targetChain && typeof targetChain.caip2 === 'string') {
+        return parseCaip2(targetChain.caip2);
+    }
+    return getChainReference(targetChain.id);
+}
+// Public `Transaction` -> internal `IntentInput`. Owned here because the facade
+// is the only translation point between the compatibility surface and the
+// intent workflow.
+export function adaptTransaction(context, transaction) {
+    const destination = 'chain' in transaction
+        ? getChainReference(transaction.chain.id)
+        : 'kind' in transaction.targetChain
+            ? parseCaip2(transaction.targetChain.caip2)
+            : getChainReference(transaction.targetChain.id);
+    const destinationChainId = destination.kind === 'evm' ? destination.id : undefined;
+    const sourceChains = 'chain' in transaction
+        ? [getChainReference(transaction.chain.id)]
+        : transaction.sourceChains?.map((chain) => getChainReference(chain.id));
+    const evmSources = sourceChains?.flatMap((chain) => chain.kind === 'evm' ? [chain] : []);
+    return {
+        destination,
+        ...(evmSources ? { sourceChains: evmSources } : {}),
+        calls: (transaction.calls ?? []).map((call) => adaptCall(call, destinationChainId)),
+        tokenRequests: (transaction.tokenRequests ?? []).map((request) => ({
+            token: destinationChainId === undefined
+                ? request.address
+                : normalizeTokenAddress(request.address, destinationChainId, false),
+            ...(request.amount === undefined ? {} : { amount: request.amount }),
+        })),
+        ...(transaction.recipient
+            ? {
+                recipient: adaptRecipient(context, transaction.recipient, destination, transaction.eip7702InitSignature, transaction.experimental_accountOverride?.setupOps),
+            }
+            : {}),
+        ...(transaction.gasLimit === undefined
+            ? {}
+            : { gasLimit: transaction.gasLimit }),
+        ...(transaction.eip7702InitSignature
+            ? { eip7702InitSignature: transaction.eip7702InitSignature }
+            : {}),
+        ...(transaction.sourceAssets || sourceChains
+            ? {
+                accountAccessList: adaptSourceAssets(transaction.sourceAssets, evmSources?.map(({ id }) => id)),
+            }
+            : {}),
+        options: {
+            ...(transaction.appFees ? { appFees: transaction.appFees } : {}),
+            ...(transaction.protocolFees
+                ? { protocolFees: transaction.protocolFees }
+                : {}),
+            ...('chain' in transaction && transaction.customDeadline !== undefined
+                ? { customDeadline: transaction.customDeadline }
+                : {}),
+            ...(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 }
+                : {}),
+            ...(transaction.auxiliaryFunds
+                ? { auxiliaryFunds: transaction.auxiliaryFunds }
+                : {}),
+        },
+        ...(transaction.sourceCalls
+            ? {
+                sourceCalls: Object.fromEntries(Object.entries(transaction.sourceCalls).map(([chainId, calls]) => [
+                    Number(chainId),
+                    calls.map((call) => ({
+                        call: adaptCall(call, Number(chainId)),
+                        ...(call.provides ? { provides: call.provides } : {}),
+                    })),
+                ])),
+            }
+            : {}),
+        ...(transaction.experimental_accountOverride?.setupOps
+            ? {
+                accountSetupOverride: transaction.experimental_accountOverride.setupOps,
+            }
+            : {}),
+        ...(transaction.signers
+            ? {
+                signers: transaction.signers.type === 'session'
+                    ? {
+                        kind: 'smart-session',
+                        byChain: adaptSessionSelection(transaction, sourceChains ?? []),
+                    }
+                    : adaptSignerSelection(context.account, transaction.signers),
+            }
+            : {}),
+    };
+}
+function adaptRecipient(context, recipient, destination, eip7702InitSignature, setupOverride) {
+    if (typeof recipient === 'string') {
+        return projectIntentRecipient(recipient, destination);
+    }
+    if (destination.kind !== 'evm') {
+        throw new Error('Smart-account recipients require an EVM destination');
+    }
+    const resolved = resolveAccountConfig(context.sdk, toAccountConstructionInput(recipient));
+    return projectIntentAccount({
+        runtime: createStaticAccountRuntime(resolved, destination, false),
+        ...(setupOverride ? { setupOverride } : {}),
+        ...(eip7702InitSignature ? { eip7702InitSignature } : {}),
+    });
+}
+function toAccountConstructionInput(config) {
+    return {
+        ...(config.account ? { account: config.account } : {}),
+        ...(config.owners ? { owners: config.owners } : {}),
+        ...(config.sessions ? { sessions: config.sessions } : {}),
+        ...(config.eoa ? { eoa: config.eoa } : {}),
+        ...(config.modules ? { modules: config.modules } : {}),
+        ...(config.initData ? { initData: config.initData } : {}),
+    };
+}
+export function authorizationChains(input) {
+    const chains = [...(input.sourceChains ?? []), input.destination];
+    const seen = new Set();
+    return chains.filter((chain) => {
+        if (seen.has(chain.caip2))
+            return false;
+        seen.add(chain.caip2);
+        return true;
+    });
+}
+function adaptCall(call, chainId) {
+    if ('resolve' in call) {
+        return {
+            resolve: async (ctx) => {
+                const chain = getChainById(ctx.chain.id);
+                const value = await call.resolve({
+                    config: ctx.config,
+                    chain,
+                    accountAddress: ctx.account,
+                });
+                return (Array.isArray(value) ? value : [value]).map((item) => normalizeCall(item, ctx.chain.id));
+            },
+        };
+    }
+    if (chainId === undefined) {
+        throw new Error('Destination calls are not supported for non-EVM chains');
+    }
+    return normalizeCall(call, chainId);
+}
+function normalizeCall(call, chainId) {
+    return {
+        target: normalizeTokenAddress(call.to, chainId, false),
+        value: call.value ?? 0n,
+        data: call.data ?? '0x',
+    };
+}
+function adaptSessionSelection(transaction, chains) {
+    const signers = transaction.signers;
+    if (!signers || signers.type !== 'session')
+        return {};
+    if ('sessions' in signers) {
+        return Object.fromEntries(Object.entries(signers.sessions).map(([chainId, selection]) => [
+            Number(chainId),
+            selection,
+        ]));
+    }
+    const chainIds = new Set(chains.flatMap((chain) => chain.kind === 'evm' && chain.id !== undefined ? [chain.id] : []));
+    if ('chain' in transaction)
+        chainIds.add(transaction.chain.id);
+    if ('targetChain' in transaction && 'id' in transaction.targetChain) {
+        chainIds.add(transaction.targetChain.id);
+    }
+    return Object.fromEntries([...chainIds].map((chainId) => [
+        chainId,
+        {
+            session: signers.session,
+            ...(signers.enableData ? { enableData: signers.enableData } : {}),
+        },
+    ]));
+}
+function adaptSourceAssets(sourceAssets, chainIds) {
+    if (!sourceAssets)
+        return chainIds ? { chainIds } : undefined;
+    if (Array.isArray(sourceAssets)) {
+        if (sourceAssets.length > 0 && typeof sourceAssets[0] === 'object') {
+            const chainTokens = {};
+            const chainTokenAmounts = {};
+            for (const item of sourceAssets) {
+                const token = normalizeTokenAddress(item.address, item.chain.id, false);
+                if (item.amount === undefined)
+                    (chainTokens[item.chain.id] ??= []).push(token);
+                else
+                    (chainTokenAmounts[item.chain.id] ??= {})[token] = item.amount;
+            }
+            return {
+                ...(Object.keys(chainTokens).length > 0 ? { chainTokens } : {}),
+                ...(Object.keys(chainTokenAmounts).length > 0
+                    ? { chainTokenAmounts }
+                    : {}),
+            };
+        }
+        const tokens = sourceAssets;
+        validateTokenAddresses(tokens);
+        return {
+            ...(chainIds ? { chainIds } : {}),
+            tokens,
+        };
+    }
+    // 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 tokens of Object.values(sourceAssets)) {
+        validateTokenAddresses(tokens);
+    }
+    return { chainTokens: sourceAssets };
+}

package/dist/src/api/accounts.d.ts

@@ -0,0 +1,12 @@
+import type { RhinestoneAccountConfig } from '../config/account.js';
+import type { SdkConstructionInput } from '../config/input.js';
+import { type LegacyAccountConfig, type LegacySdkConfigSnapshot } from '../config/legacy.js';
+import { type RhinestoneAccount } from './account.js';
+import type { CoreComposition } from './compose-types.js';
+export interface SdkComposition {
+    readonly composition: CoreComposition<LegacyAccountConfig<unknown>>;
+    readonly snapshot: LegacySdkConfigSnapshot<unknown>;
+}
+export declare function composeSdk(input: SdkConstructionInput): SdkComposition;
+export declare function attachAccount(sdk: SdkComposition, config: RhinestoneAccountConfig): RhinestoneAccount;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/src/api/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../../api/accounts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC7B,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAEvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAA;IACnE,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAA;CACpD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,oBAAoB,GAAG,cAAc,CAOtE;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,uBAAuB,GAC9B,iBAAiB,CAanB"}

package/dist/src/api/accounts.js

@@ -0,0 +1,17 @@
+import { captureLegacySdkConfig, createLegacyAccountConfig, } from '../config/legacy.js';
+import { materializeAccountInvocationContext, resolveSdkConfig, } from '../config/resolve.js';
+import { assertAccountOwnersConfigured } from '../config/validate.js';
+import { createAccountFacade } from './account.js';
+import { createConfiguredCoreComposition } from './compose.js';
+export function composeSdk(input) {
+    const resolved = resolveSdkConfig(input);
+    return {
+        composition: createConfiguredCoreComposition(resolved),
+        snapshot: captureLegacySdkConfig(input, resolved.auth),
+    };
+}
+export function attachAccount(sdk, config) {
+    const compatibilityConfig = createLegacyAccountConfig(config, sdk.snapshot);
+    assertAccountOwnersConfigured(materializeAccountInvocationContext(sdk.composition.config, compatibilityConfig, 'get-address').account);
+    return createAccountFacade(compatibilityConfig, sdk.composition);
+}