@lifi/composer-sdk 0.11.3 → 0.12.0

package/dist/run/inputs.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"inputs.cjs","names":[],"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  ForwardTo,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: ForwardTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: ForwardTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0FA,MAAa,gBACX,MACA,SAAkC,CAAC,OACZ;CACvB;CACA,GAAG;AACL;;;;;;;;;AAUA,MAAM,eACJ,QAEA,OAAO,YACL,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC/D;;;;;;;AAQF,MAAa,YAAY,SAYN;CACjB,QAAQ,IAAI;CACZ,QAAQ,IAAI;CACZ,GAAG,YAAY;EAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB,KAAA;EAC/D,aAAa,IAAI;EACjB,UAAU,IAAI;EACd,kBAAkB,IAAI;EACtB,mBAAmB,IAAI;EACvB,SAAS,IAAI;EACb,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,wBAAwB,IAAI;CAC9B,CAAC;AACH"}
+{"version":3,"file":"inputs.cjs","names":[],"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  ForwardTo,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: ForwardTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  maxPriceImpactBps?: number;\n  sweepTo?: ForwardTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmFA,MAAa,gBACX,MACA,SAAkC,CAAC,OACZ;CACvB;CACA,GAAG;AACL;;;;;;;;;AAUA,MAAM,eACJ,QAEA,OAAO,YACL,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC/D;;;;;;;AAQF,MAAa,YAAY,SAWN;CACjB,QAAQ,IAAI;CACZ,QAAQ,IAAI;CACZ,GAAG,YAAY;EAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB,KAAA;EAC/D,aAAa,IAAI;EACjB,UAAU,IAAI;EACd,mBAAmB,IAAI;EACvB,SAAS,IAAI;EACb,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,wBAAwB,IAAI;CAC9B,CAAC;AACH"}

package/dist/run/inputs.d.cts

@@ -25,13 +25,6 @@ export interface ComposeRunInput<T extends InputSchema = InputSchema> {
   readonly assumptions?: { readonly [K in keyof T]?: bigint; };
   /** Optional integrator referrer identifier. */
   readonly referrer?: string;
-  /**
-   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
-   * A non-zero value requires the request to be authenticated with an
-   * integration-scoped API key — the integration is derived from the key, not
-   * this field. Defaults to `0` (no fee) when omitted.
-   */
-  readonly integratorFeeBps?: number;
   /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
   readonly maxPriceImpactBps?: number;
   /**
@@ -92,7 +85,6 @@ export declare const buildRun: (run: {
   signer: string;
   assumptions?: Record<string, bigint>;
   referrer?: string;
-  integratorFeeBps?: number;
   maxPriceImpactBps?: number;
   sweepTo?: ForwardTo;
   simulationPolicy?: SimulationPolicy;

package/dist/run/inputs.d.ts

@@ -25,13 +25,6 @@ export interface ComposeRunInput<T extends InputSchema = InputSchema> {
   readonly assumptions?: { readonly [K in keyof T]?: bigint; };
   /** Optional integrator referrer identifier. */
   readonly referrer?: string;
-  /**
-   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
-   * A non-zero value requires the request to be authenticated with an
-   * integration-scoped API key — the integration is derived from the key, not
-   * this field. Defaults to `0` (no fee) when omitted.
-   */
-  readonly integratorFeeBps?: number;
   /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
   readonly maxPriceImpactBps?: number;
   /**
@@ -92,7 +85,6 @@ export declare const buildRun: (run: {
   signer: string;
   assumptions?: Record<string, bigint>;
   referrer?: string;
-  integratorFeeBps?: number;
   maxPriceImpactBps?: number;
   sweepTo?: ForwardTo;
   simulationPolicy?: SimulationPolicy;

package/dist/run/inputs.js

@@ -45,7 +45,6 @@ const buildRun = (run) => ({
 		preconditions: run.preconditions?.length ? run.preconditions : void 0,
 		assumptions: run.assumptions,
 		referrer: run.referrer,
-		integratorFeeBps: run.integratorFeeBps,
 		maxPriceImpactBps: run.maxPriceImpactBps,
 		sweepTo: run.sweepTo,
 		simulationPolicy: run.simulationPolicy,

package/dist/run/inputs.js.map

@@ -1 +1 @@
-{"version":3,"file":"inputs.js","names":[],"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  ForwardTo,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: ForwardTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: ForwardTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0FA,MAAa,gBACX,MACA,SAAkC,CAAC,OACZ;CACvB;CACA,GAAG;AACL;;;;;;;;;AAUA,MAAM,eACJ,QAEA,OAAO,YACL,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC/D;;;;;;;AAQF,MAAa,YAAY,SAYN;CACjB,QAAQ,IAAI;CACZ,QAAQ,IAAI;CACZ,GAAG,YAAY;EAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB,KAAA;EAC/D,aAAa,IAAI;EACjB,UAAU,IAAI;EACd,kBAAkB,IAAI;EACtB,mBAAmB,IAAI;EACvB,SAAS,IAAI;EACb,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,wBAAwB,IAAI;CAC9B,CAAC;AACH"}
+{"version":3,"file":"inputs.js","names":[],"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  ForwardTo,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: ForwardTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  maxPriceImpactBps?: number;\n  sweepTo?: ForwardTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmFA,MAAa,gBACX,MACA,SAAkC,CAAC,OACZ;CACvB;CACA,GAAG;AACL;;;;;;;;;AAUA,MAAM,eACJ,QAEA,OAAO,YACL,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC/D;;;;;;;AAQF,MAAa,YAAY,SAWN;CACjB,QAAQ,IAAI;CACZ,QAAQ,IAAI;CACZ,GAAG,YAAY;EAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB,KAAA;EAC/D,aAAa,IAAI;EACjB,UAAU,IAAI;EACd,mBAAmB,IAAI;EACvB,SAAS,IAAI;EACb,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,wBAAwB,IAAI;CAC9B,CAAC;AACH"}

package/dist/sdk.cjs

@@ -25,7 +25,6 @@ const createComposeSdk = (options) => {
 			signer: run.signer,
 			assumptions: run.assumptions,
 			referrer: run.referrer,
-			integratorFeeBps: run.integratorFeeBps,
 			maxPriceImpactBps: run.maxPriceImpactBps,
 			sweepTo: run.sweepTo,
 			simulationPolicy: run.simulationPolicy,

package/dist/sdk.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.cjs","names":["createComposeClient","buildRun","createFlowBuilderCore","bindGeneratedOps"],"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 into a submit-ready transaction. Thin\n   * pass-through to {@link ComposeClient.route}; see it for the short chain of\n   * catalog edges the server plans, when to prefer `flow(...).compile(...)`,\n   * the `success` / `partial` discrimination, and error behaviour. Build the\n   * `amount` with `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":";;;;;;;;;;;;;;;;;AA6LA,MAAa,oBAAoB,YAA2C;CAC1E,MAAM,gBAAgBA,eAAAA,oBAAoB,OAAO;CAEjD,MAAM,WACJ,SACA,SAC2B;EAC3B,MAAM;EACN,KAAKC,mBAAAA,SAAS;GACZ,QAAQ,IAAI;GACZ,eAAe,IAAI;GACnB,QAAQ,IAAI;GACZ,aAAa,IAAI;GACjB,UAAU,IAAI;GACd,kBAAkB,IAAI;GACtB,mBAAmB,IAAI;GACvB,SAAS,IAAI;GACb,kBAAkB,IAAI;GACtB,qBAAqB,IAAI;GACzB,wBAAwB,IAAI;EAC9B,CAAC;CACH;CAEA,MAAM,QACJ,SACA,SACmB;EACnB,MAAM,OAAOC,kCAAAA,sBAAsB,SAAS,IAAI;EAChD,MAAM,UAAU,OAAO,OAAO,MAAMC,uCAAAA,iBAAiB,IAAI,CAAC;EAE1D,MAAM,UAAU,OACd,QACkC;GAClC,MAAM,UAAU,QAAQ,MAAM;GAC9B,MAAM,MAAM,QAAQ,SAAS,GAAG;GAChC,OAAO,cAAc,QAAQ,GAAG;EAClC;EAEA,OAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;CAC3C;CAEA,OAAO;EACL,QAAQ;EACR;EACA,oBAAoB,cAAc;EAClC;EACA,OAAO,cAAc;EACrB,UAAU,cAAc;CAC1B;AACF"}
+{"version":3,"file":"sdk.cjs","names":["createComposeClient","buildRun","createFlowBuilderCore","bindGeneratedOps"],"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 into a submit-ready transaction. Thin\n   * pass-through to {@link ComposeClient.route}; see it for the short chain of\n   * catalog edges the server plans, when to prefer `flow(...).compile(...)`,\n   * the `success` / `partial` discrimination, and error behaviour. Build the\n   * `amount` with `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      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":";;;;;;;;;;;;;;;;;AA6LA,MAAa,oBAAoB,YAA2C;CAC1E,MAAM,gBAAgBA,eAAAA,oBAAoB,OAAO;CAEjD,MAAM,WACJ,SACA,SAC2B;EAC3B,MAAM;EACN,KAAKC,mBAAAA,SAAS;GACZ,QAAQ,IAAI;GACZ,eAAe,IAAI;GACnB,QAAQ,IAAI;GACZ,aAAa,IAAI;GACjB,UAAU,IAAI;GACd,mBAAmB,IAAI;GACvB,SAAS,IAAI;GACb,kBAAkB,IAAI;GACtB,qBAAqB,IAAI;GACzB,wBAAwB,IAAI;EAC9B,CAAC;CACH;CAEA,MAAM,QACJ,SACA,SACmB;EACnB,MAAM,OAAOC,kCAAAA,sBAAsB,SAAS,IAAI;EAChD,MAAM,UAAU,OAAO,OAAO,MAAMC,uCAAAA,iBAAiB,IAAI,CAAC;EAE1D,MAAM,UAAU,OACd,QACkC;GAClC,MAAM,UAAU,QAAQ,MAAM;GAC9B,MAAM,MAAM,QAAQ,SAAS,GAAG;GAChC,OAAO,cAAc,QAAQ,GAAG;EAClC;EAEA,OAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;CAC3C;CAEA,OAAO;EACL,QAAQ;EACR;EACA,oBAAoB,cAAc;EAClC;EACA,OAAO,cAAc;EACrB,UAAU,cAAc;CAC1B;AACF"}

package/dist/sdk.js

@@ -24,7 +24,6 @@ const createComposeSdk = (options) => {
 			signer: run.signer,
 			assumptions: run.assumptions,
 			referrer: run.referrer,
-			integratorFeeBps: run.integratorFeeBps,
 			maxPriceImpactBps: run.maxPriceImpactBps,
 			sweepTo: run.sweepTo,
 			simulationPolicy: run.simulationPolicy,

package/dist/sdk.js.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.js","names":[],"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 into a submit-ready transaction. Thin\n   * pass-through to {@link ComposeClient.route}; see it for the short chain of\n   * catalog edges the server plans, when to prefer `flow(...).compile(...)`,\n   * the `success` / `partial` discrimination, and error behaviour. Build the\n   * `amount` with `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":";;;;;;;;;;;;;;;;AA6LA,MAAa,oBAAoB,YAA2C;CAC1E,MAAM,gBAAgB,oBAAoB,OAAO;CAEjD,MAAM,WACJ,SACA,SAC2B;EAC3B,MAAM;EACN,KAAK,SAAS;GACZ,QAAQ,IAAI;GACZ,eAAe,IAAI;GACnB,QAAQ,IAAI;GACZ,aAAa,IAAI;GACjB,UAAU,IAAI;GACd,kBAAkB,IAAI;GACtB,mBAAmB,IAAI;GACvB,SAAS,IAAI;GACb,kBAAkB,IAAI;GACtB,qBAAqB,IAAI;GACzB,wBAAwB,IAAI;EAC9B,CAAC;CACH;CAEA,MAAM,QACJ,SACA,SACmB;EACnB,MAAM,OAAO,sBAAsB,SAAS,IAAI;EAChD,MAAM,UAAU,OAAO,OAAO,MAAM,iBAAiB,IAAI,CAAC;EAE1D,MAAM,UAAU,OACd,QACkC;GAClC,MAAM,UAAU,QAAQ,MAAM;GAC9B,MAAM,MAAM,QAAQ,SAAS,GAAG;GAChC,OAAO,cAAc,QAAQ,GAAG;EAClC;EAEA,OAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;CAC3C;CAEA,OAAO;EACL,QAAQ;EACR;EACA,oBAAoB,cAAc;EAClC;EACA,OAAO,cAAc;EACrB,UAAU,cAAc;CAC1B;AACF"}
+{"version":3,"file":"sdk.js","names":[],"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 into a submit-ready transaction. Thin\n   * pass-through to {@link ComposeClient.route}; see it for the short chain of\n   * catalog edges the server plans, when to prefer `flow(...).compile(...)`,\n   * the `success` / `partial` discrimination, and error behaviour. Build the\n   * `amount` with `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      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":";;;;;;;;;;;;;;;;AA6LA,MAAa,oBAAoB,YAA2C;CAC1E,MAAM,gBAAgB,oBAAoB,OAAO;CAEjD,MAAM,WACJ,SACA,SAC2B;EAC3B,MAAM;EACN,KAAK,SAAS;GACZ,QAAQ,IAAI;GACZ,eAAe,IAAI;GACnB,QAAQ,IAAI;GACZ,aAAa,IAAI;GACjB,UAAU,IAAI;GACd,mBAAmB,IAAI;GACvB,SAAS,IAAI;GACb,kBAAkB,IAAI;GACtB,qBAAqB,IAAI;GACzB,wBAAwB,IAAI;EAC9B,CAAC;CACH;CAEA,MAAM,QACJ,SACA,SACmB;EACnB,MAAM,OAAO,sBAAsB,SAAS,IAAI;EAChD,MAAM,UAAU,OAAO,OAAO,MAAM,iBAAiB,IAAI,CAAC;EAE1D,MAAM,UAAU,OACd,QACkC;GAClC,MAAM,UAAU,QAAQ,MAAM;GAC9B,MAAM,MAAM,QAAQ,SAAS,GAAG;GAChC,OAAO,cAAc,QAAQ,GAAG;EAClC;EAEA,OAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;CAC3C;CAEA,OAAO;EACL,QAAQ;EACR;EACA,oBAAoB,cAAc;EAClC;EACA,OAAO,cAAc;EACrB,UAAU,cAAc;CAC1B;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/composer-sdk",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Public Composer SDK for building and submitting flows",
   "license": "Apache-2.0",
   "repository": {
@@ -47,7 +47,7 @@
     "example:staged": "tsx src/examples/run.ts --staged"
   },
   "peerDependencies": {
-    "@lifi/compose-spec": "0.11.3"
+    "@lifi/compose-spec": "0.12.0"
   },
   "dependencies": {
     "abitype": "^1.2.3",

package/src/authoring/raw.ts

@@ -53,12 +53,20 @@ export const ref = <T extends OutputKind>(path: string): TypedRef<T> =>
  * (`continuationFlow`). The leg produces its outcome into its own proxy
  * (`leg.context.executionAddress`) and names no recipient; the composer
  * appends a settlement epilogue at commit that forwards the outcome to the
- * provider's recipient and the residual to `refund`.
+ * provider's recipient and the residual to `refund`. A call argument inside
+ * the leg (the payee of an invoice the leg pays through `core.call`) is not
+ * that recipient and may be a literal.
+ *
+ * In a `core.call` / `core.staticCall` bind, `kind` must equal the parameter's
+ * Solidity type exactly, and `value` must encode as that type: a decimal or
+ * `0x` integer, `'true'` / `'false'`, a `0x` address (mixed case only with a
+ * valid checksum), or a `0x` hex byte string of the right length.
  *
  * @typeParam T - The Solidity type of the literal (e.g. `'address'`).
  * @param kind - The literal's Solidity type.
  * @param value - The literal value, as the wire format carries it: a string.
- * @returns A {@link TypedLiteral} accepted by `Bindable<T>` slots matching `T`.
+ * @returns A {@link TypedLiteral} accepted by `Bindable<T>` slots matching `T`
+ * and by `core.call` / `core.staticCall` parameters of type `T`.
  *
  * @example
  * ```ts

package/src/authoring/signatureArgs.ts

@@ -1,38 +1,59 @@
-import type { Ref } from '@lifi/compose-spec';
+import type { Ref, SolType } from '@lifi/compose-spec';
 import { type ParseAbiItem, parseAbiItem } from 'abitype';
 
-import type { AbiTypeToOutputKind, TypedGuard } from '../types.js';
+import type {
+  AbiTypeToOutputKind,
+  TypedGuard,
+  TypedLiteral,
+} from '../types.js';
 
 import type { CallArgs } from './FlowBuilderCore.js';
 import type { AnyRefBindable, OutputHandle, RefBindable } from './handles.js';
 import { handleToRef } from './handles.js';
 
+/**
+ * Any value a signature-derived bind slot accepts, with no per-slot type
+ * constraint: a ref-resolving bindable or a typed literal.
+ */
+type AnySignatureBindable = AnyRefBindable | TypedLiteral;
+
+// The literal arm of a signature-derived slot. A positional arg is encoded by
+// its parameter's ABI type, not by the literal's `kind`, so the kind must equal
+// that type exactly: the `bytes32` widening `Bindable<T>` applies would admit an
+// `address` literal the encoder then rejects. A parameter whose ABI type is no
+// `SolType` (a tuple, an array, `uint24`) has no literal kind to name, so its
+// slot stays ref-only.
+type SignatureLiteral<TAbiType extends string> = TAbiType extends SolType
+  ? TypedLiteral<TAbiType>
+  : never;
+
 /**
  * Type-level extraction of named bind keys from a function signature string.
  * When `TSig` is a string literal matching a Solidity function signature,
- * resolves to a record whose keys are the parameter names and values are
- * `RefBindable<kind>` where the kind is derived from each parameter's Solidity
- * type via `AbiTypeToOutputKind`. For recognised `SolType` parameters
- * (e.g. `uint256`, `address`, `uint128`) the bind slot is precisely typed;
- * for other Solidity types (e.g. tuples) the slot accepts any scalar handle.
- * Falls back to `Record<string, AnyRefBindable>` for non-literal strings.
+ * resolves to a record whose keys are the parameter names and whose values are
+ * `RefBindable<kind>`, where the kind is derived from each parameter's Solidity
+ * type via `AbiTypeToOutputKind`, or a `TypedLiteral` (`raw.literal`) of that
+ * exact Solidity type. For recognised `SolType` parameters (e.g. `uint256`,
+ * `address`, `bytes`) the slot is precisely typed; other Solidity types (e.g.
+ * tuples) accept any scalar handle and no literal.
+ * Falls back to `Record<string, AnySignatureBindable>` for non-literal strings.
  *
- * These slots are lowered into `config.args`, which is positional calldata
- * rather than a node `bind` record, so a literal is not accepted here: only
- * values that resolve to a `$ref`.
+ * These slots are lowered into `config.args`, positional calldata: a ref
+ * becomes `{ $ref }` and a literal becomes its `value` string, which the
+ * backend encodes against the parameter's type.
  */
 export type SignatureBind<TSig extends string> = string extends TSig
-  ? Record<string, AnyRefBindable>
+  ? Record<string, AnySignatureBindable>
   : ParseAbiItem<TSig> extends {
         type: 'function';
         inputs: infer I extends readonly { name: string; type: string }[];
       }
     ? {
-        readonly [P in I[number] as P['name']]: RefBindable<
-          AbiTypeToOutputKind<P['type']>
-        >;
+        readonly [P in I[number] as P['name']]:
+          | RefBindable<AbiTypeToOutputKind<P['type']>>
+          | SignatureLiteral<P['type']>;
       }
-    : Record<string, AnyRefBindable>;
+    : Record<string, AnySignatureBindable>;
 
 // ---------------------------------------------------------------------------
 // Return-type inference from function signatures
@@ -139,9 +160,18 @@ export const toBindRef = (bindable: AnyRefBindable): Ref => {
   return bindable;
 };
 
+/**
+ * Converts one signature-derived bind to its positional `config.args` entry: a
+ * ref-resolving bindable becomes `{ $ref }`; a literal becomes its `value`
+ * verbatim, which the backend encodes against the parameter's ABI type (a
+ * decimal or hex integer, a hex address or byte string, `'true'`/`'false'`).
+ */
+const toPositionalArg = (bindable: AnySignatureBindable): Ref | string =>
+  'kind' in bindable ? bindable.value : toBindRef(bindable);
+
 export interface BuildCallWireFormatInput {
   readonly resource?: AnyRefBindable;
-  readonly bind: Record<string, AnyRefBindable>;
+  readonly bind: Record<string, AnySignatureBindable>;
   readonly config: Record<string, unknown>;
   readonly guards?: readonly TypedGuard[];
 }
@@ -155,13 +185,13 @@ export interface CallWireResult {
 
 /**
  * Parses a function signature from `config`, validates bind keys against it,
- * and converts named binds to positional `$ref` args.
+ * and converts named binds to positional args.
  */
 const resolvePositionalArgs = (
   label: string,
-  bind: Record<string, AnyRefBindable>,
+  bind: Record<string, AnySignatureBindable>,
   config: Record<string, unknown>,
-): Ref[] => {
+): (Ref | string)[] => {
   const functionSignature = config.functionSignature;
   if (typeof functionSignature !== 'string') {
     throw new Error(
@@ -196,7 +226,7 @@ const resolvePositionalArgs = (
         `${label}: bind value for parameter "${name}" is undefined`,
       );
     }
-    return toBindRef(bindable);
+    return toPositionalArg(bindable);
   });
 };
 
@@ -205,7 +235,7 @@ const resolvePositionalArgs = (
  * format that the backend expects:
  * - With resource: `core.call` with `bind: { input: <resourceRef> }`
  * - Without resource: `core.invoke` with `bind: {}`
- * - `config: { ...userConfig, args: [positional refs...] }`
+ * - `config: { ...userConfig, args: [positional refs and literal values...] }`
  */
 export const buildCallWireFormat = (
   args: BuildCallWireFormatInput,
@@ -226,7 +256,7 @@ export const buildCallWireFormat = (
 };
 
 export interface BuildStaticCallWireFormatInput {
-  readonly bind: Record<string, AnyRefBindable>;
+  readonly bind: Record<string, AnySignatureBindable>;
   readonly config: Record<string, unknown>;
   readonly guards?: readonly TypedGuard[];
 }

package/src/examples/continuationBridgeSettle.ts

@@ -34,8 +34,7 @@ export interface ContinuationBridgeSettleInput {
  *   escrow on Base instead of landing at an address
  * - `continuation.settle` bound to `bridge.amountOut` (delivered funding): the
  *   bridge delivers straight into the escrow, so the user signs one
- *   transaction on Arbitrum, and the settle must omit `funding` and
- *   `perpetual`
+ *   transaction on Arbitrum, and the settle must omit `funding`
  * - `validity.expiresAtMs` at least `max(3 × the bridge ETA, 30 minutes)` away
  * - A leg on the escrow chain (Base) that does the work the user could not do
  *   from Arbitrum: `lifi.zap` supplies the landed USDC to Aave. The aBasUSDC

package/src/examples/continuationSettle.ts

@@ -50,7 +50,7 @@ export interface ContinuationSettleInput {
  *   settlement account, not the user). Never set the leg's own epilogue. At
  *   commit the composer appends the settlement epilogue, which forwards each
  *   outcome to the provider's recipient and the residual to `refund`.
- * - Omit `funding` and `perpetual` when the settle input is a bridge's
+ * - Omit `funding` when the settle input is a bridge's
  *   `amountOut` (see `continuationBridgeSettle.ts`).
  * - `minAmount` is optional: a guard or an op floor on the outcome token
  *   proves it, and an unconsumed funding input proves the full funding floor.

package/src/generated/config.generated.ts

@@ -1230,7 +1230,7 @@ export interface ParaswapBuyConfig {
    */
   partnerAddress?: string;
   /**
-   * Integrator fee in basis points; non-negative integer string capped at 9000.
+   * Paraswap partner fee in basis points; non-negative integer string capped at 9000.
    */
   partnerFeeBps?: string;
 }
@@ -1319,13 +1319,13 @@ export interface ContinuationSettleConfig {
   validity: {
     expiresAtMs: Between86400000000000008640000000000000;
   };
-  perpetual?: boolean;
   provider?: string;
   funding?: 'inline' | 'external';
   /**
    * EVM address: 0x followed by 40 hex characters
    */
   refund?: Address;
+  exact?: boolean;
 }
 
 export interface UniswapV2AddLiquidityConfig {
@@ -1498,6 +1498,7 @@ export type DirectDepositMaterialiserConfig =
   | {
       allowNonExact: true;
       simAmount?: string;
+      minAmount?: IntegerStringInput;
     };
 
 export interface CallMaterialiserConfig {

package/src/generated/operations.generated.ts

@@ -436,7 +436,7 @@ export interface CoreTransferArgs {
     readonly amount: Bindable<'resource'>;
     readonly recipient: Bindable<'address'>;
   };
-  readonly config: CoreTransferConfig;
+  readonly config?: CoreTransferConfig;
   readonly guards?: readonly TypedGuard<'transferred'>[];
 }
 

package/src/index.ts

@@ -49,7 +49,6 @@ export type {
   ComposeCompilePartialData,
   ComposeAction,
   ComposeFill,
-  ComposeFee,
   ComposeUserProgramSimulation,
   ComposeWarning,
   ComposeCompileRequest,
@@ -104,6 +103,7 @@ export type {
   ContinuationOutcome,
   SettlementWire,
   SettlementEscrowWire,
+  SettlementBindingWire,
 } from '@lifi/compose-spec';
 export {
   SIMULATE_MAX_TRACKED_BALANCES,

package/src/run/inputs.ts

@@ -33,13 +33,6 @@ export interface ComposeRunInput<T extends InputSchema = InputSchema> {
   readonly assumptions?: { readonly [K in keyof T]?: bigint };
   /** Optional integrator referrer identifier. */
   readonly referrer?: string;
-  /**
-   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
-   * A non-zero value requires the request to be authenticated with an
-   * integration-scoped API key — the integration is derived from the key, not
-   * this field. Defaults to `0` (no fee) when omitted.
-   */
-  readonly integratorFeeBps?: number;
   /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
   readonly maxPriceImpactBps?: number;
   /**
@@ -123,7 +116,6 @@ export const buildRun = (run: {
   signer: string;
   assumptions?: Record<string, bigint>;
   referrer?: string;
-  integratorFeeBps?: number;
   maxPriceImpactBps?: number;
   sweepTo?: ForwardTo;
   simulationPolicy?: SimulationPolicy;
@@ -137,7 +129,6 @@ export const buildRun = (run: {
     preconditions: run.preconditions?.length ? run.preconditions : undefined,
     assumptions: run.assumptions,
     referrer: run.referrer,
-    integratorFeeBps: run.integratorFeeBps,
     maxPriceImpactBps: run.maxPriceImpactBps,
     sweepTo: run.sweepTo,
     simulationPolicy: run.simulationPolicy,

package/src/sdk.ts

@@ -201,7 +201,6 @@ export const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {
       signer: run.signer,
       assumptions: run.assumptions as Record<string, bigint> | undefined,
       referrer: run.referrer,
-      integratorFeeBps: run.integratorFeeBps,
       maxPriceImpactBps: run.maxPriceImpactBps,
       sweepTo: run.sweepTo,
       simulationPolicy: run.simulationPolicy,

package/src/examples/swapWithFee.ts

@@ -1,59 +0,0 @@
-import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
-
-import { createComposeSdk, materialisers, resources } from '../index.js';
-
-import { API_KEY, BASE_URL, OWNER } from './config.js';
-
-const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
-const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
-
-/**
- * Swap WETH to USDC via LI.FI while collecting an integrator fee.
- *
- * Demonstrates:
- * - Setting `integratorFeeBps` on the compile request (50 bps = 0.5%)
- * - The fee is taken on the input token; the backend injects the fee transfer
- *
- * A non-zero `integratorFeeBps` requires the SDK to be configured with an
- * integration-scoped API key (`apiKey`); the integration is derived from the
- * key, not the request body.
- */
-export const buildSwapWithFeeExample = (): {
-  flow: Flow;
-  request: ComposeCompileRequest;
-} => {
-  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
-
-  // Declare the flow with a single WETH input on Ethereum mainnet.
-  const builder = sdk.flow(1, {
-    name: 'swap-with-fee',
-    inputs: {
-      amountIn: resources.erc20(WETH, 1),
-    },
-  });
-
-  // Swap WETH → USDC via LI.FI.
-  builder.lifi.swap('swap', {
-    bind: { amountIn: builder.inputs.amountIn },
-    config: {
-      resourceOut: resources.erc20(USDC, 1),
-      slippage: 0.03,
-    },
-  });
-
-  const flow = builder.build();
-
-  // Build the compile request with a 50 bps (0.5%) integrator fee.
-  const request = sdk.request(flow, {
-    signer: OWNER,
-    inputs: {
-      amountIn: materialisers.directDeposit({
-        amount: '1000000000000000000',
-      }),
-    },
-    integratorFeeBps: 50,
-    sweepTo: builder.context.sender,
-  });
-
-  return { flow, request };
-};