@lifi/composer-sdk 0.10.0 → 0.11.3

package/src/examples/continuationBridgeSettle.ts

@@ -0,0 +1,100 @@
+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';
+
+const ARBITRUM = 42161;
+const BASE = 8453;
+const ARB_USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
+const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
+// Aave V3 aToken for USDC on Base.
+const A_BAS_USDC = '0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB';
+const VALIDITY_WINDOW_MS = 3_600_000;
+
+export interface ContinuationBridgeSettleInput {
+  readonly owner: Address;
+  // Receives the aBasUSDC position on Base; defaults to `owner`.
+  readonly recipient?: Address;
+}
+
+/**
+ * Bridge USDC from Arbitrum to Base, and escrow the bridged USDC on Base for a
+ * deferred settlement that supplies it to Aave and delivers the aBasUSDC
+ * position to the recipient.
+ *
+ * Demonstrates:
+ * - `lifi.bridge` with no `destination`: its `amountOut` funds the settle's
+ *   escrow on Base instead of landing at an address
+ * - `continuation.settle` bound to `bridge.amountOut` (delivered funding): the
+ *   bridge delivers straight into the escrow, so the user signs one
+ *   transaction on Arbitrum, and the settle must omit `funding` and
+ *   `perpetual`
+ * - `validity.expiresAtMs` at least `max(3 × the bridge ETA, 30 minutes)` away
+ * - A leg on the escrow chain (Base) that does the work the user could not do
+ *   from Arbitrum: `lifi.zap` supplies the landed USDC to Aave. The aBasUSDC
+ *   stays in the leg's proxy; the settlement epilogue the composer appends at
+ *   commit forwards it to the recipient
+ * - An outcome in a token the leg produces (aBasUSDC), not the funding token:
+ *   the zap's slippage guard proves the floor, so `minAmount` is omitted
+ */
+export const buildContinuationBridgeSettleExample = ({
+  owner,
+  recipient = owner,
+}: ContinuationBridgeSettleInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  // The leg: runs from the escrow on Base once the bridged USDC has landed.
+  // The zap supplies the USDC to Aave; the aBasUSDC it mints lands in the
+  // leg's proxy, where the settlement epilogue picks it up. The slippage guard
+  // on `amountOut` is the enforced floor the compiler commits.
+  const leg = sdk.flow(BASE, {
+    name: 'bridge-settle-leg',
+    inputs: { funding: resources.erc20(BASE_USDC, BASE) },
+  });
+  leg.lifi.zap('supply', {
+    bind: { amountIn: leg.inputs.funding },
+    config: { resourceOut: resources.erc20(A_BAS_USDC, BASE) },
+    guards: [guards.slippage({ port: 'amountOut', bps: 50 })],
+  });
+
+  // The main flow on Arbitrum: bridge to Base, then escrow the delivery.
+  const builder = sdk.flow(ARBITRUM, {
+    name: 'bridge-and-settle',
+    inputs: { amountIn: resources.erc20(ARB_USDC, ARBITRUM) },
+  });
+  const bridge = builder.lifi.bridge('bridge', {
+    bind: { amountIn: builder.inputs.amountIn },
+    config: { resourceOut: resources.erc20(BASE_USDC, BASE) },
+  });
+  builder.continuation.settle('settle', {
+    bind: { input: bridge.amountOut },
+    config: {
+      outcomes: [{ token: A_BAS_USDC, destination: recipient, chainId: BASE }],
+      validity: { expiresAtMs: Date.now() + VALIDITY_WINDOW_MS },
+      provider: 'intent-factory',
+      refund: owner,
+      continuationFlow: leg.build(),
+    },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      amountIn: materialisers.directDeposit({ amount: '1000000000' }),
+    },
+  });
+
+  return { flow, request };
+};

package/src/examples/continuationSettle.ts

@@ -0,0 +1,113 @@
+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';
+
+const BASE = 8453;
+const USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
+const WETH = '0x4200000000000000000000000000000000000006';
+// Aave V3 aToken for WETH on Base.
+const A_BAS_WETH = '0xD4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7';
+const VALIDITY_WINDOW_MS = 3_600_000;
+
+export interface ContinuationSettleInput {
+  readonly owner: Address;
+  // Receives the aBasWETH position; defaults to `owner`.
+  readonly recipient?: Address;
+}
+
+/**
+ * Swap USDC to WETH on Base, then escrow the WETH for a deferred settlement
+ * whose leg supplies it to Aave and delivers the aBasWETH position to the
+ * recipient.
+ *
+ * Demonstrates:
+ * - `continuation.settle` funded by an upstream output (`swap.amountOut`)
+ * - The leg (`continuationFlow`) as an ordinary flow built with `sdk.flow`
+ *   and assigned with `leg.build()`: here one `lifi.zap` that supplies the
+ *   escrowed WETH to Aave
+ * - An outcome in the token the leg produces (aBasWETH): the zap's slippage
+ *   guard proves the floor, so `minAmount` is omitted
+ * - `refund` naming the address that receives the escrow balance on expiry
+ *   and the leg's residual (optional; defaults to the signer)
+ *
+ * The leg contract:
+ * - Exactly one input: a resource input in the funding token on the escrow
+ *   chain. The solver binds the escrow balance to it.
+ * - Produce each outcome into the leg's own proxy and end there. A zap or a
+ *   deposit mints into the proxy by default; a node that needs a receiver
+ *   binds `leg.context.executionAddress`. A funding input no node consumes
+ *   stays in the proxy as the terminal `input.<name>`. Never
+ *   pay a recipient: not `destination`, not the provider's settlement
+ *   recipient, and never `context.sender` (inside the leg that is the
+ *   settlement account, not the user). Never set the leg's own epilogue. At
+ *   commit the composer appends the settlement epilogue, which forwards each
+ *   outcome to the provider's recipient and the residual to `refund`.
+ * - Omit `funding` and `perpetual` when the settle input is a bridge's
+ *   `amountOut` (see `continuationBridgeSettle.ts`).
+ * - `minAmount` is optional: a guard or an op floor on the outcome token
+ *   proves it, and an unconsumed funding input proves the full funding floor.
+ */
+export const buildContinuationSettleExample = ({
+  owner,
+  recipient = owner,
+}: ContinuationSettleInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  // The leg: runs from the escrow on Base once the WETH has landed there. The
+  // zap supplies the WETH to Aave; the aBasWETH it mints lands in the leg's
+  // proxy, where the settlement epilogue picks it up. The slippage guard on
+  // `amountOut` is the enforced floor the compiler commits.
+  const leg = sdk.flow(BASE, {
+    name: 'settle-leg',
+    inputs: { funding: resources.erc20(WETH, BASE) },
+  });
+  leg.lifi.zap('supply', {
+    bind: { amountIn: leg.inputs.funding },
+    config: { resourceOut: resources.erc20(A_BAS_WETH, BASE) },
+    guards: [guards.slippage({ port: 'amountOut', bps: 50 })],
+  });
+
+  // The main flow: swap USDC to WETH, then escrow the WETH for the leg.
+  const builder = sdk.flow(BASE, {
+    name: 'swap-and-settle',
+    inputs: { amountIn: resources.erc20(USDC, BASE) },
+  });
+  const swap = builder.lifi.swap('swap', {
+    bind: { amountIn: builder.inputs.amountIn },
+    config: { resourceOut: resources.erc20(WETH, BASE) },
+  });
+  builder.continuation.settle('settle', {
+    bind: { input: swap.amountOut },
+    config: {
+      outcomes: [{ token: A_BAS_WETH, destination: recipient, chainId: BASE }],
+      validity: { expiresAtMs: Date.now() + VALIDITY_WINDOW_MS },
+      provider: 'intent-factory',
+      refund: owner,
+      continuationFlow: leg.build(),
+    },
+  });
+
+  const flow = builder.build();
+
+  // No `sweepTo`: the swap output funds the escrow and the settle output is
+  // delivered by the settlement, never landing in the VM.
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      amountIn: materialisers.directDeposit({ amount: '1000000000' }),
+    },
+  });
+
+  return { flow, request };
+};

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?: {
@@ -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;
+  };
+  perpetual?: boolean;
+  provider?: string;
+  funding?: 'inline' | 'external';
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  refund?: Address;
+}
+
 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;

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,
@@ -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

@@ -51,6 +51,7 @@ export type {
   ComposeFill,
   ComposeFee,
   ComposeUserProgramSimulation,
+  ComposeWarning,
   ComposeCompileRequest,
   ComposeCompileResult,
   ComposeCompileSuccessData,
@@ -83,8 +84,10 @@ export type {
   RouteAmountExact,
   SimulationPolicy,
   SimulationRevert,
+  DeliveryErrorDetails,
+  DeliveryErrorReason,
   SolType,
-  SweepTo,
+  ForwardTo,
   SimulateRequest,
   SimulateResult,
   SimulateOkResult,
@@ -107,6 +110,7 @@ export {
   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';
@@ -47,7 +47,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
@@ -125,7 +125,7 @@ export const buildRun = (run: {
   referrer?: string;
   integratorFeeBps?: number;
   maxPriceImpactBps?: number;
-  sweepTo?: SweepTo;
+  sweepTo?: ForwardTo;
   simulationPolicy?: SimulationPolicy;
   simulateUserProgram?: boolean;
   checkOnChainAllowances?: boolean;