@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

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

package/dist/src/clients/json-rpc.js

@@ -0,0 +1,56 @@
+export class JsonRpcClientError extends Error {
+    method;
+    code;
+    data;
+    constructor(input) {
+        super(input.message, input.cause === undefined ? undefined : { cause: input.cause });
+        this.name = 'JsonRpcClientError';
+        this.method = input.method;
+        this.code = input.code;
+        this.data = input.data;
+    }
+}
+let nextRequestId = 1;
+export async function requestJsonRpc(input) {
+    let response;
+    try {
+        response = await input.fetch(input.url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: nextRequestId++,
+                method: input.method,
+                params: input.params,
+            }),
+        });
+    }
+    catch (cause) {
+        throw new JsonRpcClientError({
+            method: input.method,
+            message: `JSON-RPC request ${input.method} failed`,
+            cause,
+        });
+    }
+    let envelope;
+    try {
+        envelope = (await response.json());
+    }
+    catch (cause) {
+        throw new JsonRpcClientError({
+            method: input.method,
+            message: `JSON-RPC request ${input.method} returned invalid JSON`,
+            cause,
+        });
+    }
+    if (!response.ok || envelope.error) {
+        throw new JsonRpcClientError({
+            method: input.method,
+            message: envelope.error?.message ??
+                `JSON-RPC request ${input.method} failed with status ${response.status}`,
+            code: envelope.error?.code,
+            data: envelope.error?.data,
+        });
+    }
+    return envelope.result;
+}

package/dist/src/clients/orchestrator/auth.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedAuth } from '../../config/resolved.js';
+export interface OrchestratorAuthPort {
+    readonly getHeaders: () => Promise<Readonly<Record<string, string>>>;
+    readonly getSubmitHeaders: (intentInput: unknown, sponsored: boolean) => Promise<Readonly<Record<string, string>>>;
+}
+export declare function createOrchestratorAuth(auth: ResolvedAuth): OrchestratorAuthPort;
+//# sourceMappingURL=auth.d.ts.map

package/dist/src/clients/orchestrator/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../clients/orchestrator/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IACpE,QAAQ,CAAC,gBAAgB,EAAE,CACzB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,OAAO,KACf,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;CAC/C;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,GACjB,oBAAoB,CA4BtB"}

package/dist/src/clients/orchestrator/auth.js

@@ -0,0 +1,27 @@
+export function createOrchestratorAuth(auth) {
+    if (auth.kind === 'api-key') {
+        const headers = Object.freeze({ 'x-api-key': auth.apiKey });
+        return {
+            getHeaders: async () => headers,
+            getSubmitHeaders: async () => headers,
+        };
+    }
+    const accessToken = async () => typeof auth.accessToken === 'function'
+        ? await auth.accessToken()
+        : auth.accessToken;
+    const headers = async () => ({
+        Authorization: `Bearer ${await accessToken()}`,
+        'x-api-key': 'jwt',
+    });
+    return {
+        getHeaders: headers,
+        getSubmitHeaders: async (intentInput, sponsored) => ({
+            ...(await headers()),
+            ...(sponsored && auth.getIntentExtensionToken
+                ? {
+                    'X-Intent-Extension': `Bearer ${await auth.getIntentExtensionToken(intentInput)}`,
+                }
+                : {}),
+        }),
+    };
+}

package/dist/src/clients/orchestrator/chain-catalog.d.ts

@@ -0,0 +1,36 @@
+import type { WireChainsResponse } from './wire.js';
+export type CatalogToken = {
+    symbol: string;
+    address: string;
+    decimals: number;
+};
+export type ChainInfo = {
+    name: string;
+    testnet: boolean;
+    supportedTokens: 'all' | CatalogToken[];
+    wrappedNativeToken?: CatalogToken;
+};
+export type ChainInfoMap = Record<number, ChainInfo>;
+/**
+ * Read-only view over the chain facts returned by `GET /chains`. Built once per
+ * client (fetched lazily) and read synchronously thereafter.
+ */
+export declare class ChainCatalog {
+    private readonly chains;
+    constructor(chains: ChainInfoMap);
+    getSupportedChainIds(): number[];
+    isSupported(chainId: number): boolean;
+    getChainInfo(chainId: number): ChainInfo | undefined;
+    /**
+     * Whether the chain is a testnet, per the orchestrator's `/chains`. Uses the
+     * catalog's own flag so it is authoritative for every supported chain
+     * (including non-EVM and chains newer than the SDK's viem), rather than
+     * viem's local chain list.
+     */
+    isTestnet(chainId: number): boolean;
+    /** The wrapped-native (e.g. WETH) token for the chain, if advertised. */
+    getWrappedNativeToken(chainId: number): CatalogToken | undefined;
+    getSupportedTokens(chainId: number): 'all' | CatalogToken[] | undefined;
+}
+export declare function parseChains(json: WireChainsResponse): ChainInfoMap;
+//# sourceMappingURL=chain-catalog.d.ts.map

package/dist/src/clients/orchestrator/chain-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-catalog.d.ts","sourceRoot":"","sources":["../../../../clients/orchestrator/chain-catalog.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;IAGhB,eAAe,EAAE,KAAK,GAAG,YAAY,EAAE,CAAA;IACvC,kBAAkB,CAAC,EAAE,YAAY,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAEpD;;;GAGG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAEjD,oBAAoB,IAAI,MAAM,EAAE;IAIhC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIrC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIpD;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAInC,yEAAyE;IACzE,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIhE,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,YAAY,EAAE,GAAG,SAAS;CAGxE;AAKD,wBAAgB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,YAAY,CAelE"}

package/dist/src/clients/orchestrator/chain-catalog.js

@@ -0,0 +1,67 @@
+// Runtime chain catalog, sourced from the orchestrator's `GET /chains`.
+//
+// This replaces the SDK's bundled `@rhinestone/shared-configs` chain data: the
+// orchestrator is authoritative for chain *facts* (which chains are supported,
+// their tokens, and the wrapped-native token), so the SDK reads them at runtime
+// instead of baking them in at build time. That's what lets a new chain go live
+// without an SDK release.
+//
+// `Chain` objects themselves (rpc/nativeCurrency/formatters, needed for signing
+// and `createPublicClient`) still come from viem — `/chains` can't carry those.
+// The catalog only owns the chain *facts*.
+import { chainIdFromCaip2, isCaip2 } from '../../chains/caip2.js';
+/**
+ * Read-only view over the chain facts returned by `GET /chains`. Built once per
+ * client (fetched lazily) and read synchronously thereafter.
+ */
+export class ChainCatalog {
+    chains;
+    constructor(chains) {
+        this.chains = chains;
+    }
+    getSupportedChainIds() {
+        return Object.keys(this.chains).map(Number);
+    }
+    isSupported(chainId) {
+        return chainId in this.chains;
+    }
+    getChainInfo(chainId) {
+        return this.chains[chainId];
+    }
+    /**
+     * Whether the chain is a testnet, per the orchestrator's `/chains`. Uses the
+     * catalog's own flag so it is authoritative for every supported chain
+     * (including non-EVM and chains newer than the SDK's viem), rather than
+     * viem's local chain list.
+     */
+    isTestnet(chainId) {
+        return this.chains[chainId]?.testnet ?? false;
+    }
+    /** The wrapped-native (e.g. WETH) token for the chain, if advertised. */
+    getWrappedNativeToken(chainId) {
+        return this.chains[chainId]?.wrappedNativeToken;
+    }
+    getSupportedTokens(chainId) {
+        return this.chains[chainId]?.supportedTokens;
+    }
+}
+// Adapter boundary: decode the CAIP-2-keyed wire response into a numeric-keyed
+// `ChainInfoMap`. Entries whose id can't be mapped are skipped rather than
+// failing the whole catalog.
+export function parseChains(json) {
+    const out = {};
+    for (const [key, entry] of Object.entries(json)) {
+        const id = isCaip2(key) ? chainIdFromCaip2(key) : Number(key);
+        if (id === undefined || !Number.isFinite(id))
+            continue;
+        out[id] = {
+            name: entry.name,
+            testnet: entry.testnet,
+            supportedTokens: entry.supportedTokens,
+            ...(entry.wrappedNativeToken
+                ? { wrappedNativeToken: entry.wrappedNativeToken }
+                : {}),
+        };
+    }
+    return out;
+}

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

@@ -0,0 +1,13 @@
+import type { ResolvedSdkConfig } from '../../config/resolved.js';
+import type { OrchestratorAuthPort } from './auth.js';
+import { type FetchPort } from './fetch.js';
+import type { OrchestratorPort } from './port.js';
+export interface OrchestratorClientOptions {
+    readonly url: string;
+    readonly auth: OrchestratorAuthPort;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly fetch?: FetchPort;
+}
+export declare function createOrchestratorClient(options: OrchestratorClientOptions): OrchestratorPort;
+export declare function createConfiguredOrchestratorClient(config: ResolvedSdkConfig, fetch?: FetchPort): OrchestratorPort;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../clients/orchestrator/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAA;AAGlD,OAAO,EAAE,KAAK,SAAS,EAAyB,MAAM,SAAS,CAAA;AAU/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAM9C,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAC3B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,yBAAyB,GACjC,gBAAgB,CA0GlB;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,iBAAiB,EACzB,KAAK,CAAC,EAAE,SAAS,GAChB,gBAAgB,CAOlB"}

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

@@ -0,0 +1,97 @@
+import { formatCaip2 } from '../../chains/caip2.js';
+import { createOrchestratorAuth } from './auth.js';
+import { ChainCatalog, parseChains } from './chain-catalog.js';
+import { fetchOrchestratorJson } from './fetch.js';
+import { mapIntentRequestToWire, mapIntentStatusFromWire, mapPortfolioFromWire, mapQuoteResponseFromWire, mapSignedIntentToWire, mapSplitRequestToWire, mapSplitResultFromWire, } from './mappers.js';
+const SDK_VERSION = '2.1.0';
+const API_VERSION = '2026-04.blanc';
+export function createOrchestratorClient(options) {
+    const fetchPort = options.fetch ?? globalThis.fetch;
+    const request = async (input) => {
+        const authHeaders = input.submitContext
+            ? await options.auth.getSubmitHeaders(input.submitContext.intentInput, input.submitContext.sponsored)
+            : await options.auth.getHeaders();
+        return fetchOrchestratorJson({
+            fetch: fetchPort,
+            url: new URL(input.path, withTrailingSlash(options.url)).toString(),
+            init: {
+                method: input.method ?? 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-sdk-version': SDK_VERSION,
+                    'x-api-version': API_VERSION,
+                    ...authHeaders,
+                    ...options.headers,
+                },
+                ...(input.body === undefined
+                    ? {}
+                    : { body: JSON.stringify(input.body) }),
+            },
+        });
+    };
+    // Memoized so the chain catalog is fetched at most once per client, lazily on
+    // first use — never at account construction.
+    let chainCatalogPromise;
+    return {
+        createQuote: async (input) => mapQuoteResponseFromWire(await request({
+            path: 'quotes',
+            method: 'POST',
+            body: mapIntentRequestToWire(input),
+        })),
+        submitIntent: async (input, context) => {
+            const value = (await request({
+                path: 'intents',
+                method: 'POST',
+                body: mapSignedIntentToWire(input),
+                ...(context ? { submitContext: context } : {}),
+            }));
+            return { traceId: value.traceId ?? '', intentId: value.intentId ?? '' };
+        },
+        getIntentStatus: async (intentId) => mapIntentStatusFromWire(intentId, await request({ path: `intents/${encodeURIComponent(intentId)}` })),
+        splitIntents: async (input) => mapSplitResultFromWire(await request({
+            path: 'intents/splits',
+            method: 'POST',
+            body: mapSplitRequestToWire(input),
+        })),
+        getPortfolio: async (input) => {
+            const params = new URLSearchParams();
+            for (const chainId of input.chainIds ?? []) {
+                params.append('chainIds', formatCaip2(chainId));
+            }
+            for (const [chainId, tokens] of Object.entries(input.tokens ?? {})) {
+                for (const token of tokens) {
+                    params.append('tokens', `${formatCaip2(Number(chainId))}:${token}`);
+                }
+            }
+            const suffix = params.size > 0 ? `?${params}` : '';
+            return mapPortfolioFromWire(await request({
+                path: `accounts/${input.account}/portfolio${suffix}`,
+            }));
+        },
+        getAppFeeBalances: async () => {
+            const value = (await request({ path: 'app-fees/balances' }));
+            return {
+                withdrawableUsd: value.withdrawableUsd ?? 0,
+                pendingUsd: value.pendingUsd ?? 0,
+            };
+        },
+        getChainCatalog: () => {
+            chainCatalogPromise ??= (async () => {
+                const json = (await request({ path: 'chains' }));
+                return new ChainCatalog(parseChains(json));
+            })();
+            return chainCatalogPromise;
+        },
+    };
+}
+export function createConfiguredOrchestratorClient(config, fetch) {
+    return createOrchestratorClient({
+        url: config.orchestratorUrl,
+        auth: createOrchestratorAuth(config.auth),
+        headers: config.headers,
+        ...(fetch ? { fetch } : {}),
+    });
+}
+function withTrailingSlash(value) {
+    return value.endsWith('/') ? value : `${value}/`;
+}