@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

package/dist/src/api/signer-selection.js

@@ -0,0 +1,159 @@
+import { SignerNotSupportedError } from '../errors/execution.js';
+import { defineValidator } from '../modules/validators/definition.js';
+import { ecdsaSignerId, webauthnSignerId, } from '../modules/validators/signer-id.js';
+import { SOCIAL_RECOVERY_VALIDATOR_ADDRESS } from '../modules/validators/social-recovery.js';
+/**
+ * Adapts a signer selection for the intent and ERC-1271 flows.
+ *
+ * Rejects guardians: the social recovery validator reverts on
+ * `isValidSignatureWithSender` and only validates UserOperations, so a
+ * guardian signature could never be verified on these paths. Use
+ * {@link adaptUserOperationSignerSelection} for the UserOperation flow.
+ */
+export function adaptSignerSelection(account, signers) {
+    if (signers.type === 'guardians') {
+        throw new SignerNotSupportedError();
+    }
+    return adaptAnySignerSelection(account, signers);
+}
+/**
+ * Adapts a signer selection for the UserOperation flow, where guardians are
+ * the one supported non-owner signer.
+ */
+export function adaptUserOperationSignerSelection(account, signers) {
+    return adaptAnySignerSelection(account, signers);
+}
+function adaptAnySignerSelection(account, signers) {
+    if (signers.type === 'session') {
+        return adaptSessionSelection(signers);
+    }
+    if (signers.type === 'guardians') {
+        return adaptGuardianSelection(signers);
+    }
+    return adaptOwnerSelection(account, signers);
+}
+/**
+ * Adapts a guardian selection onto the social recovery validator.
+ *
+ * The module shares the ownable validator's threshold-ECDSA shape, so it
+ * resolves as an ECDSA validator pinned to the recovery module address. The
+ * threshold is the number of supplied guardians: the validator reads exactly
+ * `threshold` signatures onchain and sorts the recovered signers itself, so
+ * every guardian passed here must sign and their order is irrelevant.
+ */
+function adaptGuardianSelection(signers) {
+    if (signers.guardians.length === 0) {
+        throw new Error('Guardian signer selection requires at least one guardian');
+    }
+    return {
+        kind: 'owner',
+        validator: defineValidator({
+            type: 'ecdsa',
+            accounts: signers.guardians,
+            threshold: signers.guardians.length,
+            module: SOCIAL_RECOVERY_VALIDATOR_ADDRESS,
+        }, 'recovery-validator'),
+        signerIds: signers.guardians.map(ecdsaSignerId),
+    };
+}
+function adaptOwnerSelection(account, signers) {
+    switch (signers.kind) {
+        case 'ecdsa': {
+            const signerIds = signers.accounts.map(ecdsaSignerId);
+            return {
+                kind: 'owner',
+                validator: account.owners
+                    ? replaceValidatorAccounts(account.owners, signers.accounts)
+                    : defineValidator({ type: 'ecdsa', accounts: signers.accounts }),
+                signerIds,
+            };
+        }
+        case 'passkey': {
+            const signerIds = signers.accounts.map(webauthnSignerId);
+            return {
+                kind: 'owner',
+                validator: defineValidator({
+                    type: 'passkey',
+                    accounts: signers.accounts,
+                    ...(signers.module ? { module: signers.module } : {}),
+                }),
+                signerIds,
+            };
+        }
+        case 'multi-factor': {
+            const validator = defineValidator({
+                type: 'multi-factor',
+                validators: signers.validators.map((factor) => factor.type === 'passkey'
+                    ? { type: 'passkey', accounts: factor.accounts }
+                    : { type: 'ecdsa', accounts: factor.accounts }),
+                ...(signers.module ? { module: signers.module } : {}),
+            });
+            if (validator.kind !== 'multi-factor') {
+                throw new Error('Multi-factor signer selection did not resolve');
+            }
+            return {
+                kind: 'owner',
+                validator: {
+                    ...validator,
+                    validators: validator.validators.map((factor, index) => ({
+                        ...factor,
+                        publicId: signers.validators[index]?.id ?? factor.publicId,
+                    })),
+                },
+                signerIds: signers.validators.flatMap((factor) => factor.type === 'passkey'
+                    ? factor.accounts.map(webauthnSignerId)
+                    : factor.accounts.map(ecdsaSignerId)),
+            };
+        }
+    }
+}
+function replaceValidatorAccounts(configured, selectedAccounts) {
+    const accounts = new Map(selectedAccounts.map((account) => [
+        account.type === 'webAuthn'
+            ? webauthnSignerId(account)
+            : ecdsaSignerId(account),
+        account,
+    ]));
+    if (configured.kind === 'multi-factor') {
+        return {
+            ...configured,
+            validators: configured.validators.map((validator) => replaceAtomicValidatorAccounts(validator, accounts)),
+        };
+    }
+    return replaceAtomicValidatorAccounts(configured, accounts);
+}
+function replaceAtomicValidatorAccounts(configured, accounts) {
+    return {
+        ...configured,
+        owners: configured.owners.map((owner) => replaceOwnerAccount(owner, accounts.get(owner.signerId))),
+    };
+}
+function replaceOwnerAccount(owner, account) {
+    if (!account)
+        return owner;
+    return owner.kind === 'webauthn' && account.type === 'webAuthn'
+        ? { ...owner, account }
+        : owner.kind !== 'webauthn' && account.type !== 'webAuthn'
+            ? { ...owner, account }
+            : owner;
+}
+function adaptSessionSelection(signers) {
+    if ('sessions' in signers) {
+        return {
+            kind: 'smart-session',
+            byChain: Object.fromEntries(Object.entries(signers.sessions).map(([chainId, selection]) => [
+                Number(chainId),
+                selection,
+            ])),
+        };
+    }
+    return {
+        kind: 'smart-session',
+        byChain: {
+            [signers.session.chain.id]: {
+                session: signers.session,
+                ...(signers.enableData ? { enableData: signers.enableData } : {}),
+            },
+        },
+    };
+}

package/dist/src/calls/normalize.d.ts

@@ -0,0 +1,9 @@
+import type { Call } from './types.js';
+export interface CallInput {
+    readonly target: string;
+    readonly value?: bigint;
+    readonly data?: `0x${string}`;
+}
+export declare function normalizeCall(input: CallInput): Call;
+export declare function normalizeCalls(inputs: readonly CallInput[]): readonly Call[];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/src/calls/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../calls/normalize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;CAC9B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAYpD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,IAAI,EAAE,CAE5E"}

package/dist/src/calls/normalize.js

@@ -0,0 +1,17 @@
+import { getAddress, isAddress } from 'viem';
+export function normalizeCall(input) {
+    if (!isAddress(input.target)) {
+        throw new Error(`Invalid call target: ${input.target}`);
+    }
+    if (input.value !== undefined && input.value < 0n) {
+        throw new Error('Call value cannot be negative');
+    }
+    return {
+        target: getAddress(input.target),
+        value: input.value ?? 0n,
+        data: input.data ?? '0x',
+    };
+}
+export function normalizeCalls(inputs) {
+    return inputs.map(normalizeCall);
+}

package/dist/src/calls/resolve.d.ts

@@ -0,0 +1,3 @@
+import type { Call, CallResolveContext, UnresolvedCall } from './types.js';
+export declare function resolveCalls<CompatibilityConfig>(calls: readonly UnresolvedCall<CompatibilityConfig>[], context: CallResolveContext<CompatibilityConfig>): Promise<readonly Call[]>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/src/calls/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../calls/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,kBAAkB,EAElB,cAAc,EACf,MAAM,SAAS,CAAA;AAQhB,wBAAsB,YAAY,CAAC,mBAAmB,EACpD,KAAK,EAAE,SAAS,cAAc,CAAC,mBAAmB,CAAC,EAAE,EACrD,OAAO,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,GAC/C,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAW1B"}

package/dist/src/calls/resolve.js

@@ -0,0 +1,15 @@
+function isLazyCall(call) {
+    return 'resolve' in call && typeof call.resolve === 'function';
+}
+export async function resolveCalls(calls, context) {
+    const resolved = [];
+    for (const call of calls) {
+        if (!isLazyCall(call)) {
+            resolved.push(call);
+            continue;
+        }
+        const value = await call.resolve(context);
+        resolved.push(...(Array.isArray(value) ? value : [value]));
+    }
+    return resolved;
+}

package/dist/src/calls/types.d.ts

@@ -0,0 +1,25 @@
+import type { Address, Hex } from 'viem';
+import type { EvmChainReference, TokenReference } from '../chains/types.js';
+export interface Call {
+    readonly target: Address;
+    readonly value: bigint;
+    readonly data: Hex;
+}
+export interface SourceFund {
+    readonly token: TokenReference;
+    readonly amount: bigint;
+}
+export interface CallResolveContext<CompatibilityConfig> {
+    readonly account: Address;
+    readonly chain: EvmChainReference;
+    readonly config: CompatibilityConfig;
+}
+export interface LazyCallInput<CompatibilityConfig> {
+    readonly resolve: (context: CallResolveContext<CompatibilityConfig>) => Promise<Call | readonly Call[]>;
+}
+export type UnresolvedCall<CompatibilityConfig> = Call | LazyCallInput<CompatibilityConfig>;
+export interface ResolvedCalls {
+    readonly calls: readonly Call[];
+    readonly sourceFunds: readonly SourceFund[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/calls/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../calls/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAExE,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,kBAAkB,CAAC,mBAAmB;IACrD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;CACrC;AAED,MAAM,WAAW,aAAa,CAAC,mBAAmB;IAChD,QAAQ,CAAC,OAAO,EAAE,CAChB,OAAO,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,KAC7C,OAAO,CAAC,IAAI,GAAG,SAAS,IAAI,EAAE,CAAC,CAAA;CACrC;AAED,MAAM,MAAM,cAAc,CAAC,mBAAmB,IAC1C,IAAI,GACJ,aAAa,CAAC,mBAAmB,CAAC,CAAA;AAEtC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IAC/B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;CAC5C"}

package/dist/src/calls/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/chains/caip2.d.ts

@@ -0,0 +1,10 @@
+import type { ChainReference, EvmChainReference } from './types.js';
+export declare function formatCaip2(chainId: number): string;
+export declare function chainIdFromCaip2(value: string): number | undefined;
+export declare function parseCaip2(value: string): ChainReference;
+export declare function toEvmChainReference(chainId: number): EvmChainReference;
+export declare function chainIdFromReference(chain: ChainReference): number;
+export declare function isCaip2(value: string): boolean;
+export declare function isEvmCaip2(value: string): value is `eip155:${number}`;
+export declare function isNonEvmChainId(chainId: number): boolean;
+//# sourceMappingURL=caip2.d.ts.map

package/dist/src/chains/caip2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caip2.d.ts","sourceRoot":"","sources":["../../../chains/caip2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AA4BhE,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMnD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKlE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAmBxD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAUtE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAOlE;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,MAAM,EAAE,CAErE;AAKD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/src/chains/caip2.js

@@ -0,0 +1,85 @@
+// CAIP-2 wire format. EVM chains map programmatically (`eip155:<id>`); the
+// handful of non-EVM / virtual chains carry an explicit id ↔ caip2 mapping.
+//
+// v2: this small table is bundled here rather than read from
+// `@rhinestone/shared-configs`. EVM is the common case and needs no table, so a
+// new EVM chain needs no SDK change; a new non-EVM chain is rare and adds one
+// entry below. HyperCore is EVM-settled (id 1337) so `isNonEvmChainId` is
+// `false` for it even though its wire id is the non-`eip155` `hypercore:mainnet`.
+//
+// Spec: https://chainagnostic.org/CAIPs/caip-2
+const NON_EVM_CHAINS = [
+    { id: 1337, caip2: 'hypercore:mainnet', nonEvm: false },
+    { id: 728126428, caip2: 'tron:mainnet', nonEvm: true },
+    {
+        id: 792703809,
+        caip2: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        nonEvm: true,
+    },
+];
+const evmPattern = /^eip155:(0|[1-9]\d*)$/;
+export function formatCaip2(chainId) {
+    if (!Number.isSafeInteger(chainId) || chainId < 0) {
+        throw new Error(`Invalid chain id: ${chainId}`);
+    }
+    const nonEvm = NON_EVM_CHAINS.find((chain) => chain.id === chainId);
+    return nonEvm ? nonEvm.caip2 : `eip155:${chainId}`;
+}
+export function chainIdFromCaip2(value) {
+    if (evmPattern.test(value)) {
+        return Number(value.slice('eip155:'.length));
+    }
+    return NON_EVM_CHAINS.find((chain) => chain.caip2 === value)?.id;
+}
+export function parseCaip2(value) {
+    if (evmPattern.test(value)) {
+        const id = Number(value.slice('eip155:'.length));
+        return { kind: 'evm', id, caip2: `eip155:${id}` };
+    }
+    const id = chainIdFromCaip2(value);
+    if (id === undefined) {
+        throw new Error(`Invalid CAIP-2 chain id: ${value}`);
+    }
+    if (!isNonEvmChainId(id)) {
+        return { kind: 'evm', id, caip2: value };
+    }
+    const separator = value.indexOf(':');
+    return {
+        kind: 'non-evm',
+        namespace: value.slice(0, separator),
+        reference: value.slice(separator + 1),
+        caip2: value,
+    };
+}
+export function toEvmChainReference(chainId) {
+    const caip2 = formatCaip2(chainId);
+    if (!caip2.startsWith('eip155:') && chainId !== 1337) {
+        throw new Error(`Chain ${chainId} is not EVM-compatible`);
+    }
+    return {
+        kind: 'evm',
+        id: chainId,
+        caip2: caip2,
+    };
+}
+export function chainIdFromReference(chain) {
+    if (chain.kind === 'evm')
+        return chain.id;
+    const id = chainIdFromCaip2(chain.caip2);
+    if (id === undefined) {
+        throw new Error(`Invalid CAIP-2 chain id: ${chain.caip2}`);
+    }
+    return id;
+}
+export function isCaip2(value) {
+    return evmPattern.test(value) || chainIdFromCaip2(value) !== undefined;
+}
+export function isEvmCaip2(value) {
+    return evmPattern.test(value);
+}
+// True when a numeric chain id is genuinely non-EVM (Solana / Tron). HyperCore
+// (1337) is EVM-settled, so this is `false` for it even though its wire id is
+// the non-`eip155` `hypercore:mainnet` namespace.
+export function isNonEvmChainId(chainId) {
+    return NON_EVM_CHAINS.some((chain) => chain.id === chainId && chain.nonEvm);
+}

package/dist/src/chains/catalog.d.ts

@@ -0,0 +1,5 @@
+import { type Chain } from 'viem';
+import type { ChainReference } from './types.js';
+export declare function getChainById(chainId: number): Chain;
+export declare function getChainReference(chainId: number): ChainReference;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/src/chains/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../chains/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,MAAM,CAAA;AAG9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAU7C,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAcnD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAgBjE"}

package/dist/src/chains/catalog.js

@@ -0,0 +1,41 @@
+import { defineChain } from 'viem';
+import * as viemChains from 'viem/chains';
+import { formatCaip2 } from './caip2.js';
+// Chain objects (rpc / nativeCurrency / formatters, needed for signing and
+// `createPublicClient`) come from viem — not from bundled chain config. The
+// supported *set* is gated by the orchestrator; this resolves any known viem
+// chain by id.
+const allViemChains = Object.values(viemChains).filter((chain) => typeof chain?.id === 'number');
+export function getChainById(chainId) {
+    const known = allViemChains.find((chain) => chain.id === chainId);
+    if (known)
+        return known;
+    // The SDK must not gate signing/execution on its bundled viem version: a chain
+    // the orchestrator supports before viem knows it must still resolve. Fall back
+    // to a minimal chain carrying the id — the field EIP-712 signing needs. Richer
+    // metadata (formatters, default RPC) is only available for viem-known chains;
+    // RPC-needing paths already accept a caller-supplied transport.
+    return defineChain({
+        id: chainId,
+        name: `Chain ${chainId}`,
+        nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+        rpcUrls: { default: { http: [] } },
+    });
+}
+export function getChainReference(chainId) {
+    const caip2 = formatCaip2(chainId);
+    if (caip2.startsWith('eip155:') || chainId === 1337) {
+        return {
+            kind: 'evm',
+            id: chainId,
+            caip2: caip2,
+        };
+    }
+    const separator = caip2.indexOf(':');
+    return {
+        kind: 'non-evm',
+        namespace: caip2.slice(0, separator),
+        reference: caip2.slice(separator + 1),
+        caip2: caip2,
+    };
+}

package/dist/src/chains/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Thrown by the SDK's local chain/token registry — not an orchestrator API
+ * error. Kept distinct from `OrchestratorError` so consumers can catch
+ * unsupported-chain/token failures separately from server-side errors.
+ */
+export declare class UnsupportedChainError extends Error {
+    readonly chainId: number;
+    constructor(chainId: number);
+}
+export declare class UnsupportedTokenError extends Error {
+    readonly tokenSymbol: string;
+    readonly chainId: number;
+    constructor(tokenSymbol: string, chainId: number);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/chains/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../chains/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;gBAEZ,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;gBAEZ,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKjD"}

package/dist/src/chains/errors.js

@@ -0,0 +1,21 @@
+/**
+ * Thrown by the SDK's local chain/token registry — not an orchestrator API
+ * error. Kept distinct from `OrchestratorError` so consumers can catch
+ * unsupported-chain/token failures separately from server-side errors.
+ */
+export class UnsupportedChainError extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`Unsupported chain ${chainId}`);
+        this.chainId = chainId;
+    }
+}
+export class UnsupportedTokenError extends Error {
+    tokenSymbol;
+    chainId;
+    constructor(tokenSymbol, chainId) {
+        super(`Unsupported token ${tokenSymbol} for chain ${chainId}`);
+        this.tokenSymbol = tokenSymbol;
+        this.chainId = chainId;
+    }
+}

package/dist/src/{orchestrator/destinations.d.ts → chains/non-evm.d.ts}

@@ -1,5 +1,9 @@
 import type { Chain } from 'viem';
-import type { Caip2ChainId } from './caip2.js';
+type EvmCaip2ChainId = `eip155:${number}`;
+type SolanaCaip2ChainId = `solana:${string}`;
+type TronCaip2ChainId = `tron:${string}`;
+type HyperCoreCaip2ChainId = 'hypercore:mainnet';
+type Caip2ChainId = EvmCaip2ChainId | SolanaCaip2ChainId | TronCaip2ChainId | HyperCoreCaip2ChainId;
 interface NativeCurrency {
     readonly name: string;
     readonly symbol: string;
@@ -9,15 +13,14 @@ type NonEvmAddress = string;
 interface NonEvmChain {
     readonly name: string;
     readonly caip2: Caip2ChainId;
-    readonly kind: 'svm' | 'tvm';
+    readonly kind: 'svm' | 'tvm' | 'hypercore';
     readonly nativeCurrency: NativeCurrency;
     readonly testnet?: boolean;
 }
 type DestinationChain = Chain | NonEvmChain;
 declare const solanaMainnet: NonEvmChain;
 declare const tronMainnet: NonEvmChain;
-declare function isNonEvmChain(chain: DestinationChain): chain is NonEvmChain;
-declare function getChainId(chain: DestinationChain): number;
+declare const hyperCoreMainnet: NonEvmChain;
 export type { DestinationChain, NativeCurrency, NonEvmAddress, NonEvmChain };
-export { getChainId, isNonEvmChain, solanaMainnet, tronMainnet };
-//# sourceMappingURL=destinations.d.ts.map
+export { hyperCoreMainnet, solanaMainnet, tronMainnet };
+//# sourceMappingURL=non-evm.d.ts.map

package/dist/src/chains/non-evm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-evm.d.ts","sourceRoot":"","sources":["../../../chains/non-evm.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAA;AAEjC,KAAK,eAAe,GAAG,UAAU,MAAM,EAAE,CAAA;AACzC,KAAK,kBAAkB,GAAG,UAAU,MAAM,EAAE,CAAA;AAC5C,KAAK,gBAAgB,GAAG,QAAQ,MAAM,EAAE,CAAA;AACxC,KAAK,qBAAqB,GAAG,mBAAmB,CAAA;AAChD,KAAK,YAAY,GACb,eAAe,GACf,kBAAkB,GAClB,gBAAgB,GAChB,qBAAqB,CAAA;AAEzB,UAAU,cAAc;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAMD,KAAK,aAAa,GAAG,MAAM,CAAA;AAE3B,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAI5B,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,WAAW,CAAA;IAC1C,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED,KAAK,gBAAgB,GAAG,KAAK,GAAG,WAAW,CAAA;AAE3C,QAAA,MAAM,aAAa,EAAE,WAKpB,CAAA;AAED,QAAA,MAAM,WAAW,EAAE,WAKlB,CAAA;AAED,QAAA,MAAM,gBAAgB,EAAE,WAKvB,CAAA;AAED,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,CAAA;AAC5E,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,WAAW,EAAE,CAAA"}

package/dist/src/chains/non-evm.js

@@ -0,0 +1,30 @@
+// Public destination chain descriptors for destinations that aren't a plain
+// viem `Chain`: the non-EVM chains (Solana, Tron) plus HyperCore (an EVM-settled
+// virtual L1). Mirrors the minimal shape of viem's `Chain` (name,
+// nativeCurrency) so callers can pass them anywhere a destination chain is
+// expected — `targetChain: solanaMainnet` reads the same as `targetChain:
+// optimism`.
+//
+// The wire format is the CAIP-2 string. Internally the SDK and the
+// orchestrator also use a synthetic numeric chain id derived from the
+// CAIP-2 mapping, but it is non-standard and intentionally not exposed
+// on this type.
+const solanaMainnet = {
+    name: 'Solana',
+    caip2: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+    kind: 'svm',
+    nativeCurrency: { name: 'Solana', symbol: 'SOL', decimals: 9 },
+};
+const tronMainnet = {
+    name: 'Tron',
+    caip2: 'tron:mainnet',
+    kind: 'tvm',
+    nativeCurrency: { name: 'Tron', symbol: 'TRX', decimals: 6 },
+};
+const hyperCoreMainnet = {
+    name: 'HyperCore',
+    caip2: 'hypercore:mainnet',
+    kind: 'hypercore',
+    nativeCurrency: { name: 'Hyperliquid', symbol: 'HYPE', decimals: 18 },
+};
+export { hyperCoreMainnet, solanaMainnet, tronMainnet };

package/dist/src/chains/tokens.d.ts

@@ -0,0 +1,4 @@
+import { type Address } from 'viem';
+export declare function normalizeTokenAddress(token: Address | string, chainId: number, nonEvm: boolean): Address | string;
+export declare function validateTokenAddresses(tokens: readonly string[]): void;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/src/chains/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../chains/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,MAAM,CAAA;AAM9C,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GAAG,MAAM,EACvB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,OAAO,GACd,OAAO,GAAG,MAAM,CAMlB;AAKD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAMtE"}

package/dist/src/chains/tokens.js

@@ -0,0 +1,22 @@
+import { isAddress } from 'viem';
+// Token inputs are per-chain ERC-20 addresses (v2 no longer bundles a token
+// registry — chain/token data is fetched from the orchestrator at runtime).
+// Non-EVM chains pass their token identifiers through unchanged; EVM inputs
+// must be hex addresses.
+export function normalizeTokenAddress(token, chainId, nonEvm) {
+    if (isAddress(token))
+        return token;
+    if (nonEvm)
+        return token;
+    throw new Error(`Expected a token address on EVM chain ${chainId}, got: ${token}`);
+}
+// Rejects non-address token identifiers (e.g. symbols) so they can't slip
+// through the `sourceAssets` token-list inputs the way they can't through
+// tokenRequests / per-chain `ExactInputConfig`.
+export function validateTokenAddresses(tokens) {
+    for (const token of tokens) {
+        if (!isAddress(token, { strict: false })) {
+            throw new Error(`Invalid token address: ${token}`);
+        }
+    }
+}

package/dist/src/chains/types.d.ts

@@ -0,0 +1,25 @@
+import type { Address } from 'viem';
+export interface EvmChainReference {
+    readonly kind: 'evm';
+    readonly id: number;
+    readonly caip2: `eip155:${number}`;
+}
+export interface NonEvmChainReference {
+    readonly kind: 'non-evm';
+    readonly namespace: string;
+    readonly reference: string;
+    readonly caip2: `${string}:${string}`;
+}
+export type ChainReference = EvmChainReference | NonEvmChainReference;
+export interface EvmTokenReference {
+    readonly kind: 'evm-token';
+    readonly chain: EvmChainReference;
+    readonly address: Address;
+}
+export interface NonEvmTokenReference {
+    readonly kind: 'non-evm-token';
+    readonly chain: NonEvmChainReference;
+    readonly address: string;
+}
+export type TokenReference = EvmTokenReference | NonEvmTokenReference;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/chains/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../chains/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,UAAU,MAAM,EAAE,CAAA;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,CAAA;CACtC;AAED,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,oBAAoB,CAAA;AAErE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,oBAAoB,CAAA"}

package/dist/src/chains/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/clients/bundler/client.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedProvider, ResolvedServiceEndpoint } from '../../config/resolved.js';
+import { type JsonRpcFetchPort } from '../json-rpc.js';
+import type { BundlerPort, BundlerUserOperation } from './port.js';
+export declare function createBundlerClient(input: {
+    readonly endpoint?: ResolvedServiceEndpoint;
+    readonly provider: ResolvedProvider;
+    readonly fetch?: JsonRpcFetchPort;
+}): BundlerPort;
+export declare function serializeUserOperation(operation: BundlerUserOperation): Readonly<Record<string, unknown>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/src/clients/bundler/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../clients/bundler/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,KAAK,gBAAgB,EAAkB,MAAM,aAAa,CAAA;AAGnE,OAAO,KAAK,EAGV,WAAW,EACX,oBAAoB,EACrB,MAAM,QAAQ,CAAA;AAEf,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,uBAAuB,CAAA;IAC3C,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAA;CAClC,GAAG,WAAW,CAmDd;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,oBAAoB,GAC9B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CASnC"}