@lifi/composer-sdk 0.8.1 → 0.10.0

package/dist/sdk.d.cts

@@ -1,15 +1,11 @@
-import { ComposeCompileResult, ComposeCompileRequest, ComposeRouteRequest, SimulateRequest, SimulateResult } from '@lifi/compose-spec';
-import { FlowOptions, FlowBuilderCore, TypedFlow } from './authoring/FlowBuilderCore.cjs';
-import { ComposeClient } from './client.cjs';
-import { ChainSummary } from './discovery.cjs';
-import { GeneratedOps } from './generated/operations.generated.cjs';
-import { ComposeRunInput } from './run/inputs.cjs';
-import { InputSchema } from './types.cjs';
-import './authoring/handles.cjs';
-import './authoring/signatureArgs.cjs';
-import 'abitype';
-import './generated/config.generated.cjs';
-
+import { InputSchema } from "./types.cjs";
+import { FlowBuilderCore, FlowOptions, TypedFlow } from "./authoring/FlowBuilderCore.cjs";
+import { ChainSummary } from "./discovery.cjs";
+import { ComposeClient } from "./client.cjs";
+import { GeneratedOps } from "./generated/operations.generated.cjs";
+import { ComposeRunInput } from "./run/inputs.cjs";
+import { ComposeCompileRequest, ComposeCompileResult, ComposeRouteRequest, SimulateRequest, SimulateResult } from "@lifi/compose-spec";
+//#region src/sdk.d.ts
 /**
  * A flow builder augmented with generated operation methods and a `compile` method
  * that submits the flow to the Compose backend for compilation.
@@ -18,36 +14,36 @@ import './generated/config.generated.cjs';
  *
  * @typeParam T - The input schema describing the flow's required inputs.
  */
-type FlowBuilder<T extends InputSchema = InputSchema> = FlowBuilderCore<T> & GeneratedOps & {
-    /**
-     * Builds the flow document from the current builder state and submits it
-     * to the Compose API for compilation.
-     *
-     * @param run - Runtime inputs, preconditions, and signer address.
-     * @returns The compiled transaction calldata and metadata.
-     * @throws {@link ComposeError} on network, validation, or server errors.
-     *
-     * @example
-     * ```ts
-     * const result = await builder.compile({
-     *   inputs: { token: materialisers.balanceOf({}) },
-     *   signer: '0xYourAddress...',
-     * });
-     * console.log(result.calldata);
-     * ```
-     */
-    readonly compile: (run: ComposeRunInput<T>) => Promise<ComposeCompileResult>;
+export type FlowBuilder<T extends InputSchema = InputSchema> = FlowBuilderCore<T> & GeneratedOps & {
+  /**
+   * Builds the flow document from the current builder state and submits it
+   * to the Compose API for compilation.
+   *
+   * @param run - Runtime inputs, preconditions, and signer address.
+   * @returns The compiled transaction calldata and metadata.
+   * @throws {@link ComposeError} on network, validation, or server errors.
+   *
+   * @example
+   * ```ts
+   * const result = await builder.compile({
+   *   inputs: { token: materialisers.balanceOf({}) },
+   *   signer: '0xYourAddress...',
+   * });
+   * console.log(result.calldata);
+   * ```
+   */
+  readonly compile: (run: ComposeRunInput<T>) => Promise<ComposeCompileResult>;
 };
 /**
  * Configuration for creating a Compose SDK instance.
  */
-interface ComposeSdkOptions {
-    /** Base URL of the Compose API (e.g. `"https://li.quest"`). */
-    readonly baseUrl: string;
-    /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
-    readonly fetch?: typeof globalThis.fetch;
-    /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */
-    readonly apiKey: string;
+export interface ComposeSdkOptions {
+  /** Base URL of the Compose API (e.g. `"https://li.quest"`). */
+  readonly baseUrl: string;
+  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
+  readonly fetch?: typeof globalThis.fetch;
+  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */
+  readonly apiKey: string;
 }
 /**
  * The top-level Compose SDK interface.
@@ -76,76 +72,76 @@ interface ComposeSdkOptions {
  * });
  * ```
  */
-interface ComposeSdk {
-    /** Low-level HTTP client for the Compose API. */
-    readonly client: ComposeClient;
-    /**
-     * Creates a new flow builder targeting the given chain.
-     * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).
-     * @param options - Flow configuration including input declarations.
-     * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.
-     * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.
-     */
-    readonly flow: <T extends InputSchema>(chainId: number, options: FlowOptions<T>) => FlowBuilder<T>;
-    /**
-     * Fetches the chains this Compose deployment supports, ascending by
-     * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it
-     * for what "supported" means and for the caching caveat.
-     *
-     * Each entry pairs the `chainId` with a display `name`, so one call both
-     * gates a chain selector and labels it. Key on `chainId`; `name` is a
-     * deployment-maintained label that can change.
-     *
-     * Use it to fail fast before building a flow for a chain the server would
-     * reject.
-     *
-     * @returns The supported chains, ascending by `chainId`.
-     * @throws {@link ComposeError} on network or server errors.
-     *
-     * @example
-     * ```ts
-     * const chains = await sdk.getSupportedChains();
-     * if (!chains.some((c) => c.chainId === 8453)) {
-     *   throw new Error('Base is not supported');
-     * }
-     * for (const { chainId, name } of chains) {
-     *   console.log(`${name} (${chainId})`);
-     * }
-     * ```
-     */
-    readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;
-    /**
-     * Builds a raw compile request without sending it. Useful for inspecting the
-     * request payload or submitting it through a custom transport.
-     * @param flow - A built flow document (from `builder.build()`).
-     * @param run - Runtime inputs, preconditions, and signer address.
-     * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.
-     */
-    readonly request: <T extends InputSchema>(flow: TypedFlow<T>, run: ComposeRunInput<T>) => ComposeCompileRequest;
-    /**
-     * Compiles a token pair on one chain into a submit-ready transaction. Thin
-     * pass-through to {@link ComposeClient.route}; see it for the short chain of
-     * catalog edges the server plans, when to prefer `flow(...).compile(...)`,
-     * the `success` / `partial` discrimination, and error behaviour. Build the
-     * `amount` with `routeAmount.exact(...)` / `routeAmount.all(...)`.
-     *
-     * @param request - The from/to token pair, amount, signer, and route options.
-     * @returns A discriminated result: `status: 'success'` or `status: 'partial'`.
-     * @throws {@link ComposeError} on network, validation, or server errors.
-     */
-    readonly route: (request: ComposeRouteRequest) => Promise<ComposeCompileResult>;
-    /**
-     * Simulates a raw, pre-encoded transaction. Thin pass-through to
-     * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`
-     * result discrimination and error behaviour. Pair with `buildSimulateRequest`
-     * to assemble the request from a compile result.
-     *
-     * @param request - The raw transaction plus funding `requirements` and
-     *   `trackedBalances`.
-     * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).
-     * @throws {@link ComposeError} on network, validation, or server errors.
-     */
-    readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;
+export interface ComposeSdk {
+  /** Low-level HTTP client for the Compose API. */
+  readonly client: ComposeClient;
+  /**
+   * Creates a new flow builder targeting the given chain.
+   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).
+   * @param options - Flow configuration including input declarations.
+   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.
+   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.
+   */
+  readonly flow: <T extends InputSchema>(chainId: number, options: FlowOptions<T>) => FlowBuilder<T>;
+  /**
+   * Fetches the chains this Compose deployment supports, ascending by
+   * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it
+   * for what "supported" means and for the caching caveat.
+   *
+   * Each entry pairs the `chainId` with a display `name`, so one call both
+   * gates a chain selector and labels it. Key on `chainId`; `name` is a
+   * deployment-maintained label that can change.
+   *
+   * Use it to fail fast before building a flow for a chain the server would
+   * reject.
+   *
+   * @returns The supported chains, ascending by `chainId`.
+   * @throws {@link ComposeError} on network or server errors.
+   *
+   * @example
+   * ```ts
+   * const chains = await sdk.getSupportedChains();
+   * if (!chains.some((c) => c.chainId === 8453)) {
+   *   throw new Error('Base is not supported');
+   * }
+   * for (const { chainId, name } of chains) {
+   *   console.log(`${name} (${chainId})`);
+   * }
+   * ```
+   */
+  readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;
+  /**
+   * Builds a raw compile request without sending it. Useful for inspecting the
+   * request payload or submitting it through a custom transport.
+   * @param flow - A built flow document (from `builder.build()`).
+   * @param run - Runtime inputs, preconditions, and signer address.
+   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.
+   */
+  readonly request: <T extends InputSchema>(flow: TypedFlow<T>, run: ComposeRunInput<T>) => ComposeCompileRequest;
+  /**
+   * Compiles a token pair on one chain into a submit-ready transaction. Thin
+   * pass-through to {@link ComposeClient.route}; see it for the short chain of
+   * catalog edges the server plans, when to prefer `flow(...).compile(...)`,
+   * the `success` / `partial` discrimination, and error behaviour. Build the
+   * `amount` with `routeAmount.exact(...)` / `routeAmount.all(...)`.
+   *
+   * @param request - The from/to token pair, amount, signer, and route options.
+   * @returns A discriminated result: `status: 'success'` or `status: 'partial'`.
+   * @throws {@link ComposeError} on network, validation, or server errors.
+   */
+  readonly route: (request: ComposeRouteRequest) => Promise<ComposeCompileResult>;
+  /**
+   * Simulates a raw, pre-encoded transaction. Thin pass-through to
+   * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`
+   * result discrimination and error behaviour. Pair with `buildSimulateRequest`
+   * to assemble the request from a compile result.
+   *
+   * @param request - The raw transaction plus funding `requirements` and
+   *   `trackedBalances`.
+   * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).
+   * @throws {@link ComposeError} on network, validation, or server errors.
+   */
+  readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;
 }
 /**
  * Creates a new Compose SDK instance.
@@ -158,6 +154,7 @@ interface ComposeSdk {
  * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });
  * ```
  */
-declare const createComposeSdk: (options: ComposeSdkOptions) => ComposeSdk;
-
-export { ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type FlowBuilder, createComposeSdk };
+export declare const createComposeSdk: (options: ComposeSdkOptions) => ComposeSdk;
+//#endregion
+export type { ComposeRunInput };
+//# sourceMappingURL=sdk.d.cts.map

package/dist/sdk.d.ts

@@ -1,15 +1,11 @@
-import { ComposeCompileResult, ComposeCompileRequest, ComposeRouteRequest, SimulateRequest, SimulateResult } from '@lifi/compose-spec';
-import { FlowOptions, FlowBuilderCore, TypedFlow } from './authoring/FlowBuilderCore.js';
-import { ComposeClient } from './client.js';
-import { ChainSummary } from './discovery.js';
-import { GeneratedOps } from './generated/operations.generated.js';
-import { ComposeRunInput } from './run/inputs.js';
-import { InputSchema } from './types.js';
-import './authoring/handles.js';
-import './authoring/signatureArgs.js';
-import 'abitype';
-import './generated/config.generated.js';
-
+import { InputSchema } from "./types.js";
+import { FlowBuilderCore, FlowOptions, TypedFlow } from "./authoring/FlowBuilderCore.js";
+import { ChainSummary } from "./discovery.js";
+import { ComposeClient } from "./client.js";
+import { GeneratedOps } from "./generated/operations.generated.js";
+import { ComposeRunInput } from "./run/inputs.js";
+import { ComposeCompileRequest, ComposeCompileResult, ComposeRouteRequest, SimulateRequest, SimulateResult } from "@lifi/compose-spec";
+//#region src/sdk.d.ts
 /**
  * A flow builder augmented with generated operation methods and a `compile` method
  * that submits the flow to the Compose backend for compilation.
@@ -18,36 +14,36 @@ import './generated/config.generated.js';
  *
  * @typeParam T - The input schema describing the flow's required inputs.
  */
-type FlowBuilder<T extends InputSchema = InputSchema> = FlowBuilderCore<T> & GeneratedOps & {
-    /**
-     * Builds the flow document from the current builder state and submits it
-     * to the Compose API for compilation.
-     *
-     * @param run - Runtime inputs, preconditions, and signer address.
-     * @returns The compiled transaction calldata and metadata.
-     * @throws {@link ComposeError} on network, validation, or server errors.
-     *
-     * @example
-     * ```ts
-     * const result = await builder.compile({
-     *   inputs: { token: materialisers.balanceOf({}) },
-     *   signer: '0xYourAddress...',
-     * });
-     * console.log(result.calldata);
-     * ```
-     */
-    readonly compile: (run: ComposeRunInput<T>) => Promise<ComposeCompileResult>;
+export type FlowBuilder<T extends InputSchema = InputSchema> = FlowBuilderCore<T> & GeneratedOps & {
+  /**
+   * Builds the flow document from the current builder state and submits it
+   * to the Compose API for compilation.
+   *
+   * @param run - Runtime inputs, preconditions, and signer address.
+   * @returns The compiled transaction calldata and metadata.
+   * @throws {@link ComposeError} on network, validation, or server errors.
+   *
+   * @example
+   * ```ts
+   * const result = await builder.compile({
+   *   inputs: { token: materialisers.balanceOf({}) },
+   *   signer: '0xYourAddress...',
+   * });
+   * console.log(result.calldata);
+   * ```
+   */
+  readonly compile: (run: ComposeRunInput<T>) => Promise<ComposeCompileResult>;
 };
 /**
  * Configuration for creating a Compose SDK instance.
  */
-interface ComposeSdkOptions {
-    /** Base URL of the Compose API (e.g. `"https://li.quest"`). */
-    readonly baseUrl: string;
-    /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
-    readonly fetch?: typeof globalThis.fetch;
-    /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */
-    readonly apiKey: string;
+export interface ComposeSdkOptions {
+  /** Base URL of the Compose API (e.g. `"https://li.quest"`). */
+  readonly baseUrl: string;
+  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
+  readonly fetch?: typeof globalThis.fetch;
+  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */
+  readonly apiKey: string;
 }
 /**
  * The top-level Compose SDK interface.
@@ -76,76 +72,76 @@ interface ComposeSdkOptions {
  * });
  * ```
  */
-interface ComposeSdk {
-    /** Low-level HTTP client for the Compose API. */
-    readonly client: ComposeClient;
-    /**
-     * Creates a new flow builder targeting the given chain.
-     * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).
-     * @param options - Flow configuration including input declarations.
-     * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.
-     * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.
-     */
-    readonly flow: <T extends InputSchema>(chainId: number, options: FlowOptions<T>) => FlowBuilder<T>;
-    /**
-     * Fetches the chains this Compose deployment supports, ascending by
-     * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it
-     * for what "supported" means and for the caching caveat.
-     *
-     * Each entry pairs the `chainId` with a display `name`, so one call both
-     * gates a chain selector and labels it. Key on `chainId`; `name` is a
-     * deployment-maintained label that can change.
-     *
-     * Use it to fail fast before building a flow for a chain the server would
-     * reject.
-     *
-     * @returns The supported chains, ascending by `chainId`.
-     * @throws {@link ComposeError} on network or server errors.
-     *
-     * @example
-     * ```ts
-     * const chains = await sdk.getSupportedChains();
-     * if (!chains.some((c) => c.chainId === 8453)) {
-     *   throw new Error('Base is not supported');
-     * }
-     * for (const { chainId, name } of chains) {
-     *   console.log(`${name} (${chainId})`);
-     * }
-     * ```
-     */
-    readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;
-    /**
-     * Builds a raw compile request without sending it. Useful for inspecting the
-     * request payload or submitting it through a custom transport.
-     * @param flow - A built flow document (from `builder.build()`).
-     * @param run - Runtime inputs, preconditions, and signer address.
-     * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.
-     */
-    readonly request: <T extends InputSchema>(flow: TypedFlow<T>, run: ComposeRunInput<T>) => ComposeCompileRequest;
-    /**
-     * Compiles a token pair on one chain into a submit-ready transaction. Thin
-     * pass-through to {@link ComposeClient.route}; see it for the short chain of
-     * catalog edges the server plans, when to prefer `flow(...).compile(...)`,
-     * the `success` / `partial` discrimination, and error behaviour. Build the
-     * `amount` with `routeAmount.exact(...)` / `routeAmount.all(...)`.
-     *
-     * @param request - The from/to token pair, amount, signer, and route options.
-     * @returns A discriminated result: `status: 'success'` or `status: 'partial'`.
-     * @throws {@link ComposeError} on network, validation, or server errors.
-     */
-    readonly route: (request: ComposeRouteRequest) => Promise<ComposeCompileResult>;
-    /**
-     * Simulates a raw, pre-encoded transaction. Thin pass-through to
-     * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`
-     * result discrimination and error behaviour. Pair with `buildSimulateRequest`
-     * to assemble the request from a compile result.
-     *
-     * @param request - The raw transaction plus funding `requirements` and
-     *   `trackedBalances`.
-     * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).
-     * @throws {@link ComposeError} on network, validation, or server errors.
-     */
-    readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;
+export interface ComposeSdk {
+  /** Low-level HTTP client for the Compose API. */
+  readonly client: ComposeClient;
+  /**
+   * Creates a new flow builder targeting the given chain.
+   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).
+   * @param options - Flow configuration including input declarations.
+   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.
+   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.
+   */
+  readonly flow: <T extends InputSchema>(chainId: number, options: FlowOptions<T>) => FlowBuilder<T>;
+  /**
+   * Fetches the chains this Compose deployment supports, ascending by
+   * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it
+   * for what "supported" means and for the caching caveat.
+   *
+   * Each entry pairs the `chainId` with a display `name`, so one call both
+   * gates a chain selector and labels it. Key on `chainId`; `name` is a
+   * deployment-maintained label that can change.
+   *
+   * Use it to fail fast before building a flow for a chain the server would
+   * reject.
+   *
+   * @returns The supported chains, ascending by `chainId`.
+   * @throws {@link ComposeError} on network or server errors.
+   *
+   * @example
+   * ```ts
+   * const chains = await sdk.getSupportedChains();
+   * if (!chains.some((c) => c.chainId === 8453)) {
+   *   throw new Error('Base is not supported');
+   * }
+   * for (const { chainId, name } of chains) {
+   *   console.log(`${name} (${chainId})`);
+   * }
+   * ```
+   */
+  readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;
+  /**
+   * Builds a raw compile request without sending it. Useful for inspecting the
+   * request payload or submitting it through a custom transport.
+   * @param flow - A built flow document (from `builder.build()`).
+   * @param run - Runtime inputs, preconditions, and signer address.
+   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.
+   */
+  readonly request: <T extends InputSchema>(flow: TypedFlow<T>, run: ComposeRunInput<T>) => ComposeCompileRequest;
+  /**
+   * Compiles a token pair on one chain into a submit-ready transaction. Thin
+   * pass-through to {@link ComposeClient.route}; see it for the short chain of
+   * catalog edges the server plans, when to prefer `flow(...).compile(...)`,
+   * the `success` / `partial` discrimination, and error behaviour. Build the
+   * `amount` with `routeAmount.exact(...)` / `routeAmount.all(...)`.
+   *
+   * @param request - The from/to token pair, amount, signer, and route options.
+   * @returns A discriminated result: `status: 'success'` or `status: 'partial'`.
+   * @throws {@link ComposeError} on network, validation, or server errors.
+   */
+  readonly route: (request: ComposeRouteRequest) => Promise<ComposeCompileResult>;
+  /**
+   * Simulates a raw, pre-encoded transaction. Thin pass-through to
+   * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`
+   * result discrimination and error behaviour. Pair with `buildSimulateRequest`
+   * to assemble the request from a compile result.
+   *
+   * @param request - The raw transaction plus funding `requirements` and
+   *   `trackedBalances`.
+   * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).
+   * @throws {@link ComposeError} on network, validation, or server errors.
+   */
+  readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;
 }
 /**
  * Creates a new Compose SDK instance.
@@ -158,6 +154,7 @@ interface ComposeSdk {
  * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });
  * ```
  */
-declare const createComposeSdk: (options: ComposeSdkOptions) => ComposeSdk;
-
-export { ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type FlowBuilder, createComposeSdk };
+export declare const createComposeSdk: (options: ComposeSdkOptions) => ComposeSdk;
+//#endregion
+export type { ComposeRunInput };
+//# sourceMappingURL=sdk.d.ts.map

package/dist/sdk.js

@@ -1,49 +1,57 @@
-import {
-  createFlowBuilderCore
-} from "./authoring/FlowBuilderCore.js";
 import { createComposeClient } from "./client.js";
-import {
-  bindGeneratedOps
-} from "./generated/operations.generated.js";
 import { buildRun } from "./run/inputs.js";
+import { createFlowBuilderCore } from "./authoring/FlowBuilderCore.js";
+import { bindGeneratedOps } from "./generated/operations.generated.js";
+//#region src/sdk.ts
+/**
+* Creates a new Compose SDK instance.
+*
+* @param options - SDK configuration including the API base URL, required API key, and optional fetch implementation.
+* @returns A {@link ComposeSdk} instance.
+*
+* @example
+* ```ts
+* const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });
+* ```
+*/
 const createComposeSdk = (options) => {
-  const composeClient = createComposeClient(options);
-  const request = (flowDoc, run) => ({
-    flow: flowDoc,
-    run: buildRun({
-      inputs: run.inputs,
-      preconditions: run.preconditions,
-      signer: run.signer,
-      assumptions: run.assumptions,
-      referrer: run.referrer,
-      integratorFeeBps: run.integratorFeeBps,
-      maxPriceImpactBps: run.maxPriceImpactBps,
-      sweepTo: run.sweepTo,
-      simulationPolicy: run.simulationPolicy,
-      simulateUserProgram: run.simulateUserProgram,
-      checkOnChainAllowances: run.checkOnChainAllowances
-    })
-  });
-  const flow = (chainId, opts) => {
-    const core = createFlowBuilderCore(chainId, opts);
-    const builder = Object.assign(core, bindGeneratedOps(core));
-    const compile = async (run) => {
-      const flowDoc = builder.build();
-      const req = request(flowDoc, run);
-      return composeClient.compile(req);
-    };
-    return Object.assign(builder, { compile });
-  };
-  return {
-    client: composeClient,
-    flow,
-    getSupportedChains: composeClient.getChains,
-    request,
-    route: composeClient.route,
-    simulate: composeClient.simulate
-  };
-};
-export {
-  createComposeSdk
+	const composeClient = createComposeClient(options);
+	const request = (flowDoc, run) => ({
+		flow: flowDoc,
+		run: buildRun({
+			inputs: run.inputs,
+			preconditions: run.preconditions,
+			signer: run.signer,
+			assumptions: run.assumptions,
+			referrer: run.referrer,
+			integratorFeeBps: run.integratorFeeBps,
+			maxPriceImpactBps: run.maxPriceImpactBps,
+			sweepTo: run.sweepTo,
+			simulationPolicy: run.simulationPolicy,
+			simulateUserProgram: run.simulateUserProgram,
+			checkOnChainAllowances: run.checkOnChainAllowances
+		})
+	});
+	const flow = (chainId, opts) => {
+		const core = createFlowBuilderCore(chainId, opts);
+		const builder = Object.assign(core, bindGeneratedOps(core));
+		const compile = async (run) => {
+			const flowDoc = builder.build();
+			const req = request(flowDoc, run);
+			return composeClient.compile(req);
+		};
+		return Object.assign(builder, { compile });
+	};
+	return {
+		client: composeClient,
+		flow,
+		getSupportedChains: composeClient.getChains,
+		request,
+		route: composeClient.route,
+		simulate: composeClient.simulate
+	};
 };
+//#endregion
+export { createComposeSdk };
+
 //# sourceMappingURL=sdk.js.map