@lifi/composer-sdk 0.4.1 → 0.5.1

package/src/run/simulate.ts

@@ -12,8 +12,11 @@ import type {
 export interface BuildSimulateRequestInput {
   /**
    * A result from `builder.compile(...)` / `client.compile(...)`. Both
-   * `success` and `partial` results carry a `transactionRequest`, so either is
-   * valid input — the helper does not discriminate on `status`.
+   * `success` and `partial` results are valid input — the helper does not
+   * discriminate on `status`. A success result for an empty compiled program
+   * (a settle-only `funding: 'external'` flow) carries no
+   * `transactionRequest`; there is nothing to simulate and this helper
+   * throws — submit the result's `actions` entries directly instead.
    */
   readonly result: ComposeCompileResult;
   /** EVM chain id. A compile result does not carry the target chain. */
@@ -65,6 +68,15 @@ export const buildSimulateRequest = (
 ): SimulateRequest => {
   const { result, chainId, signer, trackedBalances, requirements, block } =
     input;
+  // A settle-only flow authored with `funding: 'external'` compiles to an
+  // empty program: the success response carries no `transactionRequest`, so
+  // there is nothing to simulate — the required submissions are the
+  // `actions` entries, submitted directly.
+  if (result.transactionRequest === undefined) {
+    throw new Error(
+      'buildSimulateRequest: the compile result has no transactionRequest (empty compiled program — a settle-only external-funding flow); submit the `actions` entries instead of simulating',
+    );
+  }
   return {
     chainId,
     from: signer,

package/src/sdk.ts

@@ -14,6 +14,7 @@ import {
   type TypedFlow,
 } from './authoring/FlowBuilderCore.js';
 import { type ComposeClient, createComposeClient } from './client.js';
+import type { ChainSummary } from './discovery.js';
 import {
   bindGeneratedOps,
   type GeneratedOps,
@@ -109,6 +110,33 @@ export interface ComposeSdk {
     chainId: number,
     options: FlowOptions<T>,
   ) => FlowBuilder<T>;
+  /**
+   * Fetches the chains this Compose deployment supports, ascending by
+   * `chainId`. Thin pass-through to {@link ComposeClient.getChains}; see it
+   * for what "supported" means and for the caching caveat.
+   *
+   * Each entry pairs the `chainId` with a display `name`, so one call both
+   * gates a chain selector and labels it. Key on `chainId`; `name` is a
+   * deployment-maintained label that can change.
+   *
+   * Use it to fail fast before building a flow for a chain the server would
+   * reject.
+   *
+   * @returns The supported chains, ascending by `chainId`.
+   * @throws {@link ComposeError} on network or server errors.
+   *
+   * @example
+   * ```ts
+   * const chains = await sdk.getSupportedChains();
+   * if (!chains.some((c) => c.chainId === 8453)) {
+   *   throw new Error('Base is not supported');
+   * }
+   * for (const { chainId, name } of chains) {
+   *   console.log(`${name} (${chainId})`);
+   * }
+   * ```
+   */
+  readonly getSupportedChains: () => Promise<readonly ChainSummary[]>;
   /**
    * Builds a raw compile request without sending it. Useful for inspecting the
    * request payload or submitting it through a custom transport.
@@ -178,6 +206,7 @@ export const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {
       maxPriceImpactBps: run.maxPriceImpactBps,
       sweepTo: run.sweepTo,
       simulationPolicy: run.simulationPolicy,
+      simulateUserProgram: run.simulateUserProgram,
       checkOnChainAllowances: run.checkOnChainAllowances,
     }),
   });
@@ -203,6 +232,7 @@ export const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {
   return {
     client: composeClient,
     flow,
+    getSupportedChains: composeClient.getChains,
     request,
     route: composeClient.route,
     simulate: composeClient.simulate,

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Ref } from '@lifi/compose-spec';
+import type { LiteralBinding, Ref } from '@lifi/compose-spec';
 import {
   InputSpec,
   MaterialiserInput,
@@ -58,6 +58,25 @@ export interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
   readonly __outputKind?: T;
 }
 
+/**
+ * A literal bind value carrying a phantom type parameter.
+ *
+ * The wire format accepts a constant in a bind slot as
+ * `{ kind: <solType>, value: <string> }`, alongside `$ref` pointers. Use it
+ * for a value that must be baked into the flow document rather than supplied
+ * at run time — the destination of a flow the backend stores and re-runs
+ * later (a `continuation.settle` node's `continuationFlow`) has no run to
+ * take an input from.
+ *
+ * @typeParam T - The Solidity type of the literal (e.g. `'address'`).
+ */
+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);