@lifi/composer-sdk 0.10.0 → 0.12.0

package/src/examples/run.ts

@@ -16,6 +16,8 @@
  *   approve-deposit   — approve vault allowance then deposit USDC
  *   consolidate       — consolidate ERC-20 balances to USDC
  *   consolidate-eth   — consolidate ERC-20 balances to native ETH
+ *   continuation-settle        — swap USDC to WETH on Base, escrow it for a deferred settlement
+ *   continuation-bridge-settle — bridge Arbitrum USDC into a Base settlement escrow
  *   deposit-proxy     — deposit tokens already on the proxy into Aave
  *   dust-sweep        — split USDC 80/20 and sweep leftover dust
  *   swap              — swap WETH to USDC via LI.FI
@@ -62,6 +64,8 @@ import { buildRedeemFromVault, buildWrapEth } from './callContract.js';
 import { API_KEY, BASE_URL, OWNER, PROXY, RECIPIENT } from './config.js';
 import { buildConsolidateToEth } from './consolidateToEth.js';
 import { buildConsolidateStablesToUsdc } from './consolidateToUsdc.js';
+import { buildContinuationBridgeSettleExample } from './continuationBridgeSettle.js';
+import { buildContinuationSettleExample } from './continuationSettle.js';
 import { buildDepositFromProxy } from './depositFromProxy.js';
 import { buildDustSweepExample } from './dustSweep.js';
 import { buildFlySwapExample } from './flySwap.js';
@@ -134,6 +138,10 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
       usdtAmount: '1000000000',
       daiAmount: '1000000000000000000000',
     }).request,
+  'continuation-settle': () =>
+    buildContinuationSettleExample({ owner: OWNER }).request,
+  'continuation-bridge-settle': () =>
+    buildContinuationBridgeSettleExample({ owner: OWNER }).request,
   'deposit-proxy': () =>
     buildDepositFromProxy({
       owner: OWNER,

package/src/generated/config.generated.ts

@@ -1,6 +1,8 @@
 // AUTO-GENERATED from manifest.json — do not edit by hand.
 // Regenerate with: yarn workspace @lifi/composer-sdk generate
 
+import type { Flow } from '@lifi/compose-spec';
+
 import type { Address, IntegerStringInput } from '../types.js';
 
 /**
@@ -253,7 +255,7 @@ export interface LifiBridgeConfig {
         token: Address;
         chainId: Positive;
       };
-  destination: StartsWith0X;
+  destination?: StartsWith0X;
   slippage?: Between01;
   timing?: {
     swapStepTimingStrategies?: {
@@ -1228,7 +1230,7 @@ export interface ParaswapBuyConfig {
    */
   partnerAddress?: string;
   /**
-   * Integrator fee in basis points; non-negative integer string capped at 9000.
+   * Paraswap partner fee in basis points; non-negative integer string capped at 9000.
    */
   partnerFeeBps?: string;
 }
@@ -1278,6 +1280,54 @@ export interface FlySwapConfig {
   maxSlippageBps?: Between05000;
 }
 
+/**
+ * a number between -8640000000000000 and 8640000000000000
+ */
+export type Between86400000000000008640000000000000 = number;
+
+export interface ContinuationSettleConfig {
+  /**
+   * @minItems 1
+   */
+  outcomes: [
+    {
+      /**
+       * EVM address: 0x followed by 40 hex characters
+       */
+      token: Address;
+      minAmount?: IntegerStringInput;
+      /**
+       * EVM address: 0x followed by 40 hex characters
+       */
+      destination: Address;
+      chainId: Positive;
+    },
+    ...{
+      /**
+       * EVM address: 0x followed by 40 hex characters
+       */
+      token: Address;
+      minAmount?: IntegerStringInput;
+      /**
+       * EVM address: 0x followed by 40 hex characters
+       */
+      destination: Address;
+      chainId: Positive;
+    }[],
+  ];
+  continuationFlow?: Flow;
+  validity: {
+    expiresAtMs: Between86400000000000008640000000000000;
+  };
+  provider?: string;
+  funding?: 'inline' | 'external';
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  refund?: Address;
+  exact?: boolean;
+}
+
 export interface UniswapV2AddLiquidityConfig {
   /**
    * EVM address: 0x followed by 40 hex characters
@@ -1355,6 +1405,64 @@ export interface UniswapV3IncreaseLiquidityConfig {
   tokenId: string;
 }
 
+/**
+ * a number less than 1
+ */
+export type LessThan1 = number;
+/**
+ * a number between 1 and 300
+ */
+export type Between1300 = number;
+/**
+ * a number between 0 and 120
+ */
+export type Between0120 = number;
+
+export interface LifiIntentsOrderConfig {
+  resourceOut:
+    | {
+        kind: 'native';
+        chainId: Positive;
+      }
+    | {
+        kind: 'erc20';
+        /**
+         * EVM address: 0x followed by 40 hex characters
+         */
+        token: Address;
+        chainId: Positive;
+      };
+  destination?: StartsWith0X;
+  slippage?: LessThan1;
+  validitySeconds?: Between1300;
+  exclusiveSeconds?: Between0120;
+}
+
+export interface LifiIntentsRefundConfig {
+  /**
+   * The order id: lifiIntents.order's delivery.trackingId, or topic1 of the escrow's Open log
+   */
+  orderId: string;
+}
+
+export interface LifiIntentsAttestNonFillConfig {
+  /**
+   * The order id: lifiIntents.order's delivery.trackingId, or topic1 of the escrow's Open log
+   */
+  orderId: string;
+}
+
+export interface LifiIntentsRefundOnNonFillConfig {
+  /**
+   * The order id: lifiIntents.order's delivery.trackingId, or topic1 of the escrow's Open log
+   */
+  orderId: string;
+  /**
+   * The output-chain transaction of lifiIntents.attestNonFill
+   */
+  attestationTxHash: string;
+}
+
 export interface SlippageGuardConfig {
   port: string;
   bps: Between010000;
@@ -1390,6 +1498,7 @@ export type DirectDepositMaterialiserConfig =
   | {
       allowNonExact: true;
       simAmount?: string;
+      minAmount?: IntegerStringInput;
     };
 
 export interface CallMaterialiserConfig {

package/src/generated/operations.generated.ts

@@ -27,6 +27,7 @@ import type {
   AaveRepayConfig,
   AaveRepayWithATokensConfig,
   AaveSetEModeConfig,
+  ContinuationSettleConfig,
   CoreApproveConfig,
   CoreAsResourceConfig,
   CoreBalanceOfConfig,
@@ -54,6 +55,10 @@ import type {
   InvariantNumericConfig,
   InvariantNumericInRangeConfig,
   LifiBridgeConfig,
+  LifiIntentsAttestNonFillConfig,
+  LifiIntentsOrderConfig,
+  LifiIntentsRefundConfig,
+  LifiIntentsRefundOnNonFillConfig,
   LifiSwapConfig,
   LifiZapAsyncConfig,
   LifiZapConfig,
@@ -431,7 +436,7 @@ export interface CoreTransferArgs {
     readonly amount: Bindable<'resource'>;
     readonly recipient: Bindable<'address'>;
   };
-  readonly config: CoreTransferConfig;
+  readonly config?: CoreTransferConfig;
   readonly guards?: readonly TypedGuard<'transferred'>[];
 }
 
@@ -668,6 +673,15 @@ export interface FlySwapArgs {
   readonly guards?: readonly TypedGuard<'unspentIn'>[];
 }
 
+/** Fund a deferred settlement and commit to a future outcome */
+export interface ContinuationSettleArgs {
+  readonly bind: {
+    readonly input: Bindable<'resource'>;
+  };
+  readonly config: ContinuationSettleConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 /** Deposit two ERC-20 tokens into an existing Uniswap V2 pair (or an ABI-identical fork such as SushiSwap V2) through its Router02 and receive the pair's LP token; unused input returns as residuals. Asserts on chain that the router's factory is `factory`, that the factory's pair for the two tokens is `pair`, and that the pair holds non-zero reserves. Exposes the pool price read before the deposit as `poolPrice`. The deposit is protected only with a `band` guard on `poolPrice` and a `slippage` guard on `liquidity`. Fee-on-transfer tokens are unsupported. */
 export interface UniswapV2AddLiquidityArgs {
   readonly bind: {
@@ -715,6 +729,36 @@ export interface UniswapV3IncreaseLiquidityArgs {
   >[];
 }
 
+/** Swap or bridge tokens through a LI.FI Intents order a solver fills */
+export interface LifiIntentsOrderArgs {
+  readonly bind: {
+    readonly amountIn: Bindable<'resource'>;
+  };
+  readonly config: LifiIntentsOrderConfig;
+  readonly guards?: readonly TypedGuard<'unspentIn'>[];
+}
+
+/** Refund a LI.FI Intents escrow order after its expiry. Anyone may call; the escrow pays the order's user. Only an order the order server reports before delivery (status Open or Signed) is refunded. */
+export interface LifiIntentsRefundArgs {
+  readonly bind: Record<string, never>;
+  readonly config: LifiIntentsRefundConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Step 1 of the early refund of a cross-chain LI.FI Intents order: on the order's output chain, after its fill deadline, record that the output was not filled. Keep the transaction hash for lifiIntents.refundOnNonFill. */
+export interface LifiIntentsAttestNonFillArgs {
+  readonly bind: Record<string, never>;
+  readonly config: LifiIntentsAttestNonFillConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Step 2 of the early refund of a cross-chain LI.FI Intents order: on the order's input chain, prove the non-fill attestation through Polymer and refund the order's user. A resolution_error means the proof is not ready yet; retry. */
+export interface LifiIntentsRefundOnNonFillArgs {
+  readonly bind: Record<string, never>;
+  readonly config: LifiIntentsRefundOnNonFillConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 export interface CoreSplitOutputs {
   readonly a: OutputHandle<'resource'>;
   readonly b: OutputHandle<'resource'>;
@@ -872,6 +916,10 @@ export interface FlySwapOutputs {
   readonly unspentIn: OutputHandle<'resource'>;
 }
 
+export interface ContinuationSettleOutputs {
+  readonly output: OutputHandle<'resource'>;
+}
+
 export interface UniswapV2AddLiquidityOutputs {
   readonly liquidity: OutputHandle<'resource'>;
   readonly residualA: OutputHandle<'resource'>;
@@ -899,6 +947,11 @@ export interface UniswapV3IncreaseLiquidityOutputs {
   readonly residualB: OutputHandle<'resource'>;
 }
 
+export interface LifiIntentsOrderOutputs {
+  readonly amountOut: OutputHandle<'resource'>;
+  readonly unspentIn: OutputHandle<'resource'>;
+}
+
 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" */
@@ -1149,6 +1202,13 @@ export type GeneratedOps = {
       args: MorphoBlueGetPositionArgs,
     ) => MorphoBlueGetPositionOutputs;
   };
+  readonly continuation: {
+    /** Fund a deferred settlement and commit to a future outcome — original id: "continuation.settle" */
+    readonly settle: (
+      nodeId: string,
+      args: ContinuationSettleArgs,
+    ) => ContinuationSettleOutputs;
+  };
   readonly paraswap: {
     /** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. — original id: "paraswap.buy" */
     readonly buy: (nodeId: string, args: ParaswapBuyArgs) => ParaswapBuyOutputs;
@@ -1181,6 +1241,25 @@ export type GeneratedOps = {
       args: UniswapV3IncreaseLiquidityArgs,
     ) => UniswapV3IncreaseLiquidityOutputs;
   };
+  readonly lifiIntents: {
+    /** Swap or bridge tokens through a LI.FI Intents order a solver fills — original id: "lifiIntents.order" */
+    readonly order: (
+      nodeId: string,
+      args: LifiIntentsOrderArgs,
+    ) => LifiIntentsOrderOutputs;
+    /** Refund a LI.FI Intents escrow order after its expiry. Anyone may call; the escrow pays the order's user. Only an order the order server reports before delivery (status Open or Signed) is refunded. — original id: "lifiIntents.refund" */
+    readonly refund: (nodeId: string, args: LifiIntentsRefundArgs) => void;
+    /** Step 1 of the early refund of a cross-chain LI.FI Intents order: on the order's output chain, after its fill deadline, record that the output was not filled. Keep the transaction hash for lifiIntents.refundOnNonFill. — original id: "lifiIntents.attestNonFill" */
+    readonly attestNonFill: (
+      nodeId: string,
+      args: LifiIntentsAttestNonFillArgs,
+    ) => void;
+    /** Step 2 of the early refund of a cross-chain LI.FI Intents order: on the order's input chain, prove the non-fill attestation through Polymer and refund the order's user. A resolution_error means the proof is not ready yet; retry. — original id: "lifiIntents.refundOnNonFill" */
+    readonly refundOnNonFill: (
+      nodeId: string,
+      args: LifiIntentsRefundOnNonFillArgs,
+    ) => void;
+  };
 };
 
 export const bindGeneratedOps = (
@@ -1470,6 +1549,12 @@ export const bindGeneratedOps = (
         collateral: 'uint128',
       } as const),
   },
+  continuation: {
+    settle: (nodeId: string, args: ContinuationSettleArgs) =>
+      builder.call(nodeId, 'continuation.settle', args, {
+        output: 'resource',
+      } as const),
+  },
   paraswap: {
     buy: (nodeId: string, args: ParaswapBuyArgs) =>
       builder.call(nodeId, 'paraswap.buy', args, {
@@ -1515,4 +1600,17 @@ export const bindGeneratedOps = (
         residualB: 'resource',
       } as const),
   },
+  lifiIntents: {
+    order: (nodeId: string, args: LifiIntentsOrderArgs) =>
+      builder.call(nodeId, 'lifiIntents.order', args, {
+        amountOut: 'resource',
+        unspentIn: 'resource',
+      } as const),
+    refund: (nodeId: string, args: LifiIntentsRefundArgs) =>
+      builder.call(nodeId, 'lifiIntents.refund', args, {}),
+    attestNonFill: (nodeId: string, args: LifiIntentsAttestNonFillArgs) =>
+      builder.call(nodeId, 'lifiIntents.attestNonFill', args, {}),
+    refundOnNonFill: (nodeId: string, args: LifiIntentsRefundOnNonFillArgs) =>
+      builder.call(nodeId, 'lifiIntents.refundOnNonFill', args, {}),
+  },
 });

package/src/index.ts

@@ -49,8 +49,8 @@ export type {
   ComposeCompilePartialData,
   ComposeAction,
   ComposeFill,
-  ComposeFee,
   ComposeUserProgramSimulation,
+  ComposeWarning,
   ComposeCompileRequest,
   ComposeCompileResult,
   ComposeCompileSuccessData,
@@ -83,8 +83,10 @@ export type {
   RouteAmountExact,
   SimulationPolicy,
   SimulationRevert,
+  DeliveryErrorDetails,
+  DeliveryErrorReason,
   SolType,
-  SweepTo,
+  ForwardTo,
   SimulateRequest,
   SimulateResult,
   SimulateOkResult,
@@ -101,12 +103,14 @@ export type {
   ContinuationOutcome,
   SettlementWire,
   SettlementEscrowWire,
+  SettlementBindingWire,
 } from '@lifi/compose-spec';
 export {
   SIMULATE_MAX_TRACKED_BALANCES,
   SIMULATE_MAX_REQUIREMENTS,
 } from '@lifi/compose-spec';
 export {
+  isComposeDeliveryError,
   isComposeError,
   isComposePreparationError,
   isComposeSdkOutdatedError,

package/src/outputs.ts

@@ -2,8 +2,9 @@ import type { Outputs, TerminalOutput } from '@lifi/compose-spec';
 
 /**
  * The entries of `outputs` the caller actually receives: every port no later
- * node spends, keyed `<nodeId>.<portName>` as on the wire. Consumed ports
- * (intermediate amounts a later op takes as input) are dropped.
+ * node spends, keyed `<nodeId>.<portName>` as on the wire, and every resource
+ * input no node spends, keyed `input.<name>`. Consumed ports (intermediate
+ * amounts a later op takes as input) are dropped.
  */
 export const terminalOutputs = (
   outputs: Outputs,

package/src/responseSchemas.ts

@@ -1,4 +1,8 @@
-import type { SimulateResult, SimulationRevert } from '@lifi/compose-spec';
+import type {
+  DeliveryErrorDetails,
+  SimulateResult,
+  SimulationRevert,
+} from '@lifi/compose-spec';
 import z from 'zod';
 
 /**
@@ -138,7 +142,7 @@ export interface ServerErrorBody {
     readonly sdkVersion?: string;
     readonly serverVersion?: string;
     readonly minimumSdkVersion?: string;
-    readonly details?: SimulationRevert;
+    readonly details?: SimulationRevert | DeliveryErrorDetails;
     readonly failedOps?: readonly ServerFailedPreparedOp[];
     readonly succeededOps?: readonly string[];
   };
@@ -155,8 +159,8 @@ const failedPreparedOpSchema = z.object({
 });
 
 // `details` is passed through (`z.custom`) rather than parsed: the SDK does not
-// own the `SimulationRevert` schema and forwards the field verbatim onto
-// `ComposeError`.
+// own the `SimulationRevert` or `DeliveryErrorDetails` schemas and forwards
+// the field verbatim onto `ComposeError`.
 //
 // `failedOps`/`succeededOps` are optional here because every error kind shares
 // this envelope; they are only populated for `preparation_error` (422). Zod
@@ -174,7 +178,7 @@ const serverErrorBodySchema = z.object({
       sdkVersion: z.string().optional(),
       serverVersion: z.string().optional(),
       minimumSdkVersion: z.string().optional(),
-      details: z.custom<SimulationRevert>().optional(),
+      details: z.custom<SimulationRevert | DeliveryErrorDetails>().optional(),
       failedOps: z.array(failedPreparedOpSchema).readonly().optional(),
       succeededOps: z.array(z.string()).readonly().optional(),
     })

package/src/run/inputs.ts

@@ -1,10 +1,10 @@
 import type {
   ComposeRun,
+  ForwardTo,
   InputSpec,
   MaterialiserInput,
   Precondition,
   SimulationPolicy,
-  SweepTo,
 } from '@lifi/compose-spec';
 
 import type { Address, InputSchema, InputSpecOf } from '../types.js';
@@ -33,13 +33,6 @@ export interface ComposeRunInput<T extends InputSchema = InputSchema> {
   readonly assumptions?: { readonly [K in keyof T]?: bigint };
   /** Optional integrator referrer identifier. */
   readonly referrer?: string;
-  /**
-   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
-   * A non-zero value requires the request to be authenticated with an
-   * integration-scoped API key — the integration is derived from the key, not
-   * this field. Defaults to `0` (no fee) when omitted.
-   */
-  readonly integratorFeeBps?: number;
   /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
   readonly maxPriceImpactBps?: number;
   /**
@@ -47,7 +40,7 @@ export interface ComposeRunInput<T extends InputSchema = InputSchema> {
    * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
    * send remaining tokens to the signer.
    */
-  readonly sweepTo?: SweepTo;
+  readonly sweepTo?: ForwardTo;
   /**
    * Controls behavior when simulation detects a revert.
    * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
@@ -123,9 +116,8 @@ export const buildRun = (run: {
   signer: string;
   assumptions?: Record<string, bigint>;
   referrer?: string;
-  integratorFeeBps?: number;
   maxPriceImpactBps?: number;
-  sweepTo?: SweepTo;
+  sweepTo?: ForwardTo;
   simulationPolicy?: SimulationPolicy;
   simulateUserProgram?: boolean;
   checkOnChainAllowances?: boolean;
@@ -137,7 +129,6 @@ export const buildRun = (run: {
     preconditions: run.preconditions?.length ? run.preconditions : undefined,
     assumptions: run.assumptions,
     referrer: run.referrer,
-    integratorFeeBps: run.integratorFeeBps,
     maxPriceImpactBps: run.maxPriceImpactBps,
     sweepTo: run.sweepTo,
     simulationPolicy: run.simulationPolicy,

package/src/sdk.ts

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

package/src/examples/swapWithFee.ts

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