@lifi/composer-sdk 0.4.0 → 0.5.0

package/dist/run/simulate.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/simulate.ts"],"sourcesContent":["import type {\n  ComposeCompileResult,\n  SimulateRequest,\n  SlotFinderRequirement,\n  TrackedBalance,\n} from '@lifi/compose-spec';\n\n/**\n * Input for {@link buildSimulateRequest}: a compile result plus the fields a\n * simulation needs that a compiled flow does not carry.\n */\nexport interface BuildSimulateRequestInput {\n  /**\n   * A result from `builder.compile(...)` / `client.compile(...)`. Both\n   * `success` and `partial` results carry a `transactionRequest`, so either is\n   * valid input — the helper does not discriminate on `status`.\n   */\n  readonly result: ComposeCompileResult;\n  /** EVM chain id. A compile result does not carry the target chain. */\n  readonly chainId: number;\n  /**\n   * The transaction sender (`from`). A compile result does not carry the\n   * signer, so it must be supplied here.\n   */\n  readonly signer: string;\n  /**\n   * Balances to watch across the simulation. These cannot be inferred from a\n   * flow and must be supplied by the caller.\n   */\n  readonly trackedBalances: readonly TrackedBalance[];\n  /** Optional funding instructions applied before simulation. */\n  readonly requirements?: readonly SlotFinderRequirement[];\n  /** Optional block to pin the simulation to. Omitted ⇒ chain head. */\n  readonly block?: number;\n  /**\n   * Optional native value override. Defaults to the compiled\n   * `transactionRequest.value` when omitted.\n   */\n  readonly value?: bigint | string;\n}\n\n/**\n * Assembles a {@link SimulateRequest} from a compile result and the\n * caller-supplied chain, signer, and tracked balances. Pure: performs no\n * network I/O, does not mutate its input, and returns a fresh object.\n *\n * Bridges the common case — simulate the transaction you just compiled —\n * without coupling raw-transaction simulation to the flow builder. The\n * `value` defaults to the compiled transaction's value unless overridden.\n *\n * @example\n * ```ts\n * const compiled = await builder.compile({ inputs: { ... }, signer: '0x1111...' });\n * const req = buildSimulateRequest({\n *   result: compiled,\n *   chainId: 1,\n *   signer: '0x1111111111111111111111111111111111111111',\n *   trackedBalances: [{ token: '0xA0b8...', owner: '0x1111...' }],\n * });\n * const sim = await sdk.client.simulate(req);\n * ```\n */\nexport const buildSimulateRequest = (\n  input: BuildSimulateRequestInput,\n): SimulateRequest => {\n  const { result, chainId, signer, trackedBalances, requirements, block } =\n    input;\n  return {\n    chainId,\n    from: signer,\n    to: result.transactionRequest.to,\n    data: result.transactionRequest.data,\n    value: input.value ?? result.transactionRequest.value,\n    block,\n    requirements,\n    trackedBalances,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA8DO,MAAM,uBAAuB,CAClC,UACoB;AACpB,QAAM,EAAE,QAAQ,SAAS,QAAQ,iBAAiB,cAAc,MAAM,IACpE;AACF,SAAO;AAAA,IACL;AAAA,IACA,MAAM;AAAA,IACN,IAAI,OAAO,mBAAmB;AAAA,IAC9B,MAAM,OAAO,mBAAmB;AAAA,IAChC,OAAO,MAAM,SAAS,OAAO,mBAAmB;AAAA,IAChD;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/run/simulate.ts"],"sourcesContent":["import type {\n  ComposeCompileResult,\n  SimulateRequest,\n  SlotFinderRequirement,\n  TrackedBalance,\n} from '@lifi/compose-spec';\n\n/**\n * Input for {@link buildSimulateRequest}: a compile result plus the fields a\n * simulation needs that a compiled flow does not carry.\n */\nexport interface BuildSimulateRequestInput {\n  /**\n   * A result from `builder.compile(...)` / `client.compile(...)`. Both\n   * `success` and `partial` results are valid input — the helper does not\n   * discriminate on `status`. A success result for an empty compiled program\n   * (a settle-only `funding: 'external'` flow) carries no\n   * `transactionRequest`; there is nothing to simulate and this helper\n   * throws — submit the result's `actions` entries directly instead.\n   */\n  readonly result: ComposeCompileResult;\n  /** EVM chain id. A compile result does not carry the target chain. */\n  readonly chainId: number;\n  /**\n   * The transaction sender (`from`). A compile result does not carry the\n   * signer, so it must be supplied here.\n   */\n  readonly signer: string;\n  /**\n   * Balances to watch across the simulation. These cannot be inferred from a\n   * flow and must be supplied by the caller.\n   */\n  readonly trackedBalances: readonly TrackedBalance[];\n  /** Optional funding instructions applied before simulation. */\n  readonly requirements?: readonly SlotFinderRequirement[];\n  /** Optional block to pin the simulation to. Omitted ⇒ chain head. */\n  readonly block?: number;\n  /**\n   * Optional native value override. Defaults to the compiled\n   * `transactionRequest.value` when omitted.\n   */\n  readonly value?: bigint | string;\n}\n\n/**\n * Assembles a {@link SimulateRequest} from a compile result and the\n * caller-supplied chain, signer, and tracked balances. Pure: performs no\n * network I/O, does not mutate its input, and returns a fresh object.\n *\n * Bridges the common case — simulate the transaction you just compiled —\n * without coupling raw-transaction simulation to the flow builder. The\n * `value` defaults to the compiled transaction's value unless overridden.\n *\n * @example\n * ```ts\n * const compiled = await builder.compile({ inputs: { ... }, signer: '0x1111...' });\n * const req = buildSimulateRequest({\n *   result: compiled,\n *   chainId: 1,\n *   signer: '0x1111111111111111111111111111111111111111',\n *   trackedBalances: [{ token: '0xA0b8...', owner: '0x1111...' }],\n * });\n * const sim = await sdk.client.simulate(req);\n * ```\n */\nexport const buildSimulateRequest = (\n  input: BuildSimulateRequestInput,\n): SimulateRequest => {\n  const { result, chainId, signer, trackedBalances, requirements, block } =\n    input;\n  // A settle-only flow authored with `funding: 'external'` compiles to an\n  // empty program: the success response carries no `transactionRequest`, so\n  // there is nothing to simulate — the required submissions are the\n  // `actions` entries, submitted directly.\n  if (result.transactionRequest === undefined) {\n    throw new Error(\n      'buildSimulateRequest: the compile result has no transactionRequest (empty compiled program — a settle-only external-funding flow); submit the `actions` entries instead of simulating',\n    );\n  }\n  return {\n    chainId,\n    from: signer,\n    to: result.transactionRequest.to,\n    data: result.transactionRequest.data,\n    value: input.value ?? result.transactionRequest.value,\n    block,\n    requirements,\n    trackedBalances,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiEO,MAAM,uBAAuB,CAClC,UACoB;AACpB,QAAM,EAAE,QAAQ,SAAS,QAAQ,iBAAiB,cAAc,MAAM,IACpE;AAKF,MAAI,OAAO,uBAAuB,QAAW;AAC3C,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA,MAAM;AAAA,IACN,IAAI,OAAO,mBAAmB;AAAA,IAC9B,MAAM,OAAO,mBAAmB;AAAA,IAChC,OAAO,MAAM,SAAS,OAAO,mBAAmB;AAAA,IAChD;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/run/simulate.d.cts

@@ -7,8 +7,11 @@ import { ComposeCompileResult, TrackedBalance, SlotFinderRequirement, SimulateRe
 interface BuildSimulateRequestInput {
     /**
      * A result from `builder.compile(...)` / `client.compile(...)`. Both
-     * `success` and `partial` results carry a `transactionRequest`, so either is
-     * valid input — the helper does not discriminate on `status`.
+     * `success` and `partial` results are valid input — the helper does not
+     * discriminate on `status`. A success result for an empty compiled program
+     * (a settle-only `funding: 'external'` flow) carries no
+     * `transactionRequest`; there is nothing to simulate and this helper
+     * throws — submit the result's `actions` entries directly instead.
      */
     readonly result: ComposeCompileResult;
     /** EVM chain id. A compile result does not carry the target chain. */

package/dist/run/simulate.d.ts

@@ -7,8 +7,11 @@ import { ComposeCompileResult, TrackedBalance, SlotFinderRequirement, SimulateRe
 interface BuildSimulateRequestInput {
     /**
      * A result from `builder.compile(...)` / `client.compile(...)`. Both
-     * `success` and `partial` results carry a `transactionRequest`, so either is
-     * valid input — the helper does not discriminate on `status`.
+     * `success` and `partial` results are valid input — the helper does not
+     * discriminate on `status`. A success result for an empty compiled program
+     * (a settle-only `funding: 'external'` flow) carries no
+     * `transactionRequest`; there is nothing to simulate and this helper
+     * throws — submit the result's `actions` entries directly instead.
      */
     readonly result: ComposeCompileResult;
     /** EVM chain id. A compile result does not carry the target chain. */

package/dist/run/simulate.js

@@ -1,5 +1,10 @@
 const buildSimulateRequest = (input) => {
   const { result, chainId, signer, trackedBalances, requirements, block } = input;
+  if (result.transactionRequest === void 0) {
+    throw new Error(
+      "buildSimulateRequest: the compile result has no transactionRequest (empty compiled program \u2014 a settle-only external-funding flow); submit the `actions` entries instead of simulating"
+    );
+  }
   return {
     chainId,
     from: signer,

package/dist/run/simulate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/simulate.ts"],"sourcesContent":["import type {\n  ComposeCompileResult,\n  SimulateRequest,\n  SlotFinderRequirement,\n  TrackedBalance,\n} from '@lifi/compose-spec';\n\n/**\n * Input for {@link buildSimulateRequest}: a compile result plus the fields a\n * simulation needs that a compiled flow does not carry.\n */\nexport interface BuildSimulateRequestInput {\n  /**\n   * A result from `builder.compile(...)` / `client.compile(...)`. Both\n   * `success` and `partial` results carry a `transactionRequest`, so either is\n   * valid input — the helper does not discriminate on `status`.\n   */\n  readonly result: ComposeCompileResult;\n  /** EVM chain id. A compile result does not carry the target chain. */\n  readonly chainId: number;\n  /**\n   * The transaction sender (`from`). A compile result does not carry the\n   * signer, so it must be supplied here.\n   */\n  readonly signer: string;\n  /**\n   * Balances to watch across the simulation. These cannot be inferred from a\n   * flow and must be supplied by the caller.\n   */\n  readonly trackedBalances: readonly TrackedBalance[];\n  /** Optional funding instructions applied before simulation. */\n  readonly requirements?: readonly SlotFinderRequirement[];\n  /** Optional block to pin the simulation to. Omitted ⇒ chain head. */\n  readonly block?: number;\n  /**\n   * Optional native value override. Defaults to the compiled\n   * `transactionRequest.value` when omitted.\n   */\n  readonly value?: bigint | string;\n}\n\n/**\n * Assembles a {@link SimulateRequest} from a compile result and the\n * caller-supplied chain, signer, and tracked balances. Pure: performs no\n * network I/O, does not mutate its input, and returns a fresh object.\n *\n * Bridges the common case — simulate the transaction you just compiled —\n * without coupling raw-transaction simulation to the flow builder. The\n * `value` defaults to the compiled transaction's value unless overridden.\n *\n * @example\n * ```ts\n * const compiled = await builder.compile({ inputs: { ... }, signer: '0x1111...' });\n * const req = buildSimulateRequest({\n *   result: compiled,\n *   chainId: 1,\n *   signer: '0x1111111111111111111111111111111111111111',\n *   trackedBalances: [{ token: '0xA0b8...', owner: '0x1111...' }],\n * });\n * const sim = await sdk.client.simulate(req);\n * ```\n */\nexport const buildSimulateRequest = (\n  input: BuildSimulateRequestInput,\n): SimulateRequest => {\n  const { result, chainId, signer, trackedBalances, requirements, block } =\n    input;\n  return {\n    chainId,\n    from: signer,\n    to: result.transactionRequest.to,\n    data: result.transactionRequest.data,\n    value: input.value ?? result.transactionRequest.value,\n    block,\n    requirements,\n    trackedBalances,\n  };\n};\n"],"mappings":"AA8DO,MAAM,uBAAuB,CAClC,UACoB;AACpB,QAAM,EAAE,QAAQ,SAAS,QAAQ,iBAAiB,cAAc,MAAM,IACpE;AACF,SAAO;AAAA,IACL;AAAA,IACA,MAAM;AAAA,IACN,IAAI,OAAO,mBAAmB;AAAA,IAC9B,MAAM,OAAO,mBAAmB;AAAA,IAChC,OAAO,MAAM,SAAS,OAAO,mBAAmB;AAAA,IAChD;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/run/simulate.ts"],"sourcesContent":["import type {\n  ComposeCompileResult,\n  SimulateRequest,\n  SlotFinderRequirement,\n  TrackedBalance,\n} from '@lifi/compose-spec';\n\n/**\n * Input for {@link buildSimulateRequest}: a compile result plus the fields a\n * simulation needs that a compiled flow does not carry.\n */\nexport interface BuildSimulateRequestInput {\n  /**\n   * A result from `builder.compile(...)` / `client.compile(...)`. Both\n   * `success` and `partial` results are valid input — the helper does not\n   * discriminate on `status`. A success result for an empty compiled program\n   * (a settle-only `funding: 'external'` flow) carries no\n   * `transactionRequest`; there is nothing to simulate and this helper\n   * throws — submit the result's `actions` entries directly instead.\n   */\n  readonly result: ComposeCompileResult;\n  /** EVM chain id. A compile result does not carry the target chain. */\n  readonly chainId: number;\n  /**\n   * The transaction sender (`from`). A compile result does not carry the\n   * signer, so it must be supplied here.\n   */\n  readonly signer: string;\n  /**\n   * Balances to watch across the simulation. These cannot be inferred from a\n   * flow and must be supplied by the caller.\n   */\n  readonly trackedBalances: readonly TrackedBalance[];\n  /** Optional funding instructions applied before simulation. */\n  readonly requirements?: readonly SlotFinderRequirement[];\n  /** Optional block to pin the simulation to. Omitted ⇒ chain head. */\n  readonly block?: number;\n  /**\n   * Optional native value override. Defaults to the compiled\n   * `transactionRequest.value` when omitted.\n   */\n  readonly value?: bigint | string;\n}\n\n/**\n * Assembles a {@link SimulateRequest} from a compile result and the\n * caller-supplied chain, signer, and tracked balances. Pure: performs no\n * network I/O, does not mutate its input, and returns a fresh object.\n *\n * Bridges the common case — simulate the transaction you just compiled —\n * without coupling raw-transaction simulation to the flow builder. The\n * `value` defaults to the compiled transaction's value unless overridden.\n *\n * @example\n * ```ts\n * const compiled = await builder.compile({ inputs: { ... }, signer: '0x1111...' });\n * const req = buildSimulateRequest({\n *   result: compiled,\n *   chainId: 1,\n *   signer: '0x1111111111111111111111111111111111111111',\n *   trackedBalances: [{ token: '0xA0b8...', owner: '0x1111...' }],\n * });\n * const sim = await sdk.client.simulate(req);\n * ```\n */\nexport const buildSimulateRequest = (\n  input: BuildSimulateRequestInput,\n): SimulateRequest => {\n  const { result, chainId, signer, trackedBalances, requirements, block } =\n    input;\n  // A settle-only flow authored with `funding: 'external'` compiles to an\n  // empty program: the success response carries no `transactionRequest`, so\n  // there is nothing to simulate — the required submissions are the\n  // `actions` entries, submitted directly.\n  if (result.transactionRequest === undefined) {\n    throw new Error(\n      'buildSimulateRequest: the compile result has no transactionRequest (empty compiled program — a settle-only external-funding flow); submit the `actions` entries instead of simulating',\n    );\n  }\n  return {\n    chainId,\n    from: signer,\n    to: result.transactionRequest.to,\n    data: result.transactionRequest.data,\n    value: input.value ?? result.transactionRequest.value,\n    block,\n    requirements,\n    trackedBalances,\n  };\n};\n"],"mappings":"AAiEO,MAAM,uBAAuB,CAClC,UACoB;AACpB,QAAM,EAAE,QAAQ,SAAS,QAAQ,iBAAiB,cAAc,MAAM,IACpE;AAKF,MAAI,OAAO,uBAAuB,QAAW;AAC3C,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA,MAAM;AAAA,IACN,IAAI,OAAO,mBAAmB;AAAA,IAC9B,MAAM,OAAO,mBAAmB;AAAA,IAChC,OAAO,MAAM,SAAS,OAAO,mBAAmB;AAAA,IAChD;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/sdk.cjs

@@ -39,6 +39,7 @@ const createComposeSdk = (options) => {
       maxPriceImpactBps: run.maxPriceImpactBps,
       sweepTo: run.sweepTo,
       simulationPolicy: run.simulationPolicy,
+      simulateUserProgram: run.simulateUserProgram,
       checkOnChainAllowances: run.checkOnChainAllowances
     })
   });
@@ -55,7 +56,9 @@ const createComposeSdk = (options) => {
   return {
     client: composeClient,
     flow,
+    getSupportedChains: composeClient.getChains,
     request,
+    route: composeClient.route,
     simulate: composeClient.simulate
   };
 };

package/dist/sdk.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sdk.ts"],"sourcesContent":["import type {\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  InputSpec,\n  SimulateRequest,\n  SimulateResult,\n} from '@lifi/compose-spec';\n\nimport {\n  createFlowBuilderCore,\n  type FlowBuilderCore,\n  type FlowOptions,\n  type TypedFlow,\n} from './authoring/FlowBuilderCore.js';\nimport { type ComposeClient, createComposeClient } from './client.js';\nimport {\n  bindGeneratedOps,\n  type GeneratedOps,\n} from './generated/operations.generated.js';\nimport { buildRun, type ComposeRunInput } from './run/inputs.js';\nimport type { InputSchema } from './types.js';\n\nexport type { ComposeRunInput };\n\n/**\n * A flow builder augmented with generated operation methods and a `compile` method\n * that submits the flow to the Compose backend for compilation.\n *\n * Created via {@link ComposeSdk.flow}.\n *\n * @typeParam T - The input schema describing the flow's required inputs.\n */\nexport type FlowBuilder<T extends InputSchema = InputSchema> =\n  FlowBuilderCore<T> &\n    GeneratedOps & {\n      /**\n       * Builds the flow document from the current builder state and submits it\n       * to the Compose API for compilation.\n       *\n       * @param run - Runtime inputs, preconditions, and signer address.\n       * @returns The compiled transaction calldata and metadata.\n       * @throws {@link ComposeError} on network, validation, or server errors.\n       *\n       * @example\n       * ```ts\n       * const result = await builder.compile({\n       *   inputs: { token: materialisers.balanceOf({}) },\n       *   signer: '0xYourAddress...',\n       * });\n       * console.log(result.calldata);\n       * ```\n       */\n      readonly compile: (\n        run: ComposeRunInput<T>,\n      ) => Promise<ComposeCompileResult>;\n    };\n\n/**\n * Configuration for creating a Compose SDK instance.\n */\nexport interface ComposeSdkOptions {\n  /** Base URL of the Compose API (e.g. `\"https://li.quest\"`). */\n  readonly baseUrl: string;\n  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */\n  readonly fetch?: typeof globalThis.fetch;\n  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */\n  readonly apiKey: string;\n}\n\n/**\n * The top-level Compose SDK interface.\n *\n * Provides methods to build flows, compile them into executable calldata, and\n * interact with the Compose API directly.\n *\n * @example\n * ```ts\n * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';\n *\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n *\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },\n * });\n *\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.usdc },\n *   config: { resourceOut: resources.native(1) },\n * });\n *\n * const result = await builder.compile({\n *   inputs: { usdc: materialisers.balanceOf({}) },\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport interface ComposeSdk {\n  /** Low-level HTTP client for the Compose API. */\n  readonly client: ComposeClient;\n  /**\n   * Creates a new flow builder targeting the given chain.\n   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).\n   * @param options - Flow configuration including input declarations.\n   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.\n   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.\n   */\n  readonly flow: <T extends InputSchema>(\n    chainId: number,\n    options: FlowOptions<T>,\n  ) => FlowBuilder<T>;\n  /**\n   * Builds a raw compile request without sending it. Useful for inspecting the\n   * request payload or submitting it through a custom transport.\n   * @param flow - A built flow document (from `builder.build()`).\n   * @param run - Runtime inputs, preconditions, and signer address.\n   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.\n   */\n  readonly request: <T extends InputSchema>(\n    flow: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ) => ComposeCompileRequest;\n  /**\n   * Simulates a raw, pre-encoded transaction. Thin pass-through to\n   * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`\n   * result discrimination and error behaviour. Pair with `buildSimulateRequest`\n   * to assemble the request from a compile result.\n   *\n   * @param request - The raw transaction plus funding `requirements` and\n   *   `trackedBalances`.\n   * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).\n   * @throws {@link ComposeError} on network, validation, or server errors.\n   */\n  readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;\n}\n\n/**\n * Creates a new Compose SDK instance.\n *\n * @param options - SDK configuration including the API base URL, required API key, and optional fetch implementation.\n * @returns A {@link ComposeSdk} instance.\n *\n * @example\n * ```ts\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n * ```\n */\nexport const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {\n  const composeClient = createComposeClient(options);\n\n  const request = <T extends InputSchema>(\n    flowDoc: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ): ComposeCompileRequest => ({\n    flow: flowDoc,\n    run: buildRun({\n      inputs: run.inputs as Record<string, InputSpec>,\n      preconditions: run.preconditions,\n      signer: run.signer,\n      assumptions: run.assumptions as Record<string, bigint> | undefined,\n      referrer: run.referrer,\n      integratorFeeBps: run.integratorFeeBps,\n      maxPriceImpactBps: run.maxPriceImpactBps,\n      sweepTo: run.sweepTo,\n      simulationPolicy: run.simulationPolicy,\n      checkOnChainAllowances: run.checkOnChainAllowances,\n    }),\n  });\n\n  const flow = <T extends InputSchema>(\n    chainId: number,\n    opts: FlowOptions<T>,\n  ): FlowBuilder<T> => {\n    const core = createFlowBuilderCore(chainId, opts);\n    const builder = Object.assign(core, bindGeneratedOps(core));\n\n    const compile = async (\n      run: ComposeRunInput<T>,\n    ): Promise<ComposeCompileResult> => {\n      const flowDoc = builder.build();\n      const req = request(flowDoc, run);\n      return composeClient.compile(req);\n    };\n\n    return Object.assign(builder, { compile });\n  };\n\n  return {\n    client: composeClient,\n    flow,\n    request,\n    simulate: composeClient.simulate,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,6BAKO;AACP,oBAAwD;AACxD,kCAGO;AACP,oBAA+C;AA+HxC,MAAM,mBAAmB,CAAC,YAA2C;AAC1E,QAAM,oBAAgB,mCAAoB,OAAO;AAEjD,QAAM,UAAU,CACd,SACA,SAC2B;AAAA,IAC3B,MAAM;AAAA,IACN,SAAK,wBAAS;AAAA,MACZ,QAAQ,IAAI;AAAA,MACZ,eAAe,IAAI;AAAA,MACnB,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,UAAU,IAAI;AAAA,MACd,kBAAkB,IAAI;AAAA,MACtB,mBAAmB,IAAI;AAAA,MACvB,SAAS,IAAI;AAAA,MACb,kBAAkB,IAAI;AAAA,MACtB,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,CACX,SACA,SACmB;AACnB,UAAM,WAAO,8CAAsB,SAAS,IAAI;AAChD,UAAM,UAAU,OAAO,OAAO,UAAM,8CAAiB,IAAI,CAAC;AAE1D,UAAM,UAAU,OACd,QACkC;AAClC,YAAM,UAAU,QAAQ,MAAM;AAC9B,YAAM,MAAM,QAAQ,SAAS,GAAG;AAChC,aAAO,cAAc,QAAQ,GAAG;AAAA,IAClC;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAAA,EAC3C;AAEA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,UAAU,cAAc;AAAA,EAC1B;AACF;","names":[]}
+{"version":3,"sources":["../src/sdk.ts"],"sourcesContent":["import type {\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeRouteRequest,\n  InputSpec,\n  SimulateRequest,\n  SimulateResult,\n} from '@lifi/compose-spec';\n\nimport {\n  createFlowBuilderCore,\n  type FlowBuilderCore,\n  type FlowOptions,\n  type TypedFlow,\n} from './authoring/FlowBuilderCore.js';\nimport { type ComposeClient, createComposeClient } from './client.js';\nimport type { ChainSummary } from './discovery.js';\nimport {\n  bindGeneratedOps,\n  type GeneratedOps,\n} from './generated/operations.generated.js';\nimport { buildRun, type ComposeRunInput } from './run/inputs.js';\nimport type { InputSchema } from './types.js';\n\nexport type { ComposeRunInput };\n\n/**\n * A flow builder augmented with generated operation methods and a `compile` method\n * that submits the flow to the Compose backend for compilation.\n *\n * Created via {@link ComposeSdk.flow}.\n *\n * @typeParam T - The input schema describing the flow's required inputs.\n */\nexport type FlowBuilder<T extends InputSchema = InputSchema> =\n  FlowBuilderCore<T> &\n    GeneratedOps & {\n      /**\n       * Builds the flow document from the current builder state and submits it\n       * to the Compose API for compilation.\n       *\n       * @param run - Runtime inputs, preconditions, and signer address.\n       * @returns The compiled transaction calldata and metadata.\n       * @throws {@link ComposeError} on network, validation, or server errors.\n       *\n       * @example\n       * ```ts\n       * const result = await builder.compile({\n       *   inputs: { token: materialisers.balanceOf({}) },\n       *   signer: '0xYourAddress...',\n       * });\n       * console.log(result.calldata);\n       * ```\n       */\n      readonly compile: (\n        run: ComposeRunInput<T>,\n      ) => Promise<ComposeCompileResult>;\n    };\n\n/**\n * Configuration for creating a Compose SDK instance.\n */\nexport interface ComposeSdkOptions {\n  /** Base URL of the Compose API (e.g. `\"https://li.quest\"`). */\n  readonly baseUrl: string;\n  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */\n  readonly fetch?: typeof globalThis.fetch;\n  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */\n  readonly apiKey: string;\n}\n\n/**\n * The top-level Compose SDK interface.\n *\n * Provides methods to build flows, compile them into executable calldata, and\n * interact with the Compose API directly.\n *\n * @example\n * ```ts\n * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';\n *\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n *\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },\n * });\n *\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.usdc },\n *   config: { resourceOut: resources.native(1) },\n * });\n *\n * const result = await builder.compile({\n *   inputs: { usdc: materialisers.balanceOf({}) },\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport interface ComposeSdk {\n  /** Low-level HTTP client for the Compose API. */\n  readonly client: ComposeClient;\n  /**\n   * Creates a new flow builder targeting the given chain.\n   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).\n   * @param options - Flow configuration including input declarations.\n   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.\n   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.\n   */\n  readonly flow: <T extends InputSchema>(\n    chainId: number,\n    options: FlowOptions<T>,\n  ) => FlowBuilder<T>;\n  /**\n   * Fetches the chains this Compose deployment supports, ascending by\n   * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it\n   * for what \"supported\" means and for the caching caveat.\n   *\n   * Each entry pairs the `chainId` with a display `name`, so one call both\n   * gates a chain selector and labels it. Key on `chainId`; `name` is a\n   * deployment-maintained label that can change.\n   *\n   * Use it to fail fast before building a flow for a chain the server would\n   * reject.\n   *\n   * @returns The supported chains, ascending by `chainId`.\n   * @throws {@link ComposeError} on network or server errors.\n   *\n   * @example\n   * ```ts\n   * const chains = await sdk.getSupportedChains();\n   * if (!chains.some((c) => c.chainId === 8453)) {\n   *   throw new Error('Base is not supported');\n   * }\n   * for (const { chainId, name } of chains) {\n   *   console.log(`${name} (${chainId})`);\n   * }\n   * ```\n   */\n  readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;\n  /**\n   * Builds a raw compile request without sending it. Useful for inspecting the\n   * request payload or submitting it through a custom transport.\n   * @param flow - A built flow document (from `builder.build()`).\n   * @param run - Runtime inputs, preconditions, and signer address.\n   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.\n   */\n  readonly request: <T extends InputSchema>(\n    flow: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ) => ComposeCompileRequest;\n  /**\n   * Compiles a token pair on one chain — as of today a single zap step over\n   * one routing-catalog edge. Thin pass-through to\n   * {@link ComposeClient.route}; see it for the current single-step limit,\n   * when to prefer `flow(...).compile(...)`, the `success` / `partial`\n   * discrimination, and error behaviour. Build the `amount` with\n   * `routeAmount.exact(...)` / `routeAmount.all(...)`.\n   *\n   * @param request - The from/to token pair, amount, signer, and route options.\n   * @returns A discriminated result: `status: 'success'` or `status: 'partial'`.\n   * @throws {@link ComposeError} on network, validation, or server errors.\n   */\n  readonly route: (\n    request: ComposeRouteRequest,\n  ) => Promise<ComposeCompileResult>;\n  /**\n   * Simulates a raw, pre-encoded transaction. Thin pass-through to\n   * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`\n   * result discrimination and error behaviour. Pair with `buildSimulateRequest`\n   * to assemble the request from a compile result.\n   *\n   * @param request - The raw transaction plus funding `requirements` and\n   *   `trackedBalances`.\n   * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).\n   * @throws {@link ComposeError} on network, validation, or server errors.\n   */\n  readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;\n}\n\n/**\n * Creates a new Compose SDK instance.\n *\n * @param options - SDK configuration including the API base URL, required API key, and optional fetch implementation.\n * @returns A {@link ComposeSdk} instance.\n *\n * @example\n * ```ts\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n * ```\n */\nexport const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {\n  const composeClient = createComposeClient(options);\n\n  const request = <T extends InputSchema>(\n    flowDoc: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ): ComposeCompileRequest => ({\n    flow: flowDoc,\n    run: buildRun({\n      inputs: run.inputs as Record<string, InputSpec>,\n      preconditions: run.preconditions,\n      signer: run.signer,\n      assumptions: run.assumptions as Record<string, bigint> | undefined,\n      referrer: run.referrer,\n      integratorFeeBps: run.integratorFeeBps,\n      maxPriceImpactBps: run.maxPriceImpactBps,\n      sweepTo: run.sweepTo,\n      simulationPolicy: run.simulationPolicy,\n      simulateUserProgram: run.simulateUserProgram,\n      checkOnChainAllowances: run.checkOnChainAllowances,\n    }),\n  });\n\n  const flow = <T extends InputSchema>(\n    chainId: number,\n    opts: FlowOptions<T>,\n  ): FlowBuilder<T> => {\n    const core = createFlowBuilderCore(chainId, opts);\n    const builder = Object.assign(core, bindGeneratedOps(core));\n\n    const compile = async (\n      run: ComposeRunInput<T>,\n    ): Promise<ComposeCompileResult> => {\n      const flowDoc = builder.build();\n      const req = request(flowDoc, run);\n      return composeClient.compile(req);\n    };\n\n    return Object.assign(builder, { compile });\n  };\n\n  return {\n    client: composeClient,\n    flow,\n    getSupportedChains: composeClient.getChains,\n    request,\n    route: composeClient.route,\n    simulate: composeClient.simulate,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,6BAKO;AACP,oBAAwD;AAExD,kCAGO;AACP,oBAA+C;AAyKxC,MAAM,mBAAmB,CAAC,YAA2C;AAC1E,QAAM,oBAAgB,mCAAoB,OAAO;AAEjD,QAAM,UAAU,CACd,SACA,SAC2B;AAAA,IAC3B,MAAM;AAAA,IACN,SAAK,wBAAS;AAAA,MACZ,QAAQ,IAAI;AAAA,MACZ,eAAe,IAAI;AAAA,MACnB,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,UAAU,IAAI;AAAA,MACd,kBAAkB,IAAI;AAAA,MACtB,mBAAmB,IAAI;AAAA,MACvB,SAAS,IAAI;AAAA,MACb,kBAAkB,IAAI;AAAA,MACtB,qBAAqB,IAAI;AAAA,MACzB,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,CACX,SACA,SACmB;AACnB,UAAM,WAAO,8CAAsB,SAAS,IAAI;AAChD,UAAM,UAAU,OAAO,OAAO,UAAM,8CAAiB,IAAI,CAAC;AAE1D,UAAM,UAAU,OACd,QACkC;AAClC,YAAM,UAAU,QAAQ,MAAM;AAC9B,YAAM,MAAM,QAAQ,SAAS,GAAG;AAChC,aAAO,cAAc,QAAQ,GAAG;AAAA,IAClC;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAAA,EAC3C;AAEA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA,oBAAoB,cAAc;AAAA,IAClC;AAAA,IACA,OAAO,cAAc;AAAA,IACrB,UAAU,cAAc;AAAA,EAC1B;AACF;","names":[]}

package/dist/sdk.d.cts

@@ -1,11 +1,11 @@
-import { ComposeCompileResult, ComposeCompileRequest, SimulateRequest, SimulateResult } from '@lifi/compose-spec';
+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 './discovery.cjs';
 import './authoring/signatureArgs.cjs';
 import 'abitype';
 import './generated/config.generated.cjs';
@@ -87,6 +87,33 @@ interface ComposeSdk {
      * @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.
@@ -95,6 +122,19 @@ interface ComposeSdk {
      * @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 — as of today a single zap step over
+     * one routing-catalog edge. Thin pass-through to
+     * {@link ComposeClient.route}; see it for the current single-step limit,
+     * 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`

package/dist/sdk.d.ts

@@ -1,11 +1,11 @@
-import { ComposeCompileResult, ComposeCompileRequest, SimulateRequest, SimulateResult } from '@lifi/compose-spec';
+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 './discovery.js';
 import './authoring/signatureArgs.js';
 import 'abitype';
 import './generated/config.generated.js';
@@ -87,6 +87,33 @@ interface ComposeSdk {
      * @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.
@@ -95,6 +122,19 @@ interface ComposeSdk {
      * @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 — as of today a single zap step over
+     * one routing-catalog edge. Thin pass-through to
+     * {@link ComposeClient.route}; see it for the current single-step limit,
+     * 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`

package/dist/sdk.js

@@ -20,6 +20,7 @@ const createComposeSdk = (options) => {
       maxPriceImpactBps: run.maxPriceImpactBps,
       sweepTo: run.sweepTo,
       simulationPolicy: run.simulationPolicy,
+      simulateUserProgram: run.simulateUserProgram,
       checkOnChainAllowances: run.checkOnChainAllowances
     })
   });
@@ -36,7 +37,9 @@ const createComposeSdk = (options) => {
   return {
     client: composeClient,
     flow,
+    getSupportedChains: composeClient.getChains,
     request,
+    route: composeClient.route,
     simulate: composeClient.simulate
   };
 };

package/dist/sdk.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sdk.ts"],"sourcesContent":["import type {\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  InputSpec,\n  SimulateRequest,\n  SimulateResult,\n} from '@lifi/compose-spec';\n\nimport {\n  createFlowBuilderCore,\n  type FlowBuilderCore,\n  type FlowOptions,\n  type TypedFlow,\n} from './authoring/FlowBuilderCore.js';\nimport { type ComposeClient, createComposeClient } from './client.js';\nimport {\n  bindGeneratedOps,\n  type GeneratedOps,\n} from './generated/operations.generated.js';\nimport { buildRun, type ComposeRunInput } from './run/inputs.js';\nimport type { InputSchema } from './types.js';\n\nexport type { ComposeRunInput };\n\n/**\n * A flow builder augmented with generated operation methods and a `compile` method\n * that submits the flow to the Compose backend for compilation.\n *\n * Created via {@link ComposeSdk.flow}.\n *\n * @typeParam T - The input schema describing the flow's required inputs.\n */\nexport type FlowBuilder<T extends InputSchema = InputSchema> =\n  FlowBuilderCore<T> &\n    GeneratedOps & {\n      /**\n       * Builds the flow document from the current builder state and submits it\n       * to the Compose API for compilation.\n       *\n       * @param run - Runtime inputs, preconditions, and signer address.\n       * @returns The compiled transaction calldata and metadata.\n       * @throws {@link ComposeError} on network, validation, or server errors.\n       *\n       * @example\n       * ```ts\n       * const result = await builder.compile({\n       *   inputs: { token: materialisers.balanceOf({}) },\n       *   signer: '0xYourAddress...',\n       * });\n       * console.log(result.calldata);\n       * ```\n       */\n      readonly compile: (\n        run: ComposeRunInput<T>,\n      ) => Promise<ComposeCompileResult>;\n    };\n\n/**\n * Configuration for creating a Compose SDK instance.\n */\nexport interface ComposeSdkOptions {\n  /** Base URL of the Compose API (e.g. `\"https://li.quest\"`). */\n  readonly baseUrl: string;\n  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */\n  readonly fetch?: typeof globalThis.fetch;\n  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */\n  readonly apiKey: string;\n}\n\n/**\n * The top-level Compose SDK interface.\n *\n * Provides methods to build flows, compile them into executable calldata, and\n * interact with the Compose API directly.\n *\n * @example\n * ```ts\n * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';\n *\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n *\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },\n * });\n *\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.usdc },\n *   config: { resourceOut: resources.native(1) },\n * });\n *\n * const result = await builder.compile({\n *   inputs: { usdc: materialisers.balanceOf({}) },\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport interface ComposeSdk {\n  /** Low-level HTTP client for the Compose API. */\n  readonly client: ComposeClient;\n  /**\n   * Creates a new flow builder targeting the given chain.\n   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).\n   * @param options - Flow configuration including input declarations.\n   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.\n   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.\n   */\n  readonly flow: <T extends InputSchema>(\n    chainId: number,\n    options: FlowOptions<T>,\n  ) => FlowBuilder<T>;\n  /**\n   * Builds a raw compile request without sending it. Useful for inspecting the\n   * request payload or submitting it through a custom transport.\n   * @param flow - A built flow document (from `builder.build()`).\n   * @param run - Runtime inputs, preconditions, and signer address.\n   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.\n   */\n  readonly request: <T extends InputSchema>(\n    flow: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ) => ComposeCompileRequest;\n  /**\n   * Simulates a raw, pre-encoded transaction. Thin pass-through to\n   * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`\n   * result discrimination and error behaviour. Pair with `buildSimulateRequest`\n   * to assemble the request from a compile result.\n   *\n   * @param request - The raw transaction plus funding `requirements` and\n   *   `trackedBalances`.\n   * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).\n   * @throws {@link ComposeError} on network, validation, or server errors.\n   */\n  readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;\n}\n\n/**\n * Creates a new Compose SDK instance.\n *\n * @param options - SDK configuration including the API base URL, required API key, and optional fetch implementation.\n * @returns A {@link ComposeSdk} instance.\n *\n * @example\n * ```ts\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n * ```\n */\nexport const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {\n  const composeClient = createComposeClient(options);\n\n  const request = <T extends InputSchema>(\n    flowDoc: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ): ComposeCompileRequest => ({\n    flow: flowDoc,\n    run: buildRun({\n      inputs: run.inputs as Record<string, InputSpec>,\n      preconditions: run.preconditions,\n      signer: run.signer,\n      assumptions: run.assumptions as Record<string, bigint> | undefined,\n      referrer: run.referrer,\n      integratorFeeBps: run.integratorFeeBps,\n      maxPriceImpactBps: run.maxPriceImpactBps,\n      sweepTo: run.sweepTo,\n      simulationPolicy: run.simulationPolicy,\n      checkOnChainAllowances: run.checkOnChainAllowances,\n    }),\n  });\n\n  const flow = <T extends InputSchema>(\n    chainId: number,\n    opts: FlowOptions<T>,\n  ): FlowBuilder<T> => {\n    const core = createFlowBuilderCore(chainId, opts);\n    const builder = Object.assign(core, bindGeneratedOps(core));\n\n    const compile = async (\n      run: ComposeRunInput<T>,\n    ): Promise<ComposeCompileResult> => {\n      const flowDoc = builder.build();\n      const req = request(flowDoc, run);\n      return composeClient.compile(req);\n    };\n\n    return Object.assign(builder, { compile });\n  };\n\n  return {\n    client: composeClient,\n    flow,\n    request,\n    simulate: composeClient.simulate,\n  };\n};\n"],"mappings":"AAQA;AAAA,EACE;AAAA,OAIK;AACP,SAA6B,2BAA2B;AACxD;AAAA,EACE;AAAA,OAEK;AACP,SAAS,gBAAsC;AA+HxC,MAAM,mBAAmB,CAAC,YAA2C;AAC1E,QAAM,gBAAgB,oBAAoB,OAAO;AAEjD,QAAM,UAAU,CACd,SACA,SAC2B;AAAA,IAC3B,MAAM;AAAA,IACN,KAAK,SAAS;AAAA,MACZ,QAAQ,IAAI;AAAA,MACZ,eAAe,IAAI;AAAA,MACnB,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,UAAU,IAAI;AAAA,MACd,kBAAkB,IAAI;AAAA,MACtB,mBAAmB,IAAI;AAAA,MACvB,SAAS,IAAI;AAAA,MACb,kBAAkB,IAAI;AAAA,MACtB,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,CACX,SACA,SACmB;AACnB,UAAM,OAAO,sBAAsB,SAAS,IAAI;AAChD,UAAM,UAAU,OAAO,OAAO,MAAM,iBAAiB,IAAI,CAAC;AAE1D,UAAM,UAAU,OACd,QACkC;AAClC,YAAM,UAAU,QAAQ,MAAM;AAC9B,YAAM,MAAM,QAAQ,SAAS,GAAG;AAChC,aAAO,cAAc,QAAQ,GAAG;AAAA,IAClC;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAAA,EAC3C;AAEA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,UAAU,cAAc;AAAA,EAC1B;AACF;","names":[]}
+{"version":3,"sources":["../src/sdk.ts"],"sourcesContent":["import type {\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeRouteRequest,\n  InputSpec,\n  SimulateRequest,\n  SimulateResult,\n} from '@lifi/compose-spec';\n\nimport {\n  createFlowBuilderCore,\n  type FlowBuilderCore,\n  type FlowOptions,\n  type TypedFlow,\n} from './authoring/FlowBuilderCore.js';\nimport { type ComposeClient, createComposeClient } from './client.js';\nimport type { ChainSummary } from './discovery.js';\nimport {\n  bindGeneratedOps,\n  type GeneratedOps,\n} from './generated/operations.generated.js';\nimport { buildRun, type ComposeRunInput } from './run/inputs.js';\nimport type { InputSchema } from './types.js';\n\nexport type { ComposeRunInput };\n\n/**\n * A flow builder augmented with generated operation methods and a `compile` method\n * that submits the flow to the Compose backend for compilation.\n *\n * Created via {@link ComposeSdk.flow}.\n *\n * @typeParam T - The input schema describing the flow's required inputs.\n */\nexport type FlowBuilder<T extends InputSchema = InputSchema> =\n  FlowBuilderCore<T> &\n    GeneratedOps & {\n      /**\n       * Builds the flow document from the current builder state and submits it\n       * to the Compose API for compilation.\n       *\n       * @param run - Runtime inputs, preconditions, and signer address.\n       * @returns The compiled transaction calldata and metadata.\n       * @throws {@link ComposeError} on network, validation, or server errors.\n       *\n       * @example\n       * ```ts\n       * const result = await builder.compile({\n       *   inputs: { token: materialisers.balanceOf({}) },\n       *   signer: '0xYourAddress...',\n       * });\n       * console.log(result.calldata);\n       * ```\n       */\n      readonly compile: (\n        run: ComposeRunInput<T>,\n      ) => Promise<ComposeCompileResult>;\n    };\n\n/**\n * Configuration for creating a Compose SDK instance.\n */\nexport interface ComposeSdkOptions {\n  /** Base URL of the Compose API (e.g. `\"https://li.quest\"`). */\n  readonly baseUrl: string;\n  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */\n  readonly fetch?: typeof globalThis.fetch;\n  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */\n  readonly apiKey: string;\n}\n\n/**\n * The top-level Compose SDK interface.\n *\n * Provides methods to build flows, compile them into executable calldata, and\n * interact with the Compose API directly.\n *\n * @example\n * ```ts\n * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';\n *\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n *\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },\n * });\n *\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.usdc },\n *   config: { resourceOut: resources.native(1) },\n * });\n *\n * const result = await builder.compile({\n *   inputs: { usdc: materialisers.balanceOf({}) },\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport interface ComposeSdk {\n  /** Low-level HTTP client for the Compose API. */\n  readonly client: ComposeClient;\n  /**\n   * Creates a new flow builder targeting the given chain.\n   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).\n   * @param options - Flow configuration including input declarations.\n   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.\n   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.\n   */\n  readonly flow: <T extends InputSchema>(\n    chainId: number,\n    options: FlowOptions<T>,\n  ) => FlowBuilder<T>;\n  /**\n   * Fetches the chains this Compose deployment supports, ascending by\n   * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it\n   * for what \"supported\" means and for the caching caveat.\n   *\n   * Each entry pairs the `chainId` with a display `name`, so one call both\n   * gates a chain selector and labels it. Key on `chainId`; `name` is a\n   * deployment-maintained label that can change.\n   *\n   * Use it to fail fast before building a flow for a chain the server would\n   * reject.\n   *\n   * @returns The supported chains, ascending by `chainId`.\n   * @throws {@link ComposeError} on network or server errors.\n   *\n   * @example\n   * ```ts\n   * const chains = await sdk.getSupportedChains();\n   * if (!chains.some((c) => c.chainId === 8453)) {\n   *   throw new Error('Base is not supported');\n   * }\n   * for (const { chainId, name } of chains) {\n   *   console.log(`${name} (${chainId})`);\n   * }\n   * ```\n   */\n  readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;\n  /**\n   * Builds a raw compile request without sending it. Useful for inspecting the\n   * request payload or submitting it through a custom transport.\n   * @param flow - A built flow document (from `builder.build()`).\n   * @param run - Runtime inputs, preconditions, and signer address.\n   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.\n   */\n  readonly request: <T extends InputSchema>(\n    flow: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ) => ComposeCompileRequest;\n  /**\n   * Compiles a token pair on one chain — as of today a single zap step over\n   * one routing-catalog edge. Thin pass-through to\n   * {@link ComposeClient.route}; see it for the current single-step limit,\n   * when to prefer `flow(...).compile(...)`, the `success` / `partial`\n   * discrimination, and error behaviour. Build the `amount` with\n   * `routeAmount.exact(...)` / `routeAmount.all(...)`.\n   *\n   * @param request - The from/to token pair, amount, signer, and route options.\n   * @returns A discriminated result: `status: 'success'` or `status: 'partial'`.\n   * @throws {@link ComposeError} on network, validation, or server errors.\n   */\n  readonly route: (\n    request: ComposeRouteRequest,\n  ) => Promise<ComposeCompileResult>;\n  /**\n   * Simulates a raw, pre-encoded transaction. Thin pass-through to\n   * {@link ComposeClient.simulate}; see it for the `ok` / `revert` / `error`\n   * result discrimination and error behaviour. Pair with `buildSimulateRequest`\n   * to assemble the request from a compile result.\n   *\n   * @param request - The raw transaction plus funding `requirements` and\n   *   `trackedBalances`.\n   * @returns A {@link SimulateResult} (`ok` / `revert` / `error`).\n   * @throws {@link ComposeError} on network, validation, or server errors.\n   */\n  readonly simulate: (request: SimulateRequest) => Promise<SimulateResult>;\n}\n\n/**\n * Creates a new Compose SDK instance.\n *\n * @param options - SDK configuration including the API base URL, required API key, and optional fetch implementation.\n * @returns A {@link ComposeSdk} instance.\n *\n * @example\n * ```ts\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });\n * ```\n */\nexport const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {\n  const composeClient = createComposeClient(options);\n\n  const request = <T extends InputSchema>(\n    flowDoc: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ): ComposeCompileRequest => ({\n    flow: flowDoc,\n    run: buildRun({\n      inputs: run.inputs as Record<string, InputSpec>,\n      preconditions: run.preconditions,\n      signer: run.signer,\n      assumptions: run.assumptions as Record<string, bigint> | undefined,\n      referrer: run.referrer,\n      integratorFeeBps: run.integratorFeeBps,\n      maxPriceImpactBps: run.maxPriceImpactBps,\n      sweepTo: run.sweepTo,\n      simulationPolicy: run.simulationPolicy,\n      simulateUserProgram: run.simulateUserProgram,\n      checkOnChainAllowances: run.checkOnChainAllowances,\n    }),\n  });\n\n  const flow = <T extends InputSchema>(\n    chainId: number,\n    opts: FlowOptions<T>,\n  ): FlowBuilder<T> => {\n    const core = createFlowBuilderCore(chainId, opts);\n    const builder = Object.assign(core, bindGeneratedOps(core));\n\n    const compile = async (\n      run: ComposeRunInput<T>,\n    ): Promise<ComposeCompileResult> => {\n      const flowDoc = builder.build();\n      const req = request(flowDoc, run);\n      return composeClient.compile(req);\n    };\n\n    return Object.assign(builder, { compile });\n  };\n\n  return {\n    client: composeClient,\n    flow,\n    getSupportedChains: composeClient.getChains,\n    request,\n    route: composeClient.route,\n    simulate: composeClient.simulate,\n  };\n};\n"],"mappings":"AASA;AAAA,EACE;AAAA,OAIK;AACP,SAA6B,2BAA2B;AAExD;AAAA,EACE;AAAA,OAEK;AACP,SAAS,gBAAsC;AAyKxC,MAAM,mBAAmB,CAAC,YAA2C;AAC1E,QAAM,gBAAgB,oBAAoB,OAAO;AAEjD,QAAM,UAAU,CACd,SACA,SAC2B;AAAA,IAC3B,MAAM;AAAA,IACN,KAAK,SAAS;AAAA,MACZ,QAAQ,IAAI;AAAA,MACZ,eAAe,IAAI;AAAA,MACnB,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,UAAU,IAAI;AAAA,MACd,kBAAkB,IAAI;AAAA,MACtB,mBAAmB,IAAI;AAAA,MACvB,SAAS,IAAI;AAAA,MACb,kBAAkB,IAAI;AAAA,MACtB,qBAAqB,IAAI;AAAA,MACzB,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,CACX,SACA,SACmB;AACnB,UAAM,OAAO,sBAAsB,SAAS,IAAI;AAChD,UAAM,UAAU,OAAO,OAAO,MAAM,iBAAiB,IAAI,CAAC;AAE1D,UAAM,UAAU,OACd,QACkC;AAClC,YAAM,UAAU,QAAQ,MAAM;AAC9B,YAAM,MAAM,QAAQ,SAAS,GAAG;AAChC,aAAO,cAAc,QAAQ,GAAG;AAAA,IAClC;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAAA,EAC3C;AAEA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA,oBAAoB,cAAc;AAAA,IAClC;AAAA,IACA,OAAO,cAAc;AAAA,IACrB,UAAU,cAAc;AAAA,EAC1B;AACF;","names":[]}

package/dist/types.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { Ref } from '@lifi/compose-spec';\nimport {\n  InputSpec,\n  MaterialiserInput,\n  Resource,\n  SolType,\n} from '@lifi/compose-spec';\n\n/**\n * A string that represents a non-negative integer (e.g. \"1000000000\").\n * Uses a template literal type so that only numeric-looking strings\n * are assignable at compile time.\n */\nexport type IntegerString = `${bigint}`;\n\n/**\n * Accepted input for integer-string config fields.\n * Callers may pass either a numeric string (\"1000000000\") or a native bigint\n * (1000000000n). Bigint values are stringified automatically during JSON\n * serialization via the SDK's `bigintReplacer`.\n */\nexport type IntegerStringInput = IntegerString | bigint;\n\n/**\n * A `0x`-prefixed hex string representing an Ethereum address.\n * Template literal type catches obviously wrong values at compile time.\n */\nexport type Address = `0x${string}`;\n\n/** The universe of output port kinds: Solidity scalar types plus `'resource'`. */\nexport type OutputKind = SolType | 'resource';\n\n/**\n * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the\n * closest `OutputKind`. When the ABI type is one of the supported `SolType`\n * scalars, the mapping is exact; for all other Solidity types (e.g. tuples,\n * fixed-point decimals) it falls back to `SolType` — accepting any scalar\n * handle but not `'resource'` handles.\n *\n * The fallback excludes `'resource'` because every Solidity type is a scalar;\n * resource handles carry token-amount semantics that should only flow into\n * slots explicitly declared as resources.\n *\n * Extending `SolType` with new members automatically widens the exact-match\n * branch — no changes needed here.\n */\nexport type AbiTypeToOutputKind<T extends string> = T extends SolType\n  ? T\n  : SolType;\n\n/**\n * A typed `$ref` pointer carrying a phantom type parameter.\n * Extends `Ref` so it is accepted anywhere a plain `Ref` is.\n * The `__outputKind` field is never set at runtime — it exists only\n * for TypeScript's structural type checker to distinguish typed refs.\n */\nexport interface TypedRef<T extends OutputKind = OutputKind> extends Ref {\n  readonly __outputKind?: T;\n}\n\n/**\n * An input declaration in a flow schema.\n * `Resource` values become resource inputs (token amounts);\n * `SolType` strings become handle inputs (scalars like addresses).\n */\nexport type InputDecl = Resource | SolType;\n\n/**\n * A record mapping input names to their declarations.\n * Used as the type parameter for generic flow builders and requests.\n */\nexport type InputSchema = Record<string, InputDecl>;\n\n/**\n * Maps an input declaration to the allowed runtime value type.\n * Resource inputs accept materialisers or literal amounts.\n * Handle inputs accept the scalar type matching their SolType.\n */\nexport type InputSpecOf<D> = D extends Resource\n  ? MaterialiserInput | IntegerStringInput\n  : D extends 'address'\n    ? Address\n    : D extends 'bool'\n      ? boolean\n      : D extends `${'u' | ''}int${string}`\n        ? IntegerStringInput\n        : D extends `bytes${string}`\n          ? `0x${string}`\n          : D extends 'string'\n            ? string\n            : InputSpec;\n\n/**\n * A guard applied to an operation, with the `port` field constrained\n * to a specific set of output port names.\n */\nexport interface TypedGuard<Port extends string = string> {\n  readonly kind: string;\n  readonly port: Port;\n  readonly [key: string]: unknown;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { LiteralBinding, Ref } from '@lifi/compose-spec';\nimport {\n  InputSpec,\n  MaterialiserInput,\n  Resource,\n  SolType,\n} from '@lifi/compose-spec';\n\n/**\n * A string that represents a non-negative integer (e.g. \"1000000000\").\n * Uses a template literal type so that only numeric-looking strings\n * are assignable at compile time.\n */\nexport type IntegerString = `${bigint}`;\n\n/**\n * Accepted input for integer-string config fields.\n * Callers may pass either a numeric string (\"1000000000\") or a native bigint\n * (1000000000n). Bigint values are stringified automatically during JSON\n * serialization via the SDK's `bigintReplacer`.\n */\nexport type IntegerStringInput = IntegerString | bigint;\n\n/**\n * A `0x`-prefixed hex string representing an Ethereum address.\n * Template literal type catches obviously wrong values at compile time.\n */\nexport type Address = `0x${string}`;\n\n/** The universe of output port kinds: Solidity scalar types plus `'resource'`. */\nexport type OutputKind = SolType | 'resource';\n\n/**\n * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the\n * closest `OutputKind`. When the ABI type is one of the supported `SolType`\n * scalars, the mapping is exact; for all other Solidity types (e.g. tuples,\n * fixed-point decimals) it falls back to `SolType` — accepting any scalar\n * handle but not `'resource'` handles.\n *\n * The fallback excludes `'resource'` because every Solidity type is a scalar;\n * resource handles carry token-amount semantics that should only flow into\n * slots explicitly declared as resources.\n *\n * Extending `SolType` with new members automatically widens the exact-match\n * branch — no changes needed here.\n */\nexport type AbiTypeToOutputKind<T extends string> = T extends SolType\n  ? T\n  : SolType;\n\n/**\n * A typed `$ref` pointer carrying a phantom type parameter.\n * Extends `Ref` so it is accepted anywhere a plain `Ref` is.\n * The `__outputKind` field is never set at runtime — it exists only\n * for TypeScript's structural type checker to distinguish typed refs.\n */\nexport interface TypedRef<T extends OutputKind = OutputKind> extends Ref {\n  readonly __outputKind?: T;\n}\n\n/**\n * A literal bind value carrying a phantom type parameter.\n *\n * The wire format accepts a constant in a bind slot as\n * `{ kind: <solType>, value: <string> }`, alongside `$ref` pointers. Use it\n * for a value that must be baked into the flow document rather than supplied\n * at run time — the destination of a flow the backend stores and re-runs\n * later (a `continuation.settle` node's `continuationFlow`) has no run to\n * take an input from.\n *\n * @typeParam T - The Solidity type of the literal (e.g. `'address'`).\n */\nexport interface TypedLiteral<\n  T extends SolType = SolType,\n> extends LiteralBinding {\n  readonly kind: T;\n  readonly __outputKind?: T;\n}\n\n/**\n * An input declaration in a flow schema.\n * `Resource` values become resource inputs (token amounts);\n * `SolType` strings become handle inputs (scalars like addresses).\n */\nexport type InputDecl = Resource | SolType;\n\n/**\n * A record mapping input names to their declarations.\n * Used as the type parameter for generic flow builders and requests.\n */\nexport type InputSchema = Record<string, InputDecl>;\n\n/**\n * Maps an input declaration to the allowed runtime value type.\n * Resource inputs accept materialisers or literal amounts.\n * Handle inputs accept the scalar type matching their SolType.\n */\nexport type InputSpecOf<D> = D extends Resource\n  ? MaterialiserInput | IntegerStringInput\n  : D extends 'address'\n    ? Address\n    : D extends 'bool'\n      ? boolean\n      : D extends `${'u' | ''}int${string}`\n        ? IntegerStringInput\n        : D extends `bytes${string}`\n          ? `0x${string}`\n          : D extends 'string'\n            ? string\n            : InputSpec;\n\n/**\n * A guard applied to an operation, with the `port` field constrained\n * to a specific set of output port names.\n */\nexport interface TypedGuard<Port extends string = string> {\n  readonly kind: string;\n  readonly port: Port;\n  readonly [key: string]: unknown;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types.d.cts

@@ -1,4 +1,4 @@
-import { SolType, Ref, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
+import { SolType, Ref, LiteralBinding, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
 
 /**
  * A string that represents a non-negative integer (e.g. "1000000000").
@@ -44,6 +44,22 @@ type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
 interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
     readonly __outputKind?: T;
 }
+/**
+ * A literal bind value carrying a phantom type parameter.
+ *
+ * The wire format accepts a constant in a bind slot as
+ * `{ kind: <solType>, value: <string> }`, alongside `$ref` pointers. Use it
+ * for a value that must be baked into the flow document rather than supplied
+ * at run time — the destination of a flow the backend stores and re-runs
+ * later (a `continuation.settle` node's `continuationFlow`) has no run to
+ * take an input from.
+ *
+ * @typeParam T - The Solidity type of the literal (e.g. `'address'`).
+ */
+interface TypedLiteral<T extends SolType = SolType> extends LiteralBinding {
+    readonly kind: T;
+    readonly __outputKind?: T;
+}
 /**
  * An input declaration in a flow schema.
  * `Resource` values become resource inputs (token amounts);
@@ -71,4 +87,4 @@ interface TypedGuard<Port extends string = string> {
     readonly [key: string]: unknown;
 }
 
-export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef };
+export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedLiteral, TypedRef };

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { SolType, Ref, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
+import { SolType, Ref, LiteralBinding, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
 
 /**
  * A string that represents a non-negative integer (e.g. "1000000000").
@@ -44,6 +44,22 @@ type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
 interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
     readonly __outputKind?: T;
 }
+/**
+ * A literal bind value carrying a phantom type parameter.
+ *
+ * The wire format accepts a constant in a bind slot as
+ * `{ kind: <solType>, value: <string> }`, alongside `$ref` pointers. Use it
+ * for a value that must be baked into the flow document rather than supplied
+ * at run time — the destination of a flow the backend stores and re-runs
+ * later (a `continuation.settle` node's `continuationFlow`) has no run to
+ * take an input from.
+ *
+ * @typeParam T - The Solidity type of the literal (e.g. `'address'`).
+ */
+interface TypedLiteral<T extends SolType = SolType> extends LiteralBinding {
+    readonly kind: T;
+    readonly __outputKind?: T;
+}
 /**
  * An input declaration in a flow schema.
  * `Resource` values become resource inputs (token amounts);
@@ -71,4 +87,4 @@ interface TypedGuard<Port extends string = string> {
     readonly [key: string]: unknown;
 }
 
-export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef };
+export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedLiteral, TypedRef };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/composer-sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Public Composer SDK for building and submitting flows",
   "license": "Apache-2.0",
   "repository": {
@@ -28,9 +28,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "prettier": {
-    "singleQuote": true
-  },
   "scripts": {
     "build": "tsc --noEmit && tsup",
     "clean": "rm -rf dist out",
@@ -40,18 +37,16 @@
     "test": "vitest run --config vitest.config.ts",
     "check:types": "tsc --noEmit",
     "check:sdk-drift": "vitest run --config vitest.drift.config.ts",
-    "fix": "run-s fix:lint fix:prettier",
+    "fix": "yarn fix:lint",
     "fix:lint": "eslint src --fix",
-    "fix:prettier": "prettier \"src/**/*.ts\" \"scripts/**/*.ts\" --write",
     "lint": "eslint src",
     "test:lint": "eslint src",
-    "test:prettier": "prettier \"src/**/*.ts\" \"scripts/**/*.ts\" --list-different",
     "verify:staged": "bash scripts/verify-staged.sh",
     "example": "tsx src/examples/run.ts",
     "example:staged": "tsx src/examples/run.ts --staged"
   },
   "peerDependencies": {
-    "@lifi/compose-spec": "0.4.0"
+    "@lifi/compose-spec": "0.5.0"
   },
   "dependencies": {
     "abitype": "^1.2.3",
@@ -62,19 +57,17 @@
     "@eslint/compat": "^1.4.0",
     "@lifi/compose-spec": "workspace:^",
     "@types/node": "^25.6.0",
-    "@typescript-eslint/eslint-plugin": "^8.44.1",
-    "@typescript-eslint/parser": "^8.44.1",
+    "@typescript-eslint/eslint-plugin": "^8.68.0",
+    "@typescript-eslint/parser": "^8.68.0",
     "eslint": "^9.36.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-import": "^2.22.0",
     "eslint-plugin-require-extensions": "^0.1.3",
     "json-schema-to-typescript": "^15.0.4",
-    "npm-run-all": "^4.1.5",
-    "prettier": "^3.9.4",
     "tsup": "^8.5.1",
     "tsx": "^4.20.4",
-    "typescript": "^5.9.2",
+    "typescript": "^6.0.3",
     "vitest": "^3.2.4"
   },
   "files": [

package/src/authoring/FlowBuilderCore.ts

@@ -1,9 +1,9 @@
 import type {
   AppliedGuard,
+  BindValue,
   Call,
   Flow,
   FlowInput,
-  Ref,
   Resource,
   SolType,
 } from '@lifi/compose-spec';
@@ -13,6 +13,7 @@ import type {
   InputSchema,
   OutputKind,
   TypedGuard,
+  TypedLiteral,
   TypedRef,
 } from '../types.js';
 
@@ -21,7 +22,7 @@ import type {
   OutputHandle,
   ResourceInputHandle,
 } from './handles.js';
-import { handleToRef } from './handles.js';
+import { toBindValue } from './handles.js';
 import { ref } from './raw.js';
 
 /**
@@ -37,17 +38,14 @@ export interface CallArgs {
 }
 
 /**
- * Any value that can be bound to an operation parameter: an input handle,
- * an output handle from a previous operation, or a typed `$ref` pointer.
+ * Any value that can be bound to an operation parameter: an input handle, an
+ * output handle from a previous operation, a typed `$ref` pointer, or a typed
+ * literal.
  *
- * Use `raw.ref<T>()` to create a typed ref from a raw path string.
+ * Use `raw.ref<T>()` to create a typed ref from a raw path string, and
+ * `raw.literal<T>()` to bake in a constant.
  */
-export type AnyBindable = InputHandle | OutputHandle | TypedRef;
-
-const toRef = (bindable: AnyBindable): Ref => {
-  if ('_tag' in bindable) return handleToRef(bindable);
-  return bindable;
-};
+export type AnyBindable = InputHandle | OutputHandle | TypedRef | TypedLiteral;
 
 /**
  * Provides references to runtime context values available inside a flow.
@@ -127,7 +125,7 @@ export interface FlowBuilderCore<T extends InputSchema = InputSchema> {
     id: string,
     op: string,
     args: {
-      readonly bind: Record<string, Ref>;
+      readonly bind: Record<string, BindValue>;
       readonly config: Record<string, unknown>;
       readonly guards?: readonly AppliedGuard[];
     },
@@ -196,9 +194,9 @@ export const createFlowBuilderCore = <T extends InputSchema>(
     if (nodeIds.has(nodeId)) throw new Error(`Duplicate node id: "${nodeId}"`);
     nodeIds.add(nodeId);
 
-    const bind: Record<string, Ref> = {};
+    const bind: Record<string, BindValue> = {};
     for (const [key, val] of Object.entries(args.bind)) {
-      bind[key] = toRef(val);
+      bind[key] = toBindValue(val);
     }
 
     const node: Call = {
@@ -230,7 +228,7 @@ export const createFlowBuilderCore = <T extends InputSchema>(
     nodeId: string,
     op: string,
     args: {
-      readonly bind: Record<string, Ref>;
+      readonly bind: Record<string, BindValue>;
       readonly config: Record<string, unknown>;
       readonly guards?: readonly AppliedGuard[];
     },