@lifi/composer-sdk 0.12.0 → 0.13.0

package/README.md

@@ -365,7 +365,8 @@ switch (result.status) {
 }
 ```
 
-- `requirements` entries are `Erc20Balance`, `NativeBalance`, or `Erc20Allowance`. Use the zero address as a `trackedBalances` token to watch the native balance.
+- `requirements` entries are `Erc20Balance`, `NativeBalance`, `Erc20Allowance`, or `Permit2Allowance`. Use the zero address as a `trackedBalances` token to watch the native balance.
+- `Permit2Allowance` (`owner`, `token`, `spender`, `amount`) lets `spender` pull `token` from `owner` through Uniswap Permit2's `transferFrom`. The simulation also grants the ERC-20 allowance `owner` → Permit2, but not the owner's balance: fund it with an `Erc20Balance`. Only the canonical Permit2 address `0x000000000022D473030F116dDEE9F6B43aC78BA3` is supported; on a chain without it, `simulate` returns `status: 'error'` with a message that names Permit2 and the chain.
 - Amount fields accept `bigint` or decimal strings.
 - `SIMULATE_MAX_TRACKED_BALANCES` and `SIMULATE_MAX_REQUIREMENTS` (both `40`) are exported.
 - A `revert` is returned, not thrown. Only transport failures and HTTP 400/401/403/404/429/5xx throw `ComposeError`.
@@ -519,6 +520,7 @@ Each file in `src/examples/` is a complete flow:
 - **simulateRawTransaction** / **simulateCompiledSwap**: raw and compiled simulation
 - **continuationSettle**: 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
 - **continuationBridgeSettle**: bridge USDC from Arbitrum into a settle escrow on Base; when the delivery lands, the leg supplies it to Aave and delivers the aBasUSDC position
+- **continuationExactInvoice**: escrow USDC on Base for an exact leg (`exact: true`) that pays a Request Network invoice through `core.call` and returns the surplus; a second builder funds the same leg from a WETH-to-USDC swap, and a third from Arbitrum ETH swapped to USDC and delivered by an exact-output `lifiIntents.order` (`exactAmountOut`) into the escrow at exactly the invoice total, with no outcome (`outcomes: []`)
 
 ## Staging channel
 

package/dist/client.cjs

@@ -3,7 +3,7 @@ const require_responseSchemas = require("./responseSchemas.cjs");
 const require_errors = require("./errors.cjs");
 let _lifi_compose_spec = require("@lifi/compose-spec");
 //#region src/client.ts
-const SDK_VERSION = "0.12.0";
+const SDK_VERSION = "0.13.0";
 const SDK_VERSION_TRIPLE = (0, _lifi_compose_spec.parseVersion)(SDK_VERSION);
 /**
 * `JSON.stringify` replacer that renders `bigint` amounts as decimal strings.

package/dist/client.js

@@ -2,7 +2,7 @@ import { parseCompilePartialEnvelope, parseSimulateResult } from "./responseSche
 import { ComposeError, errorFromHttpResponse } from "./errors.js";
 import { COMPOSER_SDK_VERSION_HEADER, COMPOSE_VERSION_HEADER, checkCompatibility, parseVersion } from "@lifi/compose-spec";
 //#region src/client.ts
-const SDK_VERSION = "0.12.0";
+const SDK_VERSION = "0.13.0";
 const SDK_VERSION_TRIPLE = parseVersion(SDK_VERSION);
 /**
 * `JSON.stringify` replacer that renders `bigint` amounts as decimal strings.

package/dist/generated/config.generated.d.cts

@@ -885,21 +885,7 @@ export interface FlySwapConfig {
  */
 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;
-  }, ...{
+  outcomes: {
     /**
      * EVM address: 0x followed by 40 hex characters
      */
@@ -910,7 +896,7 @@ export interface ContinuationSettleConfig {
      */
     destination: Address;
     chainId: Positive;
-  }[]];
+  }[];
   continuationFlow?: Flow;
   validity: {
     expiresAtMs: Between86400000000000008640000000000000;
@@ -1023,6 +1009,7 @@ export interface LifiIntentsOrderConfig {
   slippage?: LessThan1;
   validitySeconds?: Between1300;
   exclusiveSeconds?: Between0120;
+  exactAmountOut?: string;
 }
 export interface LifiIntentsRefundConfig {
   /**

package/dist/generated/config.generated.d.ts

@@ -885,21 +885,7 @@ export interface FlySwapConfig {
  */
 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;
-  }, ...{
+  outcomes: {
     /**
      * EVM address: 0x followed by 40 hex characters
      */
@@ -910,7 +896,7 @@ export interface ContinuationSettleConfig {
      */
     destination: Address;
     chainId: Positive;
-  }[]];
+  }[];
   continuationFlow?: Flow;
   validity: {
     expiresAtMs: Between86400000000000008640000000000000;
@@ -1023,6 +1009,7 @@ export interface LifiIntentsOrderConfig {
   slippage?: LessThan1;
   validitySeconds?: Between1300;
   exclusiveSeconds?: Between0120;
+  exactAmountOut?: string;
 }
 export interface LifiIntentsRefundConfig {
   /**

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["guardsMod","materialisersMod","preconditionsMod","resourcesMod","routeAmountMod","rawMod"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@lifi/composer-sdk` — TypeScript SDK for building and compiling\n * Compose flows into executable EVM calldata.\n *\n * Start by creating an SDK instance with {@link createComposeSdk}, then use\n * {@link ComposeSdk.flow} to build flows and compile them.\n *\n * @packageDocumentation\n */\n\nexport type {\n  AbiTypeToOutputKind,\n  Address,\n  InputDecl,\n  InputSchema,\n  InputSpecOf,\n  IntegerString,\n  IntegerStringInput,\n  OutputKind,\n  TypedGuard,\n  TypedRef,\n  TypedLiteral,\n} from './types.js';\n\nexport type {\n  ChainSummary,\n  GetZapPacksOptions,\n  ZapPackEdge,\n  ZapPackOverview,\n} from './discovery.js';\nexport type {\n  Reachability,\n  ReachabilityOptions,\n  RoutablePair,\n  TokenRef,\n} from './reachability.js';\nexport { buildReachability } from './reachability.js';\nexport type {\n  ComposeError,\n  ComposeErrorCode,\n  ComposeSdkOutdated,\n  ComposeServerOutdated,\n  ComposePreparationOps,\n} from './errors.js';\nexport type {\n  AppliedGuard,\n  ApprovalEntry,\n  Call,\n  ComposeCompilePartialData,\n  ComposeAction,\n  ComposeFill,\n  ComposeUserProgramSimulation,\n  ComposeWarning,\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeCompileSuccessData,\n  ComposeErrorKind,\n  ComposeRouteRequest,\n  ComposeTransactionRequest,\n  FailedPreparedOp,\n  Flow,\n  InputSpec,\n  MaterialiserConfigOf,\n  MaterialiserInput,\n  OutputAmount,\n  Amount,\n  ConsumedOutput,\n  Delivery,\n  Estimate,\n  EstimateBasis,\n  Minimum,\n  MinimumBasis,\n  Output,\n  Outputs,\n  TerminalOutput,\n  Precondition,\n  PreconditionConfigOf,\n  PriceImpact,\n  Ref,\n  Resource,\n  RouteAmount,\n  RouteAmountAll,\n  RouteAmountExact,\n  SimulationPolicy,\n  SimulationRevert,\n  DeliveryErrorDetails,\n  DeliveryErrorReason,\n  SolType,\n  ForwardTo,\n  SimulateRequest,\n  SimulateResult,\n  SimulateOkResult,\n  SimulateRevertResult,\n  SimulateRevertDecodeResult,\n  SimulateSetupErrorResult,\n  SimulateBalanceEntry,\n  TrackedBalance,\n  SlotFinderRequirement,\n  Erc20BalanceRequirement,\n  NativeBalanceRequirement,\n  Erc20AllowanceRequirement,\n  ContinuationIntent,\n  ContinuationOutcome,\n  SettlementWire,\n  SettlementEscrowWire,\n  SettlementBindingWire,\n} from '@lifi/compose-spec';\nexport {\n  SIMULATE_MAX_TRACKED_BALANCES,\n  SIMULATE_MAX_REQUIREMENTS,\n} from '@lifi/compose-spec';\nexport {\n  isComposeDeliveryError,\n  isComposeError,\n  isComposePreparationError,\n  isComposeSdkOutdatedError,\n  isComposeServerOutdatedError,\n} from './errors.js';\n\nexport type {\n  Bindable,\n  RefBindable,\n  AnyRefBindable,\n  InputHandle,\n  ResourceInputHandle,\n  OutputHandle,\n  OutputFamilyHandles,\n  FamilyCount,\n  FamilySource,\n  AnyHandle,\n} from './authoring/handles.js';\nexport { isInputHandle, isOutputHandle } from './authoring/handles.js';\nexport { ref } from './authoring/raw.js';\n\nexport type { AnyBindable } from './authoring/FlowBuilderCore.js';\nexport type { TypedFlow, FlowOptions } from './authoring/FlowBuilderCore.js';\n\nexport type { ComposeRunInput } from './run/inputs.js';\nexport { materialiser } from './run/inputs.js';\n\nexport { buildSimulateRequest } from './run/simulate.js';\nexport type { BuildSimulateRequestInput } from './run/simulate.js';\n\nexport { terminalOutputs } from './outputs.js';\n\nexport { createComposeSdk } from './sdk.js';\nexport type { ComposeSdk, ComposeSdkOptions, FlowBuilder } from './sdk.js';\n\nimport * as guardsMod from './generated/guards.generated.js';\nimport * as materialisersMod from './generated/materialisers.generated.js';\nimport * as preconditionsMod from './generated/preconditions.generated.js';\nimport * as rawMod from './raw.js';\nimport * as resourcesMod from './resources.js';\nimport * as routeAmountMod from './routeAmount.js';\n\n/**\n * Guard factories for protecting operation outputs (e.g. slippage tolerance).\n * Pass guards to an operation's `guards` array.\n *\n * @example\n * ```ts\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.token },\n *   config: { resourceOut: resources.native(1) },\n *   guards: [guards.slippage({ port: 'amountOut', bps: 300 })],\n * });\n * ```\n */\nexport const guards: typeof guardsMod = guardsMod;\n/**\n * Materialiser factories that tell the runtime how to resolve token input\n * amounts on-chain (e.g. read a wallet balance, accept a direct deposit).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   signer: '0x...',\n * });\n * ```\n */\nexport const materialisers: typeof materialisersMod = materialisersMod;\n/**\n * Precondition factories for asserting on-chain state before a flow executes\n * (e.g. minimum token balances, ERC-20 allowances).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   preconditions: [\n *     preconditions.erc20Balance({ wallet: '0x...', token: '0x...', balance: 1000n }),\n *   ],\n *   signer: '0x...',\n * });\n * ```\n */\nexport const preconditions: typeof preconditionsMod = preconditionsMod;\n/**\n * Resource declaration helpers for defining token inputs in a flow schema.\n * Use {@link resources.erc20} for ERC-20 tokens and {@link resources.native}\n * for the chain's native coin (ETH, MATIC, etc.).\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: {\n *     usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1),\n *     eth: resources.native(1),\n *   },\n * });\n * ```\n */\nexport const resources: typeof resourcesMod = resourcesMod;\n/**\n * Amount constructors for {@link ComposeSdk.route}. Use\n * {@link routeAmount.exact} to spend a fixed amount of the `fromToken`, and\n * {@link routeAmount.all} to spend the signer's whole balance.\n *\n * @example\n * ```ts\n * // USDC into the Aave v3 aEthUSDC position — one routing-catalog edge.\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',\n *   toToken: '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c',\n *   amount: routeAmount.exact(1_000_000n),\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport const routeAmount: typeof routeAmountMod = routeAmountMod;\nexport * from './generated/config.generated.js';\n\n/**\n * Low-level escape hatch for constructing flow nodes, guards, and materialiser\n * inputs without the typed builder API. Prefer the generated operation methods\n * on {@link FlowBuilder} and the typed `guards`/`materialisers` namespaces\n * for most use cases.\n */\nexport const raw: typeof rawMod = rawMod;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwKA,MAAa,SAA2BA,mCAAAA;;;;;;;;;;;;;AAaxC,MAAa,gBAAyCC,0CAAAA;;;;;;;;;;;;;;;;AAgBtD,MAAa,gBAAyCC,0CAAAA;;;;;;;;;;;;;;;;AAgBtD,MAAa,YAAiCC,kBAAAA;;;;;;;;;;;;;;;;;;AAkB9C,MAAa,cAAqCC,oBAAAA;;;;;;;AASlD,MAAa,MAAqBC,YAAAA"}
+{"version":3,"file":"index.cjs","names":["guardsMod","materialisersMod","preconditionsMod","resourcesMod","routeAmountMod","rawMod"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@lifi/composer-sdk` — TypeScript SDK for building and compiling\n * Compose flows into executable EVM calldata.\n *\n * Start by creating an SDK instance with {@link createComposeSdk}, then use\n * {@link ComposeSdk.flow} to build flows and compile them.\n *\n * @packageDocumentation\n */\n\nexport type {\n  AbiTypeToOutputKind,\n  Address,\n  InputDecl,\n  InputSchema,\n  InputSpecOf,\n  IntegerString,\n  IntegerStringInput,\n  OutputKind,\n  TypedGuard,\n  TypedRef,\n  TypedLiteral,\n} from './types.js';\n\nexport type {\n  ChainSummary,\n  GetZapPacksOptions,\n  ZapPackEdge,\n  ZapPackOverview,\n} from './discovery.js';\nexport type {\n  Reachability,\n  ReachabilityOptions,\n  RoutablePair,\n  TokenRef,\n} from './reachability.js';\nexport { buildReachability } from './reachability.js';\nexport type {\n  ComposeError,\n  ComposeErrorCode,\n  ComposeSdkOutdated,\n  ComposeServerOutdated,\n  ComposePreparationOps,\n} from './errors.js';\nexport type {\n  AppliedGuard,\n  ApprovalEntry,\n  Call,\n  ComposeCompilePartialData,\n  ComposeAction,\n  ComposeFill,\n  ComposeUserProgramSimulation,\n  ComposeWarning,\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeCompileSuccessData,\n  ComposeErrorKind,\n  ComposeRouteRequest,\n  ComposeTransactionRequest,\n  FailedPreparedOp,\n  Flow,\n  InputSpec,\n  MaterialiserConfigOf,\n  MaterialiserInput,\n  OutputAmount,\n  Amount,\n  ConsumedOutput,\n  Delivery,\n  Estimate,\n  EstimateBasis,\n  Minimum,\n  MinimumBasis,\n  Output,\n  Outputs,\n  TerminalOutput,\n  Precondition,\n  PreconditionConfigOf,\n  PriceImpact,\n  Ref,\n  Resource,\n  RouteAmount,\n  RouteAmountAll,\n  RouteAmountExact,\n  SimulationPolicy,\n  SimulationRevert,\n  DeliveryErrorDetails,\n  DeliveryErrorReason,\n  SolType,\n  ForwardTo,\n  SimulateRequest,\n  SimulateResult,\n  SimulateOkResult,\n  SimulateRevertResult,\n  SimulateRevertDecodeResult,\n  SimulateSetupErrorResult,\n  SimulateBalanceEntry,\n  TrackedBalance,\n  SlotFinderRequirement,\n  Erc20BalanceRequirement,\n  NativeBalanceRequirement,\n  Erc20AllowanceRequirement,\n  Permit2AllowanceRequirement,\n  ContinuationIntent,\n  ContinuationOutcome,\n  SettlementWire,\n  SettlementEscrowWire,\n  SettlementBindingWire,\n} from '@lifi/compose-spec';\nexport {\n  SIMULATE_MAX_TRACKED_BALANCES,\n  SIMULATE_MAX_REQUIREMENTS,\n} from '@lifi/compose-spec';\nexport {\n  isComposeDeliveryError,\n  isComposeError,\n  isComposePreparationError,\n  isComposeSdkOutdatedError,\n  isComposeServerOutdatedError,\n} from './errors.js';\n\nexport type {\n  Bindable,\n  RefBindable,\n  AnyRefBindable,\n  InputHandle,\n  ResourceInputHandle,\n  OutputHandle,\n  OutputFamilyHandles,\n  FamilyCount,\n  FamilySource,\n  AnyHandle,\n} from './authoring/handles.js';\nexport { isInputHandle, isOutputHandle } from './authoring/handles.js';\nexport { ref } from './authoring/raw.js';\n\nexport type { AnyBindable } from './authoring/FlowBuilderCore.js';\nexport type { TypedFlow, FlowOptions } from './authoring/FlowBuilderCore.js';\n\nexport type { ComposeRunInput } from './run/inputs.js';\nexport { materialiser } from './run/inputs.js';\n\nexport { buildSimulateRequest } from './run/simulate.js';\nexport type { BuildSimulateRequestInput } from './run/simulate.js';\n\nexport { terminalOutputs } from './outputs.js';\n\nexport { createComposeSdk } from './sdk.js';\nexport type { ComposeSdk, ComposeSdkOptions, FlowBuilder } from './sdk.js';\n\nimport * as guardsMod from './generated/guards.generated.js';\nimport * as materialisersMod from './generated/materialisers.generated.js';\nimport * as preconditionsMod from './generated/preconditions.generated.js';\nimport * as rawMod from './raw.js';\nimport * as resourcesMod from './resources.js';\nimport * as routeAmountMod from './routeAmount.js';\n\n/**\n * Guard factories for protecting operation outputs (e.g. slippage tolerance).\n * Pass guards to an operation's `guards` array.\n *\n * @example\n * ```ts\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.token },\n *   config: { resourceOut: resources.native(1) },\n *   guards: [guards.slippage({ port: 'amountOut', bps: 300 })],\n * });\n * ```\n */\nexport const guards: typeof guardsMod = guardsMod;\n/**\n * Materialiser factories that tell the runtime how to resolve token input\n * amounts on-chain (e.g. read a wallet balance, accept a direct deposit).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   signer: '0x...',\n * });\n * ```\n */\nexport const materialisers: typeof materialisersMod = materialisersMod;\n/**\n * Precondition factories for asserting on-chain state before a flow executes\n * (e.g. minimum token balances, ERC-20 allowances).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   preconditions: [\n *     preconditions.erc20Balance({ wallet: '0x...', token: '0x...', balance: 1000n }),\n *   ],\n *   signer: '0x...',\n * });\n * ```\n */\nexport const preconditions: typeof preconditionsMod = preconditionsMod;\n/**\n * Resource declaration helpers for defining token inputs in a flow schema.\n * Use {@link resources.erc20} for ERC-20 tokens and {@link resources.native}\n * for the chain's native coin (ETH, MATIC, etc.).\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: {\n *     usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1),\n *     eth: resources.native(1),\n *   },\n * });\n * ```\n */\nexport const resources: typeof resourcesMod = resourcesMod;\n/**\n * Amount constructors for {@link ComposeSdk.route}. Use\n * {@link routeAmount.exact} to spend a fixed amount of the `fromToken`, and\n * {@link routeAmount.all} to spend the signer's whole balance.\n *\n * @example\n * ```ts\n * // USDC into the Aave v3 aEthUSDC position — one routing-catalog edge.\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',\n *   toToken: '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c',\n *   amount: routeAmount.exact(1_000_000n),\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport const routeAmount: typeof routeAmountMod = routeAmountMod;\nexport * from './generated/config.generated.js';\n\n/**\n * Low-level escape hatch for constructing flow nodes, guards, and materialiser\n * inputs without the typed builder API. Prefer the generated operation methods\n * on {@link FlowBuilder} and the typed `guards`/`materialisers` namespaces\n * for most use cases.\n */\nexport const raw: typeof rawMod = rawMod;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyKA,MAAa,SAA2BA,mCAAAA;;;;;;;;;;;;;AAaxC,MAAa,gBAAyCC,0CAAAA;;;;;;;;;;;;;;;;AAgBtD,MAAa,gBAAyCC,0CAAAA;;;;;;;;;;;;;;;;AAgBtD,MAAa,YAAiCC,kBAAAA;;;;;;;;;;;;;;;;;;AAkB9C,MAAa,cAAqCC,oBAAAA;;;;;;;AASlD,MAAa,MAAqBC,YAAAA"}

package/dist/index.d.cts

@@ -16,7 +16,7 @@ import { ComposeSdk, ComposeSdkOptions, FlowBuilder, createComposeSdk } from "./
 import { raw_d_exports } from "./raw.cjs";
 import { resources_d_exports } from "./resources.cjs";
 import { routeAmount_d_exports } from "./routeAmount.cjs";
-import { Amount, AppliedGuard, ApprovalEntry, Call, ComposeAction, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeErrorKind, ComposeFill, ComposeRouteRequest, ComposeTransactionRequest, ComposeUserProgramSimulation, ComposeWarning, ConsumedOutput, ContinuationIntent, ContinuationOutcome, Delivery, DeliveryErrorDetails, DeliveryErrorReason, Erc20AllowanceRequirement, Erc20BalanceRequirement, Estimate, EstimateBasis, FailedPreparedOp, Flow, ForwardTo, InputSpec, MaterialiserConfigOf, MaterialiserInput, Minimum, MinimumBasis, NativeBalanceRequirement, Output, OutputAmount, Outputs, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, RouteAmount, RouteAmountAll, RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, SettlementBindingWire, SettlementEscrowWire, SettlementWire, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulationPolicy, SimulationRevert, SlotFinderRequirement, SolType, TerminalOutput, TrackedBalance } from "@lifi/compose-spec";
+import { Amount, AppliedGuard, ApprovalEntry, Call, ComposeAction, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeErrorKind, ComposeFill, ComposeRouteRequest, ComposeTransactionRequest, ComposeUserProgramSimulation, ComposeWarning, ConsumedOutput, ContinuationIntent, ContinuationOutcome, Delivery, DeliveryErrorDetails, DeliveryErrorReason, Erc20AllowanceRequirement, Erc20BalanceRequirement, Estimate, EstimateBasis, FailedPreparedOp, Flow, ForwardTo, InputSpec, MaterialiserConfigOf, MaterialiserInput, Minimum, MinimumBasis, NativeBalanceRequirement, Output, OutputAmount, Outputs, Permit2AllowanceRequirement, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, RouteAmount, RouteAmountAll, RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, SettlementBindingWire, SettlementEscrowWire, SettlementWire, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulationPolicy, SimulationRevert, SlotFinderRequirement, SolType, TerminalOutput, TrackedBalance } from "@lifi/compose-spec";
 //#region src/index.d.ts
 /**
  * Guard factories for protecting operation outputs (e.g. slippage tolerance).
@@ -103,5 +103,5 @@ export declare const routeAmount: typeof routeAmount_d_exports;
  */
 export declare const raw: typeof raw_d_exports;
 //#endregion
-export { AaveBorrowConfig, AaveClaimRewardsConfig, AaveGetHealthFactorConfig, AaveRepayConfig, AaveRepayWithATokensConfig, AaveSetEModeConfig, type AbiTypeToOutputKind, type Address, type Amount, type AnyBindable, type AnyHandle, type AnyRefBindable, type AppliedGuard, type ApprovalEntry, BalanceOfMaterialiserConfig, BandGuardConfig, Between01, Between010000, Between0120, Between0255, Between03318, Between05000, Between0999999, Between1300, Between19999, Between86400000000000008640000000000000, Between887272887272, type Bindable, type BuildSimulateRequestInput, type Call, CallMaterialiserConfig, type ChainSummary, type ComposeAction, type ComposeCompilePartialData, type ComposeCompileRequest, type ComposeCompileResult, type ComposeCompileSuccessData, type ComposeError, type ComposeErrorCode, type ComposeErrorKind, type ComposeFill, type ComposePreparationOps, type ComposeRouteRequest, type ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type ComposeSdkOutdated, type ComposeServerOutdated, type ComposeTransactionRequest, type ComposeUserProgramSimulation, type ComposeWarning, type ConsumedOutput, type ContinuationIntent, type ContinuationOutcome, ContinuationSettleConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreEmitEvent1Config, CoreEmitEvent2Config, CoreEmitEvent3Config, CoreEmitEvent4Config, CoreInvokeConfig, CoreNumericInvariantGuardConfig, CorePartitionConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitAtConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, type Delivery, type DeliveryErrorDetails, type DeliveryErrorReason, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, type Erc20AllowanceRequirement, Erc20BalancePreconditionConfig, type Erc20BalanceRequirement, type Estimate, type EstimateBasis, type FailedPreparedOp, type FamilyCount, type FamilySource, FlashloanMaterialiserConfig, type Flow, type FlowBuilder, type FlowOptions, FlySwapConfig, type ForwardTo, type GetZapPacksOptions, type InputDecl, type InputHandle, type InputSchema, type InputSpec, type InputSpecOf, type IntegerString, type IntegerStringInput, InvariantEqConfig, InvariantGtConfig, InvariantGteConfig, InvariantLtConfig, InvariantLteConfig, InvariantNeqConfig, InvariantNumericConfig, InvariantNumericInRangeConfig, LessThan1, LifiBridgeConfig, LifiFlashloanRepayConfig, LifiIntentsAttestNonFillConfig, LifiIntentsOrderConfig, LifiIntentsRefundConfig, LifiIntentsRefundOnNonFillConfig, LifiSwapConfig, LifiZapAsyncConfig, LifiZapConfig, type MaterialiserConfigOf, type MaterialiserInput, MaxItems16, MaxItems50, MaxLength64, MaxLength65536, type Minimum, type MinimumBasis, MorphoBlueBorrowConfig, MorphoBlueGetPositionConfig, MorphoBlueRepayConfig, MorphoBlueSupplyCollateralConfig, MorphoBlueSupplyConfig, MorphoBlueWithdrawCollateralConfig, MorphoBlueWithdrawConfig, NativeBalancePreconditionConfig, type NativeBalanceRequirement, NonNegative, type Output, type OutputAmount, type OutputFamilyHandles, type OutputHandle, type OutputKind, type Outputs, ParaswapBuyConfig, Positive, type Precondition, type PreconditionConfigOf, type PriceImpact, type Reachability, type ReachabilityOptions, type Ref, type RefBindable, type Resource, type ResourceInputHandle, type RoutablePair, type RouteAmount, type RouteAmountAll, type RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, type SettlementBindingWire, type SettlementEscrowWire, type SettlementWire, type SimulateBalanceEntry, type SimulateOkResult, type SimulateRequest, type SimulateResult, type SimulateRevertDecodeResult, type SimulateRevertResult, type SimulateSetupErrorResult, type SimulationPolicy, type SimulationRevert, SlippageGuardConfig, type SlotFinderRequirement, type SolType, StartsWith0X, type TerminalOutput, type TokenRef, type TrackedBalance, type TypedFlow, type TypedGuard, type TypedLiteral, type TypedRef, UniswapV2AddLiquidityConfig, UniswapV2RemoveLiquidityConfig, UniswapV3IncreaseLiquidityConfig, UniswapV3MintConfig, type ZapPackEdge, type ZapPackOverview, buildReachability, buildSimulateRequest, createComposeSdk, isComposeDeliveryError, isComposeError, isComposePreparationError, isComposeSdkOutdatedError, isComposeServerOutdatedError, isInputHandle, isOutputHandle, materialiser, ref, terminalOutputs };
+export { AaveBorrowConfig, AaveClaimRewardsConfig, AaveGetHealthFactorConfig, AaveRepayConfig, AaveRepayWithATokensConfig, AaveSetEModeConfig, type AbiTypeToOutputKind, type Address, type Amount, type AnyBindable, type AnyHandle, type AnyRefBindable, type AppliedGuard, type ApprovalEntry, BalanceOfMaterialiserConfig, BandGuardConfig, Between01, Between010000, Between0120, Between0255, Between03318, Between05000, Between0999999, Between1300, Between19999, Between86400000000000008640000000000000, Between887272887272, type Bindable, type BuildSimulateRequestInput, type Call, CallMaterialiserConfig, type ChainSummary, type ComposeAction, type ComposeCompilePartialData, type ComposeCompileRequest, type ComposeCompileResult, type ComposeCompileSuccessData, type ComposeError, type ComposeErrorCode, type ComposeErrorKind, type ComposeFill, type ComposePreparationOps, type ComposeRouteRequest, type ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type ComposeSdkOutdated, type ComposeServerOutdated, type ComposeTransactionRequest, type ComposeUserProgramSimulation, type ComposeWarning, type ConsumedOutput, type ContinuationIntent, type ContinuationOutcome, ContinuationSettleConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreEmitEvent1Config, CoreEmitEvent2Config, CoreEmitEvent3Config, CoreEmitEvent4Config, CoreInvokeConfig, CoreNumericInvariantGuardConfig, CorePartitionConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitAtConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, type Delivery, type DeliveryErrorDetails, type DeliveryErrorReason, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, type Erc20AllowanceRequirement, Erc20BalancePreconditionConfig, type Erc20BalanceRequirement, type Estimate, type EstimateBasis, type FailedPreparedOp, type FamilyCount, type FamilySource, FlashloanMaterialiserConfig, type Flow, type FlowBuilder, type FlowOptions, FlySwapConfig, type ForwardTo, type GetZapPacksOptions, type InputDecl, type InputHandle, type InputSchema, type InputSpec, type InputSpecOf, type IntegerString, type IntegerStringInput, InvariantEqConfig, InvariantGtConfig, InvariantGteConfig, InvariantLtConfig, InvariantLteConfig, InvariantNeqConfig, InvariantNumericConfig, InvariantNumericInRangeConfig, LessThan1, LifiBridgeConfig, LifiFlashloanRepayConfig, LifiIntentsAttestNonFillConfig, LifiIntentsOrderConfig, LifiIntentsRefundConfig, LifiIntentsRefundOnNonFillConfig, LifiSwapConfig, LifiZapAsyncConfig, LifiZapConfig, type MaterialiserConfigOf, type MaterialiserInput, MaxItems16, MaxItems50, MaxLength64, MaxLength65536, type Minimum, type MinimumBasis, MorphoBlueBorrowConfig, MorphoBlueGetPositionConfig, MorphoBlueRepayConfig, MorphoBlueSupplyCollateralConfig, MorphoBlueSupplyConfig, MorphoBlueWithdrawCollateralConfig, MorphoBlueWithdrawConfig, NativeBalancePreconditionConfig, type NativeBalanceRequirement, NonNegative, type Output, type OutputAmount, type OutputFamilyHandles, type OutputHandle, type OutputKind, type Outputs, ParaswapBuyConfig, type Permit2AllowanceRequirement, Positive, type Precondition, type PreconditionConfigOf, type PriceImpact, type Reachability, type ReachabilityOptions, type Ref, type RefBindable, type Resource, type ResourceInputHandle, type RoutablePair, type RouteAmount, type RouteAmountAll, type RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, type SettlementBindingWire, type SettlementEscrowWire, type SettlementWire, type SimulateBalanceEntry, type SimulateOkResult, type SimulateRequest, type SimulateResult, type SimulateRevertDecodeResult, type SimulateRevertResult, type SimulateSetupErrorResult, type SimulationPolicy, type SimulationRevert, SlippageGuardConfig, type SlotFinderRequirement, type SolType, StartsWith0X, type TerminalOutput, type TokenRef, type TrackedBalance, type TypedFlow, type TypedGuard, type TypedLiteral, type TypedRef, UniswapV2AddLiquidityConfig, UniswapV2RemoveLiquidityConfig, UniswapV3IncreaseLiquidityConfig, UniswapV3MintConfig, type ZapPackEdge, type ZapPackOverview, buildReachability, buildSimulateRequest, createComposeSdk, isComposeDeliveryError, isComposeError, isComposePreparationError, isComposeSdkOutdatedError, isComposeServerOutdatedError, isInputHandle, isOutputHandle, materialiser, ref, terminalOutputs };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -16,7 +16,7 @@ import { ComposeSdk, ComposeSdkOptions, FlowBuilder, createComposeSdk } from "./
 import { raw_d_exports } from "./raw.js";
 import { resources_d_exports } from "./resources.js";
 import { routeAmount_d_exports } from "./routeAmount.js";
-import { Amount, AppliedGuard, ApprovalEntry, Call, ComposeAction, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeErrorKind, ComposeFill, ComposeRouteRequest, ComposeTransactionRequest, ComposeUserProgramSimulation, ComposeWarning, ConsumedOutput, ContinuationIntent, ContinuationOutcome, Delivery, DeliveryErrorDetails, DeliveryErrorReason, Erc20AllowanceRequirement, Erc20BalanceRequirement, Estimate, EstimateBasis, FailedPreparedOp, Flow, ForwardTo, InputSpec, MaterialiserConfigOf, MaterialiserInput, Minimum, MinimumBasis, NativeBalanceRequirement, Output, OutputAmount, Outputs, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, RouteAmount, RouteAmountAll, RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, SettlementBindingWire, SettlementEscrowWire, SettlementWire, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulationPolicy, SimulationRevert, SlotFinderRequirement, SolType, TerminalOutput, TrackedBalance } from "@lifi/compose-spec";
+import { Amount, AppliedGuard, ApprovalEntry, Call, ComposeAction, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeErrorKind, ComposeFill, ComposeRouteRequest, ComposeTransactionRequest, ComposeUserProgramSimulation, ComposeWarning, ConsumedOutput, ContinuationIntent, ContinuationOutcome, Delivery, DeliveryErrorDetails, DeliveryErrorReason, Erc20AllowanceRequirement, Erc20BalanceRequirement, Estimate, EstimateBasis, FailedPreparedOp, Flow, ForwardTo, InputSpec, MaterialiserConfigOf, MaterialiserInput, Minimum, MinimumBasis, NativeBalanceRequirement, Output, OutputAmount, Outputs, Permit2AllowanceRequirement, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, RouteAmount, RouteAmountAll, RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, SettlementBindingWire, SettlementEscrowWire, SettlementWire, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulationPolicy, SimulationRevert, SlotFinderRequirement, SolType, TerminalOutput, TrackedBalance } from "@lifi/compose-spec";
 //#region src/index.d.ts
 /**
  * Guard factories for protecting operation outputs (e.g. slippage tolerance).
@@ -103,5 +103,5 @@ export declare const routeAmount: typeof routeAmount_d_exports;
  */
 export declare const raw: typeof raw_d_exports;
 //#endregion
-export { AaveBorrowConfig, AaveClaimRewardsConfig, AaveGetHealthFactorConfig, AaveRepayConfig, AaveRepayWithATokensConfig, AaveSetEModeConfig, type AbiTypeToOutputKind, type Address, type Amount, type AnyBindable, type AnyHandle, type AnyRefBindable, type AppliedGuard, type ApprovalEntry, BalanceOfMaterialiserConfig, BandGuardConfig, Between01, Between010000, Between0120, Between0255, Between03318, Between05000, Between0999999, Between1300, Between19999, Between86400000000000008640000000000000, Between887272887272, type Bindable, type BuildSimulateRequestInput, type Call, CallMaterialiserConfig, type ChainSummary, type ComposeAction, type ComposeCompilePartialData, type ComposeCompileRequest, type ComposeCompileResult, type ComposeCompileSuccessData, type ComposeError, type ComposeErrorCode, type ComposeErrorKind, type ComposeFill, type ComposePreparationOps, type ComposeRouteRequest, type ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type ComposeSdkOutdated, type ComposeServerOutdated, type ComposeTransactionRequest, type ComposeUserProgramSimulation, type ComposeWarning, type ConsumedOutput, type ContinuationIntent, type ContinuationOutcome, ContinuationSettleConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreEmitEvent1Config, CoreEmitEvent2Config, CoreEmitEvent3Config, CoreEmitEvent4Config, CoreInvokeConfig, CoreNumericInvariantGuardConfig, CorePartitionConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitAtConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, type Delivery, type DeliveryErrorDetails, type DeliveryErrorReason, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, type Erc20AllowanceRequirement, Erc20BalancePreconditionConfig, type Erc20BalanceRequirement, type Estimate, type EstimateBasis, type FailedPreparedOp, type FamilyCount, type FamilySource, FlashloanMaterialiserConfig, type Flow, type FlowBuilder, type FlowOptions, FlySwapConfig, type ForwardTo, type GetZapPacksOptions, type InputDecl, type InputHandle, type InputSchema, type InputSpec, type InputSpecOf, type IntegerString, type IntegerStringInput, InvariantEqConfig, InvariantGtConfig, InvariantGteConfig, InvariantLtConfig, InvariantLteConfig, InvariantNeqConfig, InvariantNumericConfig, InvariantNumericInRangeConfig, LessThan1, LifiBridgeConfig, LifiFlashloanRepayConfig, LifiIntentsAttestNonFillConfig, LifiIntentsOrderConfig, LifiIntentsRefundConfig, LifiIntentsRefundOnNonFillConfig, LifiSwapConfig, LifiZapAsyncConfig, LifiZapConfig, type MaterialiserConfigOf, type MaterialiserInput, MaxItems16, MaxItems50, MaxLength64, MaxLength65536, type Minimum, type MinimumBasis, MorphoBlueBorrowConfig, MorphoBlueGetPositionConfig, MorphoBlueRepayConfig, MorphoBlueSupplyCollateralConfig, MorphoBlueSupplyConfig, MorphoBlueWithdrawCollateralConfig, MorphoBlueWithdrawConfig, NativeBalancePreconditionConfig, type NativeBalanceRequirement, NonNegative, type Output, type OutputAmount, type OutputFamilyHandles, type OutputHandle, type OutputKind, type Outputs, ParaswapBuyConfig, Positive, type Precondition, type PreconditionConfigOf, type PriceImpact, type Reachability, type ReachabilityOptions, type Ref, type RefBindable, type Resource, type ResourceInputHandle, type RoutablePair, type RouteAmount, type RouteAmountAll, type RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, type SettlementBindingWire, type SettlementEscrowWire, type SettlementWire, type SimulateBalanceEntry, type SimulateOkResult, type SimulateRequest, type SimulateResult, type SimulateRevertDecodeResult, type SimulateRevertResult, type SimulateSetupErrorResult, type SimulationPolicy, type SimulationRevert, SlippageGuardConfig, type SlotFinderRequirement, type SolType, StartsWith0X, type TerminalOutput, type TokenRef, type TrackedBalance, type TypedFlow, type TypedGuard, type TypedLiteral, type TypedRef, UniswapV2AddLiquidityConfig, UniswapV2RemoveLiquidityConfig, UniswapV3IncreaseLiquidityConfig, UniswapV3MintConfig, type ZapPackEdge, type ZapPackOverview, buildReachability, buildSimulateRequest, createComposeSdk, isComposeDeliveryError, isComposeError, isComposePreparationError, isComposeSdkOutdatedError, isComposeServerOutdatedError, isInputHandle, isOutputHandle, materialiser, ref, terminalOutputs };
+export { AaveBorrowConfig, AaveClaimRewardsConfig, AaveGetHealthFactorConfig, AaveRepayConfig, AaveRepayWithATokensConfig, AaveSetEModeConfig, type AbiTypeToOutputKind, type Address, type Amount, type AnyBindable, type AnyHandle, type AnyRefBindable, type AppliedGuard, type ApprovalEntry, BalanceOfMaterialiserConfig, BandGuardConfig, Between01, Between010000, Between0120, Between0255, Between03318, Between05000, Between0999999, Between1300, Between19999, Between86400000000000008640000000000000, Between887272887272, type Bindable, type BuildSimulateRequestInput, type Call, CallMaterialiserConfig, type ChainSummary, type ComposeAction, type ComposeCompilePartialData, type ComposeCompileRequest, type ComposeCompileResult, type ComposeCompileSuccessData, type ComposeError, type ComposeErrorCode, type ComposeErrorKind, type ComposeFill, type ComposePreparationOps, type ComposeRouteRequest, type ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type ComposeSdkOutdated, type ComposeServerOutdated, type ComposeTransactionRequest, type ComposeUserProgramSimulation, type ComposeWarning, type ConsumedOutput, type ContinuationIntent, type ContinuationOutcome, ContinuationSettleConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreEmitEvent1Config, CoreEmitEvent2Config, CoreEmitEvent3Config, CoreEmitEvent4Config, CoreInvokeConfig, CoreNumericInvariantGuardConfig, CorePartitionConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitAtConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, type Delivery, type DeliveryErrorDetails, type DeliveryErrorReason, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, type Erc20AllowanceRequirement, Erc20BalancePreconditionConfig, type Erc20BalanceRequirement, type Estimate, type EstimateBasis, type FailedPreparedOp, type FamilyCount, type FamilySource, FlashloanMaterialiserConfig, type Flow, type FlowBuilder, type FlowOptions, FlySwapConfig, type ForwardTo, type GetZapPacksOptions, type InputDecl, type InputHandle, type InputSchema, type InputSpec, type InputSpecOf, type IntegerString, type IntegerStringInput, InvariantEqConfig, InvariantGtConfig, InvariantGteConfig, InvariantLtConfig, InvariantLteConfig, InvariantNeqConfig, InvariantNumericConfig, InvariantNumericInRangeConfig, LessThan1, LifiBridgeConfig, LifiFlashloanRepayConfig, LifiIntentsAttestNonFillConfig, LifiIntentsOrderConfig, LifiIntentsRefundConfig, LifiIntentsRefundOnNonFillConfig, LifiSwapConfig, LifiZapAsyncConfig, LifiZapConfig, type MaterialiserConfigOf, type MaterialiserInput, MaxItems16, MaxItems50, MaxLength64, MaxLength65536, type Minimum, type MinimumBasis, MorphoBlueBorrowConfig, MorphoBlueGetPositionConfig, MorphoBlueRepayConfig, MorphoBlueSupplyCollateralConfig, MorphoBlueSupplyConfig, MorphoBlueWithdrawCollateralConfig, MorphoBlueWithdrawConfig, NativeBalancePreconditionConfig, type NativeBalanceRequirement, NonNegative, type Output, type OutputAmount, type OutputFamilyHandles, type OutputHandle, type OutputKind, type Outputs, ParaswapBuyConfig, type Permit2AllowanceRequirement, Positive, type Precondition, type PreconditionConfigOf, type PriceImpact, type Reachability, type ReachabilityOptions, type Ref, type RefBindable, type Resource, type ResourceInputHandle, type RoutablePair, type RouteAmount, type RouteAmountAll, type RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, type SettlementBindingWire, type SettlementEscrowWire, type SettlementWire, type SimulateBalanceEntry, type SimulateOkResult, type SimulateRequest, type SimulateResult, type SimulateRevertDecodeResult, type SimulateRevertResult, type SimulateSetupErrorResult, type SimulationPolicy, type SimulationRevert, SlippageGuardConfig, type SlotFinderRequirement, type SolType, StartsWith0X, type TerminalOutput, type TokenRef, type TrackedBalance, type TypedFlow, type TypedGuard, type TypedLiteral, type TypedRef, UniswapV2AddLiquidityConfig, UniswapV2RemoveLiquidityConfig, UniswapV3IncreaseLiquidityConfig, UniswapV3MintConfig, type ZapPackEdge, type ZapPackOverview, buildReachability, buildSimulateRequest, createComposeSdk, isComposeDeliveryError, isComposeError, isComposePreparationError, isComposeSdkOutdatedError, isComposeServerOutdatedError, isInputHandle, isOutputHandle, materialiser, ref, terminalOutputs };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["guardsMod","materialisersMod","preconditionsMod","resourcesMod","routeAmountMod","rawMod"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@lifi/composer-sdk` — TypeScript SDK for building and compiling\n * Compose flows into executable EVM calldata.\n *\n * Start by creating an SDK instance with {@link createComposeSdk}, then use\n * {@link ComposeSdk.flow} to build flows and compile them.\n *\n * @packageDocumentation\n */\n\nexport type {\n  AbiTypeToOutputKind,\n  Address,\n  InputDecl,\n  InputSchema,\n  InputSpecOf,\n  IntegerString,\n  IntegerStringInput,\n  OutputKind,\n  TypedGuard,\n  TypedRef,\n  TypedLiteral,\n} from './types.js';\n\nexport type {\n  ChainSummary,\n  GetZapPacksOptions,\n  ZapPackEdge,\n  ZapPackOverview,\n} from './discovery.js';\nexport type {\n  Reachability,\n  ReachabilityOptions,\n  RoutablePair,\n  TokenRef,\n} from './reachability.js';\nexport { buildReachability } from './reachability.js';\nexport type {\n  ComposeError,\n  ComposeErrorCode,\n  ComposeSdkOutdated,\n  ComposeServerOutdated,\n  ComposePreparationOps,\n} from './errors.js';\nexport type {\n  AppliedGuard,\n  ApprovalEntry,\n  Call,\n  ComposeCompilePartialData,\n  ComposeAction,\n  ComposeFill,\n  ComposeUserProgramSimulation,\n  ComposeWarning,\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeCompileSuccessData,\n  ComposeErrorKind,\n  ComposeRouteRequest,\n  ComposeTransactionRequest,\n  FailedPreparedOp,\n  Flow,\n  InputSpec,\n  MaterialiserConfigOf,\n  MaterialiserInput,\n  OutputAmount,\n  Amount,\n  ConsumedOutput,\n  Delivery,\n  Estimate,\n  EstimateBasis,\n  Minimum,\n  MinimumBasis,\n  Output,\n  Outputs,\n  TerminalOutput,\n  Precondition,\n  PreconditionConfigOf,\n  PriceImpact,\n  Ref,\n  Resource,\n  RouteAmount,\n  RouteAmountAll,\n  RouteAmountExact,\n  SimulationPolicy,\n  SimulationRevert,\n  DeliveryErrorDetails,\n  DeliveryErrorReason,\n  SolType,\n  ForwardTo,\n  SimulateRequest,\n  SimulateResult,\n  SimulateOkResult,\n  SimulateRevertResult,\n  SimulateRevertDecodeResult,\n  SimulateSetupErrorResult,\n  SimulateBalanceEntry,\n  TrackedBalance,\n  SlotFinderRequirement,\n  Erc20BalanceRequirement,\n  NativeBalanceRequirement,\n  Erc20AllowanceRequirement,\n  ContinuationIntent,\n  ContinuationOutcome,\n  SettlementWire,\n  SettlementEscrowWire,\n  SettlementBindingWire,\n} from '@lifi/compose-spec';\nexport {\n  SIMULATE_MAX_TRACKED_BALANCES,\n  SIMULATE_MAX_REQUIREMENTS,\n} from '@lifi/compose-spec';\nexport {\n  isComposeDeliveryError,\n  isComposeError,\n  isComposePreparationError,\n  isComposeSdkOutdatedError,\n  isComposeServerOutdatedError,\n} from './errors.js';\n\nexport type {\n  Bindable,\n  RefBindable,\n  AnyRefBindable,\n  InputHandle,\n  ResourceInputHandle,\n  OutputHandle,\n  OutputFamilyHandles,\n  FamilyCount,\n  FamilySource,\n  AnyHandle,\n} from './authoring/handles.js';\nexport { isInputHandle, isOutputHandle } from './authoring/handles.js';\nexport { ref } from './authoring/raw.js';\n\nexport type { AnyBindable } from './authoring/FlowBuilderCore.js';\nexport type { TypedFlow, FlowOptions } from './authoring/FlowBuilderCore.js';\n\nexport type { ComposeRunInput } from './run/inputs.js';\nexport { materialiser } from './run/inputs.js';\n\nexport { buildSimulateRequest } from './run/simulate.js';\nexport type { BuildSimulateRequestInput } from './run/simulate.js';\n\nexport { terminalOutputs } from './outputs.js';\n\nexport { createComposeSdk } from './sdk.js';\nexport type { ComposeSdk, ComposeSdkOptions, FlowBuilder } from './sdk.js';\n\nimport * as guardsMod from './generated/guards.generated.js';\nimport * as materialisersMod from './generated/materialisers.generated.js';\nimport * as preconditionsMod from './generated/preconditions.generated.js';\nimport * as rawMod from './raw.js';\nimport * as resourcesMod from './resources.js';\nimport * as routeAmountMod from './routeAmount.js';\n\n/**\n * Guard factories for protecting operation outputs (e.g. slippage tolerance).\n * Pass guards to an operation's `guards` array.\n *\n * @example\n * ```ts\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.token },\n *   config: { resourceOut: resources.native(1) },\n *   guards: [guards.slippage({ port: 'amountOut', bps: 300 })],\n * });\n * ```\n */\nexport const guards: typeof guardsMod = guardsMod;\n/**\n * Materialiser factories that tell the runtime how to resolve token input\n * amounts on-chain (e.g. read a wallet balance, accept a direct deposit).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   signer: '0x...',\n * });\n * ```\n */\nexport const materialisers: typeof materialisersMod = materialisersMod;\n/**\n * Precondition factories for asserting on-chain state before a flow executes\n * (e.g. minimum token balances, ERC-20 allowances).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   preconditions: [\n *     preconditions.erc20Balance({ wallet: '0x...', token: '0x...', balance: 1000n }),\n *   ],\n *   signer: '0x...',\n * });\n * ```\n */\nexport const preconditions: typeof preconditionsMod = preconditionsMod;\n/**\n * Resource declaration helpers for defining token inputs in a flow schema.\n * Use {@link resources.erc20} for ERC-20 tokens and {@link resources.native}\n * for the chain's native coin (ETH, MATIC, etc.).\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: {\n *     usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1),\n *     eth: resources.native(1),\n *   },\n * });\n * ```\n */\nexport const resources: typeof resourcesMod = resourcesMod;\n/**\n * Amount constructors for {@link ComposeSdk.route}. Use\n * {@link routeAmount.exact} to spend a fixed amount of the `fromToken`, and\n * {@link routeAmount.all} to spend the signer's whole balance.\n *\n * @example\n * ```ts\n * // USDC into the Aave v3 aEthUSDC position — one routing-catalog edge.\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',\n *   toToken: '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c',\n *   amount: routeAmount.exact(1_000_000n),\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport const routeAmount: typeof routeAmountMod = routeAmountMod;\nexport * from './generated/config.generated.js';\n\n/**\n * Low-level escape hatch for constructing flow nodes, guards, and materialiser\n * inputs without the typed builder API. Prefer the generated operation methods\n * on {@link FlowBuilder} and the typed `guards`/`materialisers` namespaces\n * for most use cases.\n */\nexport const raw: typeof rawMod = rawMod;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwKA,MAAa,SAA2BA;;;;;;;;;;;;;AAaxC,MAAa,gBAAyCC;;;;;;;;;;;;;;;;AAgBtD,MAAa,gBAAyCC;;;;;;;;;;;;;;;;AAgBtD,MAAa,YAAiCC;;;;;;;;;;;;;;;;;;AAkB9C,MAAa,cAAqCC;;;;;;;AASlD,MAAa,MAAqBC"}
+{"version":3,"file":"index.js","names":["guardsMod","materialisersMod","preconditionsMod","resourcesMod","routeAmountMod","rawMod"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@lifi/composer-sdk` — TypeScript SDK for building and compiling\n * Compose flows into executable EVM calldata.\n *\n * Start by creating an SDK instance with {@link createComposeSdk}, then use\n * {@link ComposeSdk.flow} to build flows and compile them.\n *\n * @packageDocumentation\n */\n\nexport type {\n  AbiTypeToOutputKind,\n  Address,\n  InputDecl,\n  InputSchema,\n  InputSpecOf,\n  IntegerString,\n  IntegerStringInput,\n  OutputKind,\n  TypedGuard,\n  TypedRef,\n  TypedLiteral,\n} from './types.js';\n\nexport type {\n  ChainSummary,\n  GetZapPacksOptions,\n  ZapPackEdge,\n  ZapPackOverview,\n} from './discovery.js';\nexport type {\n  Reachability,\n  ReachabilityOptions,\n  RoutablePair,\n  TokenRef,\n} from './reachability.js';\nexport { buildReachability } from './reachability.js';\nexport type {\n  ComposeError,\n  ComposeErrorCode,\n  ComposeSdkOutdated,\n  ComposeServerOutdated,\n  ComposePreparationOps,\n} from './errors.js';\nexport type {\n  AppliedGuard,\n  ApprovalEntry,\n  Call,\n  ComposeCompilePartialData,\n  ComposeAction,\n  ComposeFill,\n  ComposeUserProgramSimulation,\n  ComposeWarning,\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeCompileSuccessData,\n  ComposeErrorKind,\n  ComposeRouteRequest,\n  ComposeTransactionRequest,\n  FailedPreparedOp,\n  Flow,\n  InputSpec,\n  MaterialiserConfigOf,\n  MaterialiserInput,\n  OutputAmount,\n  Amount,\n  ConsumedOutput,\n  Delivery,\n  Estimate,\n  EstimateBasis,\n  Minimum,\n  MinimumBasis,\n  Output,\n  Outputs,\n  TerminalOutput,\n  Precondition,\n  PreconditionConfigOf,\n  PriceImpact,\n  Ref,\n  Resource,\n  RouteAmount,\n  RouteAmountAll,\n  RouteAmountExact,\n  SimulationPolicy,\n  SimulationRevert,\n  DeliveryErrorDetails,\n  DeliveryErrorReason,\n  SolType,\n  ForwardTo,\n  SimulateRequest,\n  SimulateResult,\n  SimulateOkResult,\n  SimulateRevertResult,\n  SimulateRevertDecodeResult,\n  SimulateSetupErrorResult,\n  SimulateBalanceEntry,\n  TrackedBalance,\n  SlotFinderRequirement,\n  Erc20BalanceRequirement,\n  NativeBalanceRequirement,\n  Erc20AllowanceRequirement,\n  Permit2AllowanceRequirement,\n  ContinuationIntent,\n  ContinuationOutcome,\n  SettlementWire,\n  SettlementEscrowWire,\n  SettlementBindingWire,\n} from '@lifi/compose-spec';\nexport {\n  SIMULATE_MAX_TRACKED_BALANCES,\n  SIMULATE_MAX_REQUIREMENTS,\n} from '@lifi/compose-spec';\nexport {\n  isComposeDeliveryError,\n  isComposeError,\n  isComposePreparationError,\n  isComposeSdkOutdatedError,\n  isComposeServerOutdatedError,\n} from './errors.js';\n\nexport type {\n  Bindable,\n  RefBindable,\n  AnyRefBindable,\n  InputHandle,\n  ResourceInputHandle,\n  OutputHandle,\n  OutputFamilyHandles,\n  FamilyCount,\n  FamilySource,\n  AnyHandle,\n} from './authoring/handles.js';\nexport { isInputHandle, isOutputHandle } from './authoring/handles.js';\nexport { ref } from './authoring/raw.js';\n\nexport type { AnyBindable } from './authoring/FlowBuilderCore.js';\nexport type { TypedFlow, FlowOptions } from './authoring/FlowBuilderCore.js';\n\nexport type { ComposeRunInput } from './run/inputs.js';\nexport { materialiser } from './run/inputs.js';\n\nexport { buildSimulateRequest } from './run/simulate.js';\nexport type { BuildSimulateRequestInput } from './run/simulate.js';\n\nexport { terminalOutputs } from './outputs.js';\n\nexport { createComposeSdk } from './sdk.js';\nexport type { ComposeSdk, ComposeSdkOptions, FlowBuilder } from './sdk.js';\n\nimport * as guardsMod from './generated/guards.generated.js';\nimport * as materialisersMod from './generated/materialisers.generated.js';\nimport * as preconditionsMod from './generated/preconditions.generated.js';\nimport * as rawMod from './raw.js';\nimport * as resourcesMod from './resources.js';\nimport * as routeAmountMod from './routeAmount.js';\n\n/**\n * Guard factories for protecting operation outputs (e.g. slippage tolerance).\n * Pass guards to an operation's `guards` array.\n *\n * @example\n * ```ts\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.token },\n *   config: { resourceOut: resources.native(1) },\n *   guards: [guards.slippage({ port: 'amountOut', bps: 300 })],\n * });\n * ```\n */\nexport const guards: typeof guardsMod = guardsMod;\n/**\n * Materialiser factories that tell the runtime how to resolve token input\n * amounts on-chain (e.g. read a wallet balance, accept a direct deposit).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   signer: '0x...',\n * });\n * ```\n */\nexport const materialisers: typeof materialisersMod = materialisersMod;\n/**\n * Precondition factories for asserting on-chain state before a flow executes\n * (e.g. minimum token balances, ERC-20 allowances).\n *\n * @example\n * ```ts\n * await builder.compile({\n *   inputs: { token: materialisers.balanceOf({}) },\n *   preconditions: [\n *     preconditions.erc20Balance({ wallet: '0x...', token: '0x...', balance: 1000n }),\n *   ],\n *   signer: '0x...',\n * });\n * ```\n */\nexport const preconditions: typeof preconditionsMod = preconditionsMod;\n/**\n * Resource declaration helpers for defining token inputs in a flow schema.\n * Use {@link resources.erc20} for ERC-20 tokens and {@link resources.native}\n * for the chain's native coin (ETH, MATIC, etc.).\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: {\n *     usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1),\n *     eth: resources.native(1),\n *   },\n * });\n * ```\n */\nexport const resources: typeof resourcesMod = resourcesMod;\n/**\n * Amount constructors for {@link ComposeSdk.route}. Use\n * {@link routeAmount.exact} to spend a fixed amount of the `fromToken`, and\n * {@link routeAmount.all} to spend the signer's whole balance.\n *\n * @example\n * ```ts\n * // USDC into the Aave v3 aEthUSDC position — one routing-catalog edge.\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',\n *   toToken: '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c',\n *   amount: routeAmount.exact(1_000_000n),\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport const routeAmount: typeof routeAmountMod = routeAmountMod;\nexport * from './generated/config.generated.js';\n\n/**\n * Low-level escape hatch for constructing flow nodes, guards, and materialiser\n * inputs without the typed builder API. Prefer the generated operation methods\n * on {@link FlowBuilder} and the typed `guards`/`materialisers` namespaces\n * for most use cases.\n */\nexport const raw: typeof rawMod = rawMod;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyKA,MAAa,SAA2BA;;;;;;;;;;;;;AAaxC,MAAa,gBAAyCC;;;;;;;;;;;;;;;;AAgBtD,MAAa,gBAAyCC;;;;;;;;;;;;;;;;AAgBtD,MAAa,YAAiCC;;;;;;;;;;;;;;;;;;AAkB9C,MAAa,cAAqCC;;;;;;;AASlD,MAAa,MAAqBC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/composer-sdk",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Public Composer SDK for building and submitting flows",
   "license": "Apache-2.0",
   "repository": {
@@ -47,7 +47,7 @@
     "example:staged": "tsx src/examples/run.ts --staged"
   },
   "peerDependencies": {
-    "@lifi/compose-spec": "0.12.0"
+    "@lifi/compose-spec": "0.13.0"
   },
   "dependencies": {
     "abitype": "^1.2.3",

package/src/examples/continuationExactInvoice.ts

@@ -0,0 +1,341 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import {
+  type ComposeSdk,
+  type ContinuationSettleConfig,
+  createComposeSdk,
+  materialisers,
+  raw,
+  resources,
+} from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL, RECIPIENT } from './config.js';
+
+const ARBITRUM = 42161;
+const BASE = 8453;
+const ARB_USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
+const USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
+const WETH = '0x4200000000000000000000000000000000000006';
+// Request Network's ERC20FeeProxy on Base. It moves `amount` to `to` and
+// `feeAmount` to `feeAddress` from the caller with `transferFrom`, and emits
+// `TransferWithReferenceAndFee` with the payment reference: the event that
+// marks the invoice paid.
+const ERC20_FEE_PROXY = '0x1892196E80C4c17ea5100Da765Ab48c1fE2Fb814';
+const VALIDITY_WINDOW_MS = 3_600_000;
+
+/** A Request Network invoice payable in USDC on Base. */
+export interface UsdcInvoice {
+  readonly payee: Address;
+  // USDC base units (6 decimals) paid to `payee`.
+  readonly amount: bigint;
+  // USDC base units paid to `feeAddress`; may be 0.
+  readonly fee: bigint;
+  readonly feeAddress: Address;
+  // The invoice's payment reference (8 bytes for Request Network).
+  readonly paymentReference: `0x${string}`;
+}
+
+// A sample invoice for the examples: 990 USDC to the payee plus a 10 USDC fee.
+export const SAMPLE_INVOICE: UsdcInvoice = {
+  payee: RECIPIENT,
+  amount: 990_000_000n,
+  fee: 10_000_000n,
+  feeAddress: '0x2222222222222222222222222222222222222222',
+  paymentReference: '0x8c6f1d3b4a5e7c21',
+};
+
+export interface ContinuationExactInvoiceInput {
+  readonly owner: Address;
+  readonly invoice: UsdcInvoice;
+  // USDC base units the escrow is funded with. Must exceed
+  // `invoice.amount + invoice.fee`: the surplus, the settle's only outcome,
+  // returns to `owner`, and an outcome must commit a positive floor.
+  readonly usdcAmount: `${bigint}`;
+}
+
+export interface ContinuationExactSwapInvoiceInput {
+  readonly owner: Address;
+  readonly invoice: UsdcInvoice;
+  // WETH base units (18 decimals) swapped to USDC. The swap's guaranteed
+  // minimum output must exceed `invoice.amount + invoice.fee`, for the same
+  // reason as `usdcAmount` above.
+  readonly wethAmount: `${bigint}`;
+}
+
+export interface ContinuationExactIntentInvoiceInput {
+  readonly owner: Address;
+  readonly invoice: UsdcInvoice;
+  // Native ETH base units (18 decimals) on Arbitrum, swapped to Arbitrum
+  // USDC. The swap's guaranteed minimum output must cover the input the
+  // solver asks for the invoice total plus one unit; the rest returns to
+  // `owner`.
+  readonly ethAmount: `${bigint}`;
+}
+
+/**
+ * The leg every example settles: split the invoice total off the escrowed
+ * USDC, pay it through `ERC20FeeProxy`, and leave the surplus in the leg's
+ * proxy as the settle's outcome, if the settle commits one.
+ *
+ * `core.call` declares no settlement verification, so only an exact settle
+ * may run it. The invoice terms are constants of the leg document, so each
+ * argument is a `raw.literal` of the parameter's Solidity type. The leg names
+ * no funding amount: at fill the executor's proxy sweeps the escrowed USDC
+ * into `input.funding`.
+ */
+const buildInvoiceLeg = (sdk: ComposeSdk, invoice: UsdcInvoice): Flow => {
+  const leg = sdk.flow(BASE, {
+    name: 'pay-invoice-leg',
+    inputs: { funding: resources.erc20(USDC, BASE) },
+  });
+  // `head` is the invoice total; `tail`, the surplus, stays in the proxy.
+  const { head } = leg.core.splitAt('invoice', {
+    bind: { source: leg.inputs.funding },
+    config: { amount: `${invoice.amount + invoice.fee}` },
+  });
+  leg.core.call('pay', {
+    resource: head,
+    bind: {
+      tokenAddress: raw.literal('address', USDC),
+      to: raw.literal('address', invoice.payee),
+      amount: raw.literal('uint256', `${invoice.amount}`),
+      paymentReference: raw.literal('bytes', invoice.paymentReference),
+      feeAmount: raw.literal('uint256', `${invoice.fee}`),
+      feeAddress: raw.literal('address', invoice.feeAddress),
+    },
+    config: {
+      target: ERC20_FEE_PROXY,
+      functionSignature:
+        'function transferFromWithReferenceAndFee(address tokenAddress, address to, uint256 amount, bytes paymentReference, uint256 feeAmount, address feeAddress)',
+      // The fee proxy pulls the USDC with `transferFrom`.
+      approvals: [{ spender: ERC20_FEE_PROXY }],
+    },
+  });
+  return leg.build();
+};
+
+/**
+ * The exact settle config every example shares: the leg's leftover USDC
+ * returns to `owner` on Base, and so does the escrow if it expires unfilled.
+ */
+const invoiceSettleConfig = (
+  sdk: ComposeSdk,
+  owner: Address,
+  invoice: UsdcInvoice,
+): ContinuationSettleConfig => ({
+  exact: true,
+  outcomes: [{ token: USDC, destination: owner, chainId: BASE }],
+  validity: { expiresAtMs: Date.now() + VALIDITY_WINDOW_MS },
+  provider: 'intent-factory',
+  refund: owner,
+  continuationFlow: buildInvoiceLeg(sdk, invoice),
+});
+
+/**
+ * Escrow USDC on Base for an exact continuation leg that pays a Request
+ * Network invoice, and return the surplus to the owner.
+ *
+ * Demonstrates:
+ * - `exact: true` on `continuation.settle`: the escrow is bound to the leg's
+ *   compiled calldata, so the solver runs exactly those bytes and chooses
+ *   nothing. A committed (non-exact) leg rejects `core.call`, because a
+ *   balance cannot prove that an invoice was paid; an exact leg admits it.
+ * - A leg that pays a third party (`invoice.payee`), which only an exact leg
+ *   may do: its bytes are fixed at compile time.
+ * - The surplus (`usdcAmount` minus the invoice total) as the outcome. The
+ *   compile proves its floor at the escrow's funding floor, so `minAmount` is
+ *   omitted. A surplus of 0 proves no floor, and the compile rejects it.
+ * - Funding from a declared input, transferred into the escrow inline by the
+ *   user's transaction.
+ *
+ * Reading the response:
+ * - `settlements.settle.escrow` holds the registered escrow. `binding` holds
+ *   what the escrow is bound to: the solver's executor (`executionTarget`),
+ *   the compiled leg (`calldata`), its `approvals`, and the `payload` the
+ *   settlement service hashes into `payloadHash`.
+ * - Inline funding means the user's `execute` transaction funds the escrow.
+ *   Before submitting it, check that `payloadHash` is the hash of `payload`,
+ *   for example with viem:
+ *   `keccak256(binding.payload) === binding.payloadHash.toLowerCase()`.
+ *   On a mismatch, do not submit.
+ *
+ * The exact-leg rules:
+ * - No leg node may quote off-chain or declare an expiring route:
+ *   `lifi.swap`, `paraswap.buy`, `core.peek` and any prepared op fail
+ *   `validation_error` at the leg node, because the bound bytes cannot be
+ *   re-quoted at fill.
+ * - The settle's funding must be an ERC-20 from a declared input, an upstream
+ *   output, or a `lifi.bridge` or `lifiIntents.order` delivery into the
+ *   escrow: native funding fails `validation_error`.
+ * - The deployment must serve exact legs (an intent-factory provider
+ *   configured with the solver's executor); elsewhere the settle fails
+ *   `validation_error` before any registration.
+ */
+export const buildContinuationExactInvoiceExample = ({
+  owner,
+  invoice,
+  usdcAmount,
+}: ContinuationExactInvoiceInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(BASE, {
+    name: 'pay-invoice',
+    inputs: { usdc: resources.erc20(USDC, BASE) },
+  });
+  builder.continuation.settle('settle', {
+    bind: { input: builder.inputs.usdc },
+    config: invoiceSettleConfig(sdk, owner, invoice),
+  });
+
+  const flow = builder.build();
+
+  // No `sweepTo`: the funding moves into the escrow, and the surplus reaches
+  // the owner through the settlement, never through the user's proxy.
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      usdc: materialisers.directDeposit({ amount: usdcAmount }),
+    },
+    // The price-impact check compares the flow's input value with its output
+    // value. The invoice payment leaves the flow, so the check would count it
+    // as lost value (1,050 USDC in, a 50 USDC surplus out: 95% impact) and
+    // reject the compile. `0` disables the check.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};
+
+/**
+ * Pay the same USDC invoice from WETH: the user's transaction swaps WETH to
+ * USDC and escrows the swap output for the exact leg.
+ *
+ * Demonstrates:
+ * - An exact settle funded by an upstream output (`swap.amountOut`). The
+ *   escrow's funding floor is the swap's guaranteed minimum output, and the
+ *   leg is proven at that floor, so the minimum must exceed the invoice total.
+ * - The quote rule applies to the leg only. The main flow runs inside the
+ *   user's transaction, so its `lifi.swap` may quote; the leg, bound to fixed
+ *   bytes until the fill, may not.
+ */
+export const buildContinuationExactSwapInvoiceExample = ({
+  owner,
+  invoice,
+  wethAmount,
+}: ContinuationExactSwapInvoiceInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(BASE, {
+    name: 'swap-and-pay-invoice',
+    inputs: { weth: resources.erc20(WETH, BASE) },
+  });
+  const swap = builder.lifi.swap('swap', {
+    bind: { amountIn: builder.inputs.weth },
+    config: { resourceOut: resources.erc20(USDC, BASE) },
+  });
+  builder.continuation.settle('settle', {
+    bind: { input: swap.amountOut },
+    config: invoiceSettleConfig(sdk, owner, invoice),
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      weth: materialisers.directDeposit({ amount: wethAmount }),
+    },
+    // The invoice payment leaves the flow, so the price-impact check would
+    // count it as lost value. `0` disables the check, and with it the only
+    // bound on the swap's price against the market. The swap's minimum output
+    // bounds only slippage against its own quote. Before signing, compare
+    // that minimum (`settlements.settle.escrow.floor` in the response) with
+    // an independent WETH price.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};
+
+/**
+ * Pay the same USDC invoice on Base from ETH on Arbitrum: the user's
+ * transaction swaps ETH to Arbitrum USDC and opens an exact-output LI.FI
+ * Intents order whose solver delivers Base USDC into the escrow.
+ *
+ * Demonstrates:
+ * - An exact settle funded by a `lifiIntents.order` delivery: the order omits
+ *   `destination`, the solver delivers into the escrow on Base, and the user
+ *   signs one transaction on Arbitrum.
+ * - `exactAmountOut` `T`, the invoice total, and `outcomes: []`. The leg pays
+ *   all of `T`, so nothing is left on Base and the settle commits no outcome.
+ *   An outcome would need a positive floor, so it would cost an extra unit of
+ *   funding that only lands on Base as dust.
+ * - The escrow registers at `T` itself, with no drift margin: an exact-output
+ *   order delivers exactly `T` on both of the compile's quotes, so the leg
+ *   compiles at `T`.
+ *
+ * Sizing the deposit:
+ * - The solver quotes the Arbitrum USDC input `X` it needs for exactly `T`,
+ *   and the order pulls exactly `X`. The swap's minimum output must cover
+ *   `X`, or the compile fails with a 422 `preparation_error` whose failed op
+ *   is a `validation_error` naming both amounts. Deposit enough ETH for the
+ *   swap's minimum to clear `X` with room to spare.
+ * - The rest of the swap output (`order.unspentIn`) returns to `owner` as
+ *   Arbitrum USDC through `sweepTo`, in the same transaction. All slack
+ *   (swap slippage, the solver's price, the sizing buffer) lands there, not
+ *   on Base.
+ */
+export const buildContinuationExactIntentInvoiceExample = ({
+  owner,
+  invoice,
+  ethAmount,
+}: ContinuationExactIntentInvoiceInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(ARBITRUM, {
+    name: 'intent-and-pay-invoice',
+    inputs: { eth: resources.native(ARBITRUM) },
+  });
+  const swap = builder.lifi.swap('swap', {
+    bind: { amountIn: builder.inputs.eth },
+    config: { resourceOut: resources.erc20(ARB_USDC, ARBITRUM) },
+  });
+  const order = builder.lifiIntents.order('order', {
+    bind: { amountIn: swap.amountOut },
+    config: {
+      resourceOut: resources.erc20(USDC, BASE),
+      exactAmountOut: `${invoice.amount + invoice.fee}`,
+    },
+  });
+  builder.continuation.settle('settle', {
+    bind: { input: order.amountOut },
+    config: { ...invoiceSettleConfig(sdk, owner, invoice), outcomes: [] },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      eth: materialisers.directDeposit({ amount: ethAmount }),
+    },
+    // Returns the order's unspent Arbitrum USDC to the owner.
+    sweepTo: owner,
+    // The invoice payment leaves the flow, so the price-impact check would
+    // count it as lost value. `0` disables the check; the swap is then bounded
+    // only by its slippage against its own quote.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};

package/src/examples/run.ts

@@ -18,6 +18,9 @@
  *   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
+ *   continuation-exact-invoice      — escrow USDC on Base for an exact leg that pays a Request Network invoice
+ *   continuation-exact-swap-invoice — swap WETH to USDC on Base, escrow it for the same exact invoice leg
+ *   continuation-exact-intent-invoice — swap Arbitrum ETH to USDC, order exactly the invoice total on Base for the same exact leg, with no outcome
  *   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
@@ -65,6 +68,12 @@ 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 {
+  buildContinuationExactIntentInvoiceExample,
+  buildContinuationExactInvoiceExample,
+  buildContinuationExactSwapInvoiceExample,
+  SAMPLE_INVOICE,
+} from './continuationExactInvoice.js';
 import { buildContinuationSettleExample } from './continuationSettle.js';
 import { buildDepositFromProxy } from './depositFromProxy.js';
 import { buildDustSweepExample } from './dustSweep.js';
@@ -142,6 +151,24 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
     buildContinuationSettleExample({ owner: OWNER }).request,
   'continuation-bridge-settle': () =>
     buildContinuationBridgeSettleExample({ owner: OWNER }).request,
+  'continuation-exact-invoice': () =>
+    buildContinuationExactInvoiceExample({
+      owner: OWNER,
+      invoice: SAMPLE_INVOICE,
+      usdcAmount: '1050000000',
+    }).request,
+  'continuation-exact-swap-invoice': () =>
+    buildContinuationExactSwapInvoiceExample({
+      owner: OWNER,
+      invoice: SAMPLE_INVOICE,
+      wethAmount: '1000000000000000000',
+    }).request,
+  'continuation-exact-intent-invoice': () =>
+    buildContinuationExactIntentInvoiceExample({
+      owner: OWNER,
+      invoice: SAMPLE_INVOICE,
+      ethAmount: '500000000000000000',
+    }).request,
   'deposit-proxy': () =>
     buildDepositFromProxy({
       owner: OWNER,

package/src/generated/config.generated.ts

@@ -1286,35 +1286,18 @@ export interface FlySwapConfig {
 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;
-    }[],
-  ];
+  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;
+  }[];
   continuationFlow?: Flow;
   validity: {
     expiresAtMs: Between86400000000000008640000000000000;
@@ -1436,6 +1419,7 @@ export interface LifiIntentsOrderConfig {
   slippage?: LessThan1;
   validitySeconds?: Between1300;
   exclusiveSeconds?: Between0120;
+  exactAmountOut?: string;
 }
 
 export interface LifiIntentsRefundConfig {

package/src/index.ts

@@ -99,6 +99,7 @@ export type {
   Erc20BalanceRequirement,
   NativeBalanceRequirement,
   Erc20AllowanceRequirement,
+  Permit2AllowanceRequirement,
   ContinuationIntent,
   ContinuationOutcome,
   SettlementWire,