@lifi/composer-sdk 0.7.1 → 0.9.0

package/dist/sdk.js.map

@@ -1 +1 @@
-{"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 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":"AASA;AAAA,EACE;AAAA,OAIK;AACP,SAA6B,2BAA2B;AAExD;AAAA,EACE;AAAA,OAEK;AACP,SAAS,gBAAsC;AAwKxC,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":[]}
+{"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"}

package/dist/types.cjs

@@ -1,17 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
-//# sourceMappingURL=types.cjs.map

package/dist/types.d.cts

@@ -1,25 +1,25 @@
-import { SolType, Ref, LiteralBinding, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
-
+import { InputSpec, LiteralBinding, MaterialiserInput, Ref, Resource, SolType } from "@lifi/compose-spec";
+//#region src/types.d.ts
 /**
  * A string that represents a non-negative integer (e.g. "1000000000").
  * Uses a template literal type so that only numeric-looking strings
  * are assignable at compile time.
  */
-type IntegerString = `${bigint}`;
+export type IntegerString = `${bigint}`;
 /**
  * Accepted input for integer-string config fields.
  * Callers may pass either a numeric string ("1000000000") or a native bigint
  * (1000000000n). Bigint values are stringified automatically during JSON
  * serialization via the SDK's `bigintReplacer`.
  */
-type IntegerStringInput = IntegerString | bigint;
+export type IntegerStringInput = IntegerString | bigint;
 /**
  * A `0x`-prefixed hex string representing an Ethereum address.
  * Template literal type catches obviously wrong values at compile time.
  */
-type Address = `0x${string}`;
+export type Address = `0x${string}`;
 /** The universe of output port kinds: Solidity scalar types plus `'resource'`. */
-type OutputKind = SolType | 'resource';
+export type OutputKind = SolType | "resource";
 /**
  * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the
  * closest `OutputKind`. When the ABI type is one of the supported `SolType`
@@ -34,7 +34,7 @@ type OutputKind = SolType | 'resource';
  * Extending `SolType` with new members automatically widens the exact-match
  * branch — no changes needed here.
  */
-type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
+export type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
 /**
  * Phantom brand key for {@link TypedRef}.
  *
@@ -42,7 +42,7 @@ type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
  * typed ref from an arbitrary `{ $ref }` object. Keying it on a `unique
  * symbol` means no caller can produce one by writing an object literal.
  */
-declare const typedRefKind: unique symbol;
+export declare const typedRefKind: unique symbol;
 /**
  * A typed `$ref` pointer carrying a phantom type parameter.
  *
@@ -52,8 +52,8 @@ declare const typedRefKind: unique symbol;
  * advertises: an untyped `{ $ref }` never enters a typed bind slot. Build one
  * with `raw.ref<T>()`.
  */
-interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
-    readonly [typedRefKind]: T;
+export interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
+  readonly [typedRefKind]: T;
 }
 /**
  * A literal bind value carrying a phantom type parameter.
@@ -67,35 +67,35 @@ interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
  *
  * @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;
+export 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);
  * `SolType` strings become handle inputs (scalars like addresses).
  */
-type InputDecl = Resource | SolType;
+export type InputDecl = Resource | SolType;
 /**
  * A record mapping input names to their declarations.
  * Used as the type parameter for generic flow builders and requests.
  */
-type InputSchema = Record<string, InputDecl>;
+export type InputSchema = Record<string, InputDecl>;
 /**
  * Maps an input declaration to the allowed runtime value type.
  * Resource inputs accept materialisers or literal amounts.
  * Handle inputs accept the scalar type matching their SolType.
  */
-type InputSpecOf<D> = D extends Resource ? MaterialiserInput | IntegerStringInput : D extends 'address' ? Address : D extends 'bool' ? boolean : D extends `${'u' | ''}int${string}` ? IntegerStringInput : D extends `bytes${string}` ? `0x${string}` : D extends 'string' ? string : InputSpec;
+export type InputSpecOf<D> = D extends Resource ? MaterialiserInput | IntegerStringInput : D extends "address" ? Address : D extends "bool" ? boolean : D extends `${"u" | ""}int${string}` ? IntegerStringInput : D extends `bytes${string}` ? `0x${string}` : D extends "string" ? string : InputSpec;
 /**
  * A guard applied to an operation, with the `port` field constrained
  * to a specific set of output port names.
  */
-interface TypedGuard<Port extends string = string> {
-    readonly kind: string;
-    readonly port: Port;
-    readonly [key: string]: unknown;
+export interface TypedGuard<Port extends string = string> {
+  readonly kind: string;
+  readonly port: Port;
+  readonly [key: string]: unknown;
 }
-
-export { type AbiTypeToOutputKind, type Address, type InputDecl, type InputSchema, type InputSpecOf, type IntegerString, type IntegerStringInput, type OutputKind, type TypedGuard, type TypedLiteral, type TypedRef, typedRefKind };
+//#endregion
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.ts

@@ -1,25 +1,25 @@
-import { SolType, Ref, LiteralBinding, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
-
+import { InputSpec, LiteralBinding, MaterialiserInput, Ref, Resource, SolType } from "@lifi/compose-spec";
+//#region src/types.d.ts
 /**
  * A string that represents a non-negative integer (e.g. "1000000000").
  * Uses a template literal type so that only numeric-looking strings
  * are assignable at compile time.
  */
-type IntegerString = `${bigint}`;
+export type IntegerString = `${bigint}`;
 /**
  * Accepted input for integer-string config fields.
  * Callers may pass either a numeric string ("1000000000") or a native bigint
  * (1000000000n). Bigint values are stringified automatically during JSON
  * serialization via the SDK's `bigintReplacer`.
  */
-type IntegerStringInput = IntegerString | bigint;
+export type IntegerStringInput = IntegerString | bigint;
 /**
  * A `0x`-prefixed hex string representing an Ethereum address.
  * Template literal type catches obviously wrong values at compile time.
  */
-type Address = `0x${string}`;
+export type Address = `0x${string}`;
 /** The universe of output port kinds: Solidity scalar types plus `'resource'`. */
-type OutputKind = SolType | 'resource';
+export type OutputKind = SolType | "resource";
 /**
  * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the
  * closest `OutputKind`. When the ABI type is one of the supported `SolType`
@@ -34,7 +34,7 @@ type OutputKind = SolType | 'resource';
  * Extending `SolType` with new members automatically widens the exact-match
  * branch — no changes needed here.
  */
-type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
+export type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
 /**
  * Phantom brand key for {@link TypedRef}.
  *
@@ -42,7 +42,7 @@ type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
  * typed ref from an arbitrary `{ $ref }` object. Keying it on a `unique
  * symbol` means no caller can produce one by writing an object literal.
  */
-declare const typedRefKind: unique symbol;
+export declare const typedRefKind: unique symbol;
 /**
  * A typed `$ref` pointer carrying a phantom type parameter.
  *
@@ -52,8 +52,8 @@ declare const typedRefKind: unique symbol;
  * advertises: an untyped `{ $ref }` never enters a typed bind slot. Build one
  * with `raw.ref<T>()`.
  */
-interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
-    readonly [typedRefKind]: T;
+export interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
+  readonly [typedRefKind]: T;
 }
 /**
  * A literal bind value carrying a phantom type parameter.
@@ -67,35 +67,35 @@ interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
  *
  * @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;
+export 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);
  * `SolType` strings become handle inputs (scalars like addresses).
  */
-type InputDecl = Resource | SolType;
+export type InputDecl = Resource | SolType;
 /**
  * A record mapping input names to their declarations.
  * Used as the type parameter for generic flow builders and requests.
  */
-type InputSchema = Record<string, InputDecl>;
+export type InputSchema = Record<string, InputDecl>;
 /**
  * Maps an input declaration to the allowed runtime value type.
  * Resource inputs accept materialisers or literal amounts.
  * Handle inputs accept the scalar type matching their SolType.
  */
-type InputSpecOf<D> = D extends Resource ? MaterialiserInput | IntegerStringInput : D extends 'address' ? Address : D extends 'bool' ? boolean : D extends `${'u' | ''}int${string}` ? IntegerStringInput : D extends `bytes${string}` ? `0x${string}` : D extends 'string' ? string : InputSpec;
+export type InputSpecOf<D> = D extends Resource ? MaterialiserInput | IntegerStringInput : D extends "address" ? Address : D extends "bool" ? boolean : D extends `${"u" | ""}int${string}` ? IntegerStringInput : D extends `bytes${string}` ? `0x${string}` : D extends "string" ? string : InputSpec;
 /**
  * A guard applied to an operation, with the `port` field constrained
  * to a specific set of output port names.
  */
-interface TypedGuard<Port extends string = string> {
-    readonly kind: string;
-    readonly port: Port;
-    readonly [key: string]: unknown;
+export interface TypedGuard<Port extends string = string> {
+  readonly kind: string;
+  readonly port: Port;
+  readonly [key: string]: unknown;
 }
-
-export { type AbiTypeToOutputKind, type Address, type InputDecl, type InputSchema, type InputSpecOf, type IntegerString, type IntegerStringInput, type OutputKind, type TypedGuard, type TypedLiteral, type TypedRef, typedRefKind };
+//#endregion
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1 +1 @@
-//# sourceMappingURL=types.js.map
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/composer-sdk",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Public Composer SDK for building and submitting flows",
   "license": "Apache-2.0",
   "repository": {
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc --noEmit && tsup",
+    "build": "tsc --noEmit && tsdown",
     "clean": "rm -rf dist out",
     "pack:local": "yarn build && mkdir -p out && yarn pack --out 'out/%s-%v.tgz'",
     "generate": "tsx scripts/generate-sdk/index.ts",
@@ -47,7 +47,7 @@
     "example:staged": "tsx src/examples/run.ts --staged"
   },
   "peerDependencies": {
-    "@lifi/compose-spec": "0.7.1"
+    "@lifi/compose-spec": "0.9.0"
   },
   "dependencies": {
     "abitype": "^1.2.3",
@@ -67,7 +67,7 @@
     "eslint-plugin-import": "^2.22.0",
     "eslint-plugin-require-extensions": "^0.1.3",
     "json-schema-to-typescript": "^15.0.4",
-    "tsup": "^8.5.1",
+    "tsdown": "^0.23.0",
     "tsx": "^4.20.4",
     "typescript": "^6.0.3",
     "vitest": "^3.2.4"

package/src/client.ts

@@ -26,11 +26,11 @@ import {
   parseSimulateResult,
 } from './responseSchemas.js';
 
-// __SDK_VERSION__ is a compile-time constant injected by tsup (via `define` in tsup.config.ts)
+// __SDK_VERSION__ is a compile-time constant injected by tsdown (via `define` in tsdown.config.ts)
 // and by vitest (via `define` in vitest.config.ts). Both read the version from package.json
 // at build/test time and replace this identifier with the literal string value.
 // It is sent as the `COMPOSER_SDK_VERSION_HEADER` request header so the server can identify the caller.
-// Falls back to 'dev' when running via tsx without tsup substitution (e.g. the example harness).
+// Falls back to 'dev' when running via tsx without tsdown substitution (e.g. the example harness).
 declare const __SDK_VERSION__: string;
 
 const SDK_VERSION: string =

package/src/examples/aaveClaimRewards.ts

@@ -73,7 +73,8 @@ export const buildAaveClaimRewards = ({
     inputs: {
       recipient,
     },
-    sweepTo: builder.context.sender,
+    // No `sweepTo`: the transfer forwards the whole claim, so the proxy holds
+    // nothing left to sweep.
   });
 
   return { flow, request };

package/src/examples/emitCustomEvent.ts

@@ -64,8 +64,7 @@ export const buildEmitCustomEvent = ({
   const flow = builder.build();
 
   // No `sweepTo`: this flow only reads and emits a log — it moves no funds, so
-  // there are no proxy-held terminal resources to sweep. Specifying `sweepTo`
-  // here would fail compilation with "no ... terminal resources ... to sweep".
+  // there are no proxy-held terminal resources to sweep.
   const request = sdk.request(flow, {
     signer: owner,
     inputs: {},

package/src/examples/run.ts

@@ -36,8 +36,10 @@
  *   redeem            — redeem ERC-4626 vault shares via core.call
  *   wrap-eth          — wrap native ETH into WETH via ValueCall
  *   transfer          — transfer full token balance to a recipient
- *   partial-transfer  — transfer a specific amount, keeping the remainder
+ *   partial-transfer  — split off a fixed amount with core.splitAt, transfer it, swap the rest
  *   untyped-ref       — mix untypedOp with typed handles via raw.ref
+ *   uniswap-v2-add    — split USDC, swap half to WETH, add both to the Uniswap V2 pair
+ *   uniswap-v3-mint   — open a full-range Uniswap V3 USDC/WETH position
  *   route-exact       — wrap 0.1 native ETH into WETH via /compose/route
  *   route-all         — unwrap the whole WETH balance to ETH via /compose/route
  *   supported-chains  — list the chains this deployment supports, and guard on them
@@ -83,6 +85,8 @@ import { buildSwapWithAllowRevertExample } from './swapWithAllowRevert.js';
 import { buildSwapWithBalanceCheck } from './swapWithBalanceCheck.js';
 import { buildSwapWithOutputValidation } from './swapWithOutputValidation.js';
 import { buildPartialTransfer, buildTransferTokens } from './transferTokens.js';
+import { buildUniswapV2AddLiquidity } from './uniswapV2AddLiquidity.js';
+import { buildUniswapV3Mint } from './uniswapV3Mint.js';
 import { buildUntypedOpWithTypedRef } from './untypedOpWithTypedRef.js';
 
 const stringifyJson = (value: unknown) =>
@@ -196,6 +200,15 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
       amount: '1000000000',
     }).request,
   'untyped-ref': () => buildUntypedOpWithTypedRef({ owner: OWNER }).request,
+  'uniswap-v2-add': () =>
+    buildUniswapV2AddLiquidity({ owner: OWNER, usdcAmount: '1000000000' })
+      .request,
+  'uniswap-v3-mint': () =>
+    buildUniswapV3Mint({
+      owner: OWNER,
+      usdcAmount: '1000000000',
+      wethAmount: '400000000000000000',
+    }).request,
 };
 
 // `/compose/route` examples build a `ComposeRouteRequest` and go to

package/src/examples/transferTokens.ts

@@ -17,11 +17,9 @@ export interface TransferTokensInput {
  * Transfer ERC-20 tokens from the proxy to an arbitrary recipient.
  *
  * Demonstrates:
- * - `core.transfer` to move tokens to a recipient address
+ * - `core.transfer` to move the whole input to a recipient address
  * - Binding a scalar handle input (`recipient`) alongside a resource input
- * - Optionally specifying a partial transfer amount via `config.amount`
- *   (omit to transfer the full balance)
- * - The `transferred` and `remainder` output ports
+ * - The `transferred` output port
  */
 export const buildTransferTokens = ({
   owner,
@@ -41,8 +39,8 @@ export const buildTransferTokens = ({
     },
   });
 
-  // Transfer the full input amount to the recipient.
-  // The `transferred` port tracks what was sent; `remainder` tracks what's left.
+  // Transfer the full input amount to the recipient. The `transferred` port
+  // tracks what the recipient received.
   builder.core.transfer('send', {
     bind: {
       amount: builder.inputs.amountIn,
@@ -65,11 +63,12 @@ export const buildTransferTokens = ({
 };
 
 /**
- * Transfer a partial amount, keeping the remainder in the proxy.
+ * Transfer a fixed amount and swap the rest.
  *
  * Demonstrates:
- * - `config.amount` to transfer a specific sub-amount
- * - Using the `remainder` output port for subsequent operations
+ * - `core.splitAt` to carve a fixed sub-amount (`head`) out of a resource,
+ *   leaving the rest in `tail`
+ * - Sending `head` with `core.transfer` and using `tail` in a later operation
  */
 export const buildPartialTransfer = ({
   owner,
@@ -89,19 +88,24 @@ export const buildPartialTransfer = ({
     },
   });
 
-  // Transfer a fixed 0.5 USDC (500000 base units at 6 decimals);
-  // the remainder stays on the proxy for subsequent operations.
-  const out = builder.core.transfer('send-half', {
+  // Carve out a fixed 0.5 USDC (500000 base units at 6 decimals). Below that
+  // amount, `head` takes the whole input and `tail` is 0.
+  const { head, tail } = builder.core.splitAt('split', {
+    bind: { source: builder.inputs.amountIn },
+    config: { amount: '500000' },
+  });
+
+  builder.core.transfer('send-half', {
     bind: {
-      amount: builder.inputs.amountIn,
+      amount: head,
       recipient: builder.inputs.recipient,
     },
-    config: { amount: '500000' },
+    config: {},
   });
 
-  // Use the remainder in a swap.
-  builder.lifi.swap('swap-remainder', {
-    bind: { amountIn: out.remainder },
+  // Swap the rest.
+  builder.lifi.swap('swap-rest', {
+    bind: { amountIn: tail },
     config: {
       resourceOut: resources.native(1),
       slippage: 0.03,

package/src/examples/uniswapV2AddLiquidity.ts

@@ -0,0 +1,106 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import {
+  createComposeSdk,
+  guards,
+  materialisers,
+  resources,
+} from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL } from './config.js';
+
+// Ethereum mainnet (chainId 1).
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const UNISWAP_V2_ROUTER = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D';
+const UNISWAP_V2_FACTORY = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f';
+const USDC_WETH_PAIR = '0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc';
+
+// Tolerance of the swap leg: the aggregator's `toAmountMin` lets the swap
+// deliver up to 3% less WETH than quoted.
+const SWAP_SLIPPAGE = 0.03;
+
+export interface UniswapV2AddLiquidityInput {
+  readonly owner: Address;
+  readonly usdcAmount: `${bigint}`;
+}
+
+/**
+ * Deposit USDC alone into the Uniswap V2 USDC/WETH pair.
+ *
+ * - `core.split` halves the USDC input.
+ * - `lifi.swap` turns one half into WETH.
+ * - `uniswapV2.addLiquidity` deposits the other USDC half and the swapped
+ *   WETH, minting the UNI-V2 LP token. Unused input comes back as residuals.
+ * - The request sweeps the LP token and the residuals to the signer.
+ */
+export const buildUniswapV2AddLiquidity = ({
+  owner,
+  usdcAmount,
+}: UniswapV2AddLiquidityInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(1, {
+    name: 'uniswap-v2-add-liquidity-usdc-weth',
+    inputs: {
+      usdcIn: resources.erc20(USDC, 1),
+    },
+  });
+
+  const { a: usdcHalf, b: usdcToSwap } = builder.core.split('split', {
+    bind: { source: builder.inputs.usdcIn },
+    config: { bps: 5000 },
+  });
+
+  const swap = builder.lifi.swap('swap', {
+    bind: { amountIn: usdcToSwap },
+    config: {
+      resourceOut: resources.erc20(WETH, 1),
+      slippage: SWAP_SLIPPAGE,
+    },
+  });
+
+  builder.uniswapV2.addLiquidity('add-liquidity', {
+    bind: {
+      tokenA: usdcHalf,
+      tokenB: swap.amountOut,
+    },
+    config: {
+      router: UNISWAP_V2_ROUTER,
+      factory: UNISWAP_V2_FACTORY,
+      pair: USDC_WETH_PAIR,
+    },
+    guards: [
+      // The router is called with zero minimums, so this band is the sandwich
+      // protection: it reverts unless the pool price read before the deposit
+      // stays within ±50 bps of the simulated price. It does not depend on the
+      // swap leg.
+      guards.band({ port: 'poolPrice', bps: 50 }),
+      // A swap that fills at its 3% minimum delivers less WETH, so the add
+      // mints less LP. The floor must cover that tolerance (300 bps) plus the
+      // 50 bps band, or a valid swap fill reverts the transaction.
+      guards.slippage({ port: 'liquidity', bps: 350 }),
+    ],
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      usdcIn: materialisers.directDeposit({ amount: usdcAmount }),
+    },
+    // Sweep the LP token and the unused USDC/WETH back to the signer.
+    sweepTo: builder.context.sender,
+    // The UNI-V2 LP token is unpriced, so the default 500 bps price-impact
+    // check reads the deposit as a 100% loss. 0 skips the check; the `band`
+    // and `slippage` guards above are the protection.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};