@rhinestone/sdk 2.0.0-beta.9 → 2.0.0

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"}

package/dist/src/clients/bundler/client.js

@@ -0,0 +1,85 @@
+import { createPublicClient } from 'viem';
+import { entryPoint07Address } from 'viem/account-abstraction';
+import { getChainById } from '../../chains/catalog.js';
+import { requestJsonRpc } from '../json-rpc.js';
+import { createRpcTransport } from '../rpc/transport.js';
+import { resolveBundlerUrl } from './endpoints.js';
+export function createBundlerClient(input) {
+    const fetchPort = input.fetch ?? globalThis.fetch;
+    const request = (chainId, method, params) => requestJsonRpc({
+        fetch: fetchPort,
+        url: resolveBundlerUrl(chainId, input.endpoint),
+        method,
+        params,
+    });
+    return {
+        estimateGas: async (chain, operation) => mapGasEstimate(await request(chain.id, 'eth_estimateUserOperationGas', [
+            serializeUserOperation(operation),
+            entryPoint07Address,
+        ])),
+        getGasPrice: async (chain) => {
+            if (input.endpoint?.kind === 'custom') {
+                const client = createPublicClient({
+                    chain: getChainById(chain.id),
+                    transport: createRpcTransport(chain.id, input.provider),
+                });
+                const fees = await client.estimateFeesPerGas({ type: 'eip1559' });
+                return {
+                    maxFeePerGas: 2n * fees.maxFeePerGas,
+                    maxPriorityFeePerGas: 2n * fees.maxPriorityFeePerGas,
+                };
+            }
+            return mapGasPrice(await request(chain.id, 'pimlico_getUserOperationGasPrice', []));
+        },
+        send: async (chain, operation) => (await request(chain.id, 'eth_sendUserOperation', [
+            serializeUserOperation(operation),
+            entryPoint07Address,
+        ])),
+        getReceipt: async (chain, hash) => {
+            const receipt = await request(chain.id, 'eth_getUserOperationReceipt', [
+                hash,
+            ]);
+            return receipt === null
+                ? undefined
+                : receipt;
+        },
+    };
+}
+export function serializeUserOperation(operation) {
+    return Object.fromEntries(Object.entries(operation)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => [
+        key,
+        typeof value === 'bigint' ? `0x${value.toString(16)}` : value,
+    ]));
+}
+function mapGasEstimate(value) {
+    const result = value;
+    return {
+        callGasLimit: parseQuantity(result.callGasLimit),
+        verificationGasLimit: parseQuantity(result.verificationGasLimit),
+        preVerificationGas: parseQuantity(result.preVerificationGas),
+        ...(result.paymasterVerificationGasLimit
+            ? {
+                paymasterVerificationGasLimit: parseQuantity(result.paymasterVerificationGasLimit),
+            }
+            : {}),
+        ...(result.paymasterPostOpGasLimit
+            ? {
+                paymasterPostOpGasLimit: parseQuantity(result.paymasterPostOpGasLimit),
+            }
+            : {}),
+    };
+}
+function mapGasPrice(value) {
+    const result = value;
+    return {
+        maxFeePerGas: parseQuantity(result.fast?.maxFeePerGas),
+        maxPriorityFeePerGas: parseQuantity(result.fast?.maxPriorityFeePerGas),
+    };
+}
+function parseQuantity(value) {
+    if (value === undefined)
+        throw new Error('JSON-RPC quantity is missing');
+    return BigInt(value);
+}

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

@@ -0,0 +1,3 @@
+import type { ResolvedServiceEndpoint } from '../../config/resolved.js';
+export declare function resolveBundlerUrl(chainId: number, endpoint?: ResolvedServiceEndpoint): string;
+//# sourceMappingURL=endpoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.d.ts","sourceRoot":"","sources":["../../../../clients/bundler/endpoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAEpE,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,uBAAuB,GACjC,MAAM,CAiBR"}

package/dist/src/clients/bundler/endpoints.js

@@ -0,0 +1,18 @@
+export function resolveBundlerUrl(chainId, endpoint) {
+    if (!endpoint)
+        return `https://public.pimlico.io/v2/${chainId}/rpc`;
+    switch (endpoint.kind) {
+        case 'pimlico':
+            return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${endpoint.apiKey}`;
+        case 'biconomy':
+            return `https://bundler.biconomy.io/api/v3/${chainId}/${endpoint.apiKey}`;
+        case 'custom': {
+            const url = typeof endpoint.urls === 'string'
+                ? endpoint.urls
+                : endpoint.urls[chainId];
+            if (!url)
+                throw new Error(`No bundler URL configured for chain ${chainId}`);
+            return url;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { Hex } from 'viem';
+import type { UserOperation, UserOperationReceipt } from 'viem/account-abstraction';
+import type { EvmChainReference } from '../../chains/types.js';
+export type BundlerUserOperation = UserOperation<'0.7'>;
+export interface BundlerGasEstimate {
+    readonly callGasLimit: bigint;
+    readonly verificationGasLimit: bigint;
+    readonly preVerificationGas: bigint;
+    readonly paymasterVerificationGasLimit?: bigint;
+    readonly paymasterPostOpGasLimit?: bigint;
+}
+export interface BundlerGasPrice {
+    readonly maxFeePerGas: bigint;
+    readonly maxPriorityFeePerGas: bigint;
+}
+export interface BundlerPort {
+    readonly estimateGas: (chain: EvmChainReference, operation: BundlerUserOperation) => Promise<BundlerGasEstimate>;
+    readonly getGasPrice: (chain: EvmChainReference) => Promise<BundlerGasPrice>;
+    readonly send: (chain: EvmChainReference, operation: BundlerUserOperation) => Promise<Hex>;
+    readonly getReceipt: (chain: EvmChainReference, userOperationHash: Hex) => Promise<UserOperationReceipt<'0.7'> | undefined>;
+}
+//# sourceMappingURL=port.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../../../clients/bundler/port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EACV,aAAa,EACb,oBAAoB,EACrB,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAE3D,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,KAAK,CAAC,CAAA;AAEvD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,MAAM,CAAA;IAC/C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;CAC1C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;CACtC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,CACpB,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,oBAAoB,KAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;IAC5E,QAAQ,CAAC,IAAI,EAAE,CACb,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,oBAAoB,KAC5B,OAAO,CAAC,GAAG,CAAC,CAAA;IACjB,QAAQ,CAAC,UAAU,EAAE,CACnB,KAAK,EAAE,iBAAiB,EACxB,iBAAiB,EAAE,GAAG,KACnB,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAA;CACtD"}

package/dist/src/clients/bundler/port.js

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

package/dist/src/clients/json-rpc.d.ts

@@ -0,0 +1,20 @@
+export type JsonRpcFetchPort = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare class JsonRpcClientError extends Error {
+    readonly method: string;
+    readonly code?: number;
+    readonly data?: unknown;
+    constructor(input: {
+        readonly method: string;
+        readonly message: string;
+        readonly code?: number;
+        readonly data?: unknown;
+        readonly cause?: unknown;
+    });
+}
+export declare function requestJsonRpc(input: {
+    readonly fetch: JsonRpcFetchPort;
+    readonly url: string;
+    readonly method: string;
+    readonly params: readonly unknown[];
+}): Promise<unknown>;
+//# sourceMappingURL=json-rpc.d.ts.map

package/dist/src/clients/json-rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-rpc.d.ts","sourceRoot":"","sources":["../../../clients/json-rpc.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,CAC7B,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,KACf,OAAO,CAAC,QAAQ,CAAC,CAAA;AAEtB,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;gBAEX,KAAK,EAAE;QACjB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;QACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;QACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;QACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KACzB;CAUF;AAID,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAA;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAA;CACpC,GAAG,OAAO,CAAC,OAAO,CAAC,CAgDnB"}