@lifi/composer-sdk 0.8.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.8.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.8.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,7 +36,7 @@
  *   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

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/generated/config.generated.ts

@@ -12,6 +12,10 @@ export interface CoreSplitConfig {
   bps: Between010000;
 }
 
+export interface CoreSplitAtConfig {
+  amount: IntegerStringInput;
+}
+
 /**
  * an array of at most 16 item(s)
  *
@@ -179,6 +183,10 @@ export interface CorePartitionConfig {
  * a positive number
  */
 export type Positive = number;
+/**
+ * a number between 0 and 1
+ */
+export type Between01 = number;
 /**
  * a string at most 64 character(s) long
  */
@@ -204,7 +212,7 @@ export interface LifiSwapConfig {
         token: Address;
         chainId: Positive;
       };
-  slippage?: number;
+  slippage?: Between01;
   timing?: {
     swapStepTimingStrategies?: {
       strategy: 'minWaitTime';
@@ -230,10 +238,6 @@ export interface LifiSwapConfig {
  * a string starting with "0x"
  */
 export type StartsWith0X = string;
-/**
- * a number between 0 and 1
- */
-export type Between01 = number;
 
 export interface LifiBridgeConfig {
   resourceOut:
@@ -343,9 +347,7 @@ export interface CoreBalanceOfConfig {
   owner?: Address;
 }
 
-export interface CoreTransferConfig {
-  amount?: IntegerStringInput;
-}
+export type CoreTransferConfig = Record<string, never>;
 
 export interface CoreEmitEvent1Config {
   signature: string;
@@ -1237,7 +1239,16 @@ export interface CorePeekConfig {
    */
   target: Address;
   functionSignature: string;
-  args?: string[];
+  args?: (
+    | MaxLength65536
+    | (
+        | MaxLength65536
+        | (
+            | MaxLength65536
+            | (MaxLength65536 | (MaxLength65536 | MaxLength65536[])[])[]
+          )[]
+      )[]
+  )[];
 }
 
 /**

package/src/generated/operations.generated.ts

@@ -40,6 +40,7 @@ import type {
   CorePartitionConfig,
   CorePeekConfig,
   CoreRawCallConfig,
+  CoreSplitAtConfig,
   CoreSplitConfig,
   CoreStaticCallConfig,
   CoreTransferConfig,
@@ -79,6 +80,15 @@ export interface CoreSplitArgs {
   readonly guards?: readonly TypedGuard<'a' | 'b'>[];
 }
 
+/** Split a resource at a fixed amount. Output `head` receives `min(source, amount)`; `tail` receives the rest, and is 0 (omitted when unspent) when the source is at or below `amount`. */
+export interface CoreSplitAtArgs {
+  readonly bind: {
+    readonly source: Bindable<'resource'>;
+  };
+  readonly config: CoreSplitAtConfig;
+  readonly guards?: readonly TypedGuard<'head' | 'tail'>[];
+}
+
 /** Partition a resource into one output per basis-point share. `bps` lists 2 to 16 shares summing to 10000; output `parts.i` receives share i, rounded down, and the last part takes the remainder. */
 export interface CorePartitionArgs<
   TBps extends FamilySource<CorePartitionConfig['bps']> = FamilySource<
@@ -415,14 +425,14 @@ export interface CoreBalanceOfArgs {
   readonly guards?: readonly TypedGuard<'balance'>[];
 }
 
-/** Transfer tokens to a recipient address, optionally specifying a partial amount */
+/** Transfer the whole input resource to a recipient address. To send part of a resource, split it first with `core.split` or `core.splitAt`. */
 export interface CoreTransferArgs {
   readonly bind: {
     readonly amount: Bindable<'resource'>;
     readonly recipient: Bindable<'address'>;
   };
   readonly config: CoreTransferConfig;
-  readonly guards?: readonly TypedGuard<'transferred' | 'remainder'>[];
+  readonly guards?: readonly TypedGuard<'transferred'>[];
 }
 
 /** Emit a custom on-chain event carrying 1 32-byte payload value. The value becomes a non-indexed data word in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
@@ -710,6 +720,11 @@ export interface CoreSplitOutputs {
   readonly b: OutputHandle<'resource'>;
 }
 
+export interface CoreSplitAtOutputs {
+  readonly head: OutputHandle<'resource'>;
+  readonly tail: OutputHandle<'resource'>;
+}
+
 export interface CorePartitionOutputs<
   TBps extends FamilySource<CorePartitionConfig['bps']> = FamilySource<
     CorePartitionConfig['bps']
@@ -766,7 +781,6 @@ export interface CoreBalanceOfOutputs {
 
 export interface CoreTransferOutputs {
   readonly transferred: OutputHandle<'resource'>;
-  readonly remainder: OutputHandle<'resource'>;
 }
 
 export interface CoreRawCallOutputs {
@@ -889,6 +903,11 @@ export type GeneratedOps = {
   readonly core: {
     /** Split a resource into two outputs by basis-point ratio. Output `a` receives `bps` of the source, rounded up, and `b` takes the remainder. — original id: "core.split" */
     readonly split: (nodeId: string, args: CoreSplitArgs) => CoreSplitOutputs;
+    /** Split a resource at a fixed amount. Output `head` receives `min(source, amount)`; `tail` receives the rest, and is 0 (omitted when unspent) when the source is at or below `amount`. — original id: "core.splitAt" */
+    readonly splitAt: (
+      nodeId: string,
+      args: CoreSplitAtArgs,
+    ) => CoreSplitAtOutputs;
     /** Partition a resource into one output per basis-point share. `bps` lists 2 to 16 shares summing to 10000; output `parts.i` receives share i, rounded down, and the last part takes the remainder. — original id: "core.partition" */
     readonly partition: <
       const TBps extends FamilySource<CorePartitionConfig['bps']>,
@@ -954,7 +973,7 @@ export type GeneratedOps = {
       nodeId: string,
       args: CoreBalanceOfArgs,
     ) => CoreBalanceOfOutputs;
-    /** Transfer tokens to a recipient address, optionally specifying a partial amount — original id: "core.transfer" */
+    /** Transfer the whole input resource to a recipient address. To send part of a resource, split it first with `core.split` or `core.splitAt`. — original id: "core.transfer" */
     readonly transfer: (
       nodeId: string,
       args: CoreTransferArgs,
@@ -1173,6 +1192,11 @@ export const bindGeneratedOps = (
         a: 'resource',
         b: 'resource',
       } as const),
+    splitAt: (nodeId: string, args: CoreSplitAtArgs) =>
+      builder.call(nodeId, 'core.splitAt', args, {
+        head: 'resource',
+        tail: 'resource',
+      } as const),
     partition: <const TBps extends FamilySource<CorePartitionConfig['bps']>>(
       nodeId: string,
       args: CorePartitionArgs<TBps>,
@@ -1237,7 +1261,6 @@ export const bindGeneratedOps = (
     transfer: (nodeId: string, args: CoreTransferArgs) =>
       builder.call(nodeId, 'core.transfer', args, {
         transferred: 'resource',
-        remainder: 'resource',
       } as const),
     emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) =>
       builder.call(nodeId, 'core.emitEvent1', args, {}),

package/dist/discovery.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/discovery.ts"],"sourcesContent":["/**\n * Types for the Compose discovery API (`GET /compose/zap-packs`, `GET /chains`).\n *\n * These are SDK-facing presentation types — not part of the core compile\n * contract in compose-spec. The backend response is the source of truth;\n * the SDK provides typed access.\n *\n * The `type` field on edges is a plain `string` rather than a strict union\n * so the SDK remains forward-compatible when the backend introduces new\n * edge types. Known values at time of writing:\n * `\"enter-position\"`, `\"exit-position\"`, `\"wrap\"`, `\"unwrap\"`, `\"mint\"`, `\"burn\"`.\n */\n\n/**\n * A chain the Compose deployment supports.\n */\nexport interface ChainSummary {\n  /** EVM chain ID. The stable identifier — key on this. */\n  readonly chainId: number;\n  /**\n   * Human-readable label, suitable for display in a chain selector.\n   *\n   * Maintained by the deployment rather than derived from canonical chain\n   * branding, so it can differ from a chain's marketed name and can change\n   * without notice. Never treat it as an identifier, and never match on it.\n   * A chain the deployment has no configured label for reports `Chain <id>`.\n   */\n  readonly name: string;\n}\n\n/**\n * A single routing edge representing a supported token-to-token path\n * through a DeFi protocol.\n */\nexport interface ZapPackEdge {\n  /** Edge type (e.g. `\"enter-position\"`, `\"exit-position\"`, `\"wrap\"`). */\n  readonly type: string;\n  /** Input token. */\n  readonly in: { readonly address: string; readonly chainId: number };\n  /** Output token. */\n  readonly out: { readonly address: string; readonly chainId: number };\n  /** Minimum input amount accepted (stringified integer), if constrained. */\n  readonly inAmountMin?: string;\n  /** Maximum input amount accepted (stringified integer), if constrained. */\n  readonly inAmountMax?: string;\n  /**\n   * Recipient binding obligation. `\"required\"` means the zap must bind its\n   * `recipient` input. The output is externally owned, terminal, and unswept.\n   * The loose string type preserves forward compatibility with new values.\n   */\n  readonly recipient?: string;\n  /**\n   * Output availability. `\"future\"` means the output becomes available only\n   * after the initiating transaction settles; route via `lifi.zapAsync` with\n   * a bound recipient. Absent means the output is available synchronously.\n   * The loose string type preserves forward compatibility with new values.\n   */\n  readonly availability?: string;\n}\n\n/**\n * All routing edges for a single protocol.\n */\nexport interface ZapPackOverview {\n  /** Protocol identifier (e.g. `\"aave\"`, `\"morpho\"`). */\n  readonly protocol: string;\n  /** Available routing edges for this protocol. */\n  readonly edges: readonly ZapPackEdge[];\n}\n\n/**\n * Options for {@link ComposeClient.getZapPacks}.\n */\nexport interface GetZapPacksOptions {\n  /**\n   * Filter to specific protocols. Pass a single string or an array.\n   * Only edges belonging to the listed protocols are returned.\n   * Omit to fetch all available protocols.\n   */\n  readonly protocols?: string | readonly string[];\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/discovery.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}