@lifi/composer-sdk 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef } from './types.js';
-export { GetZapPacksOptions, ZapPackEdge, ZapPackOverview } from './discovery.js';
+export { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedLiteral, TypedRef } from './types.js';
+export { ChainSummary, GetZapPacksOptions, ZapPackEdge, ZapPackOverview } from './discovery.js';
 export { ComposeError, ComposeErrorCode, ComposePreparationOps, isComposeError, isComposePreparationError } from './errors.js';
-export { AppliedGuard, ApprovalEntry, Call, Check, CheckComparator, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeContinuation, ComposeErrorKind, ComposeTransactionRequest, ContinuationIntent, ContinuationOutcome, ContinuationPlanWire, Erc20AllowanceRequirement, Erc20BalanceRequirement, FailedPreparedOp, Flow, InputSpec, MaterialiserConfigOf, MaterialiserInput, NativeBalanceRequirement, Phase1ArtifactWire, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulationPolicy, SimulationRevert, SlotFinderRequirement, SolType, SweepTo, TrackedBalance } from '@lifi/compose-spec';
-export { AnyHandle, Bindable, InputHandle, OutputHandle, ResourceInputHandle, isInputHandle, isOutputHandle } from './authoring/handles.js';
+export { AppliedGuard, ApprovalEntry, Call, Check, CheckComparator, ComposeAction, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeErrorKind, ComposeFee, ComposeFill, ComposeRouteRequest, ComposeTransactionRequest, ComposeUserProgramSimulation, ContinuationIntent, ContinuationOutcome, ContinuationPlanWire, Erc20AllowanceRequirement, Erc20BalanceRequirement, FailedPreparedOp, Flow, InputSpec, MaterialiserConfigOf, MaterialiserInput, NativeBalanceRequirement, Phase1ArtifactWire, Precondition, PreconditionConfigOf, PriceImpact, ProducedResource, Ref, Resource, RouteAmount, RouteAmountAll, RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulatedAmounts, SimulationPolicy, SimulationRevert, SlotFinderRequirement, SolType, SweepTo, TrackedBalance } from '@lifi/compose-spec';
+export { AnyHandle, AnyRefBindable, Bindable, InputHandle, OutputHandle, RefBindable, ResourceInputHandle, isInputHandle, isOutputHandle } from './authoring/handles.js';
 export { ref } from './authoring/raw.js';
 export { AnyBindable, FlowOptions, TypedFlow } from './authoring/FlowBuilderCore.js';
 export { ComposeRunInput, materialiser } from './run/inputs.js';
@@ -11,9 +11,10 @@ export { ComposeSdk, ComposeSdkOptions, FlowBuilder, createComposeSdk } from './
 import { g as guardsMod } from './guards.generated-BPLFwe7y.js';
 import { m as materialisersMod } from './materialisers.generated-BMkBQgWZ.js';
 import { p as preconditionsMod } from './preconditions.generated-U7YpVh30.js';
-import { r as rawMod } from './raw-IxCF_bSS.js';
+import { r as rawMod } from './raw-BvRghN3r.js';
 import { r as resourcesMod } from './resources-CYis1_DS.js';
-export { AaveBorrowConfig, AaveClaimRewardsConfig, AaveGetHealthFactorConfig, AaveRepayConfig, AaveRepayWithATokensConfig, AaveSetEModeConfig, BalanceOfMaterialiserConfig, Between010000, Between0255, CallMaterialiserConfig, ContinuationAssertReadyConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreEmitEvent1Config, CoreEmitEvent2Config, CoreEmitEvent3Config, CoreEmitEvent4Config, CoreInvokeConfig, CoreNumericInvariantGuardConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, Erc20BalancePreconditionConfig, FlashloanMaterialiserConfig, InvariantEqConfig, InvariantGtConfig, InvariantGteConfig, InvariantLtConfig, InvariantLteConfig, InvariantNeqConfig, InvariantNumericConfig, InvariantNumericInRangeConfig, LifiFlashloanRepayConfig, LifiSwapConfig, LifiZapConfig, MaxItems50, MaxLength64, MaxLength65536, MorphoBlueBorrowConfig, MorphoBlueGetPositionConfig, MorphoBlueRepayConfig, MorphoBlueSupplyCollateralConfig, MorphoBlueSupplyConfig, MorphoBlueWithdrawCollateralConfig, MorphoBlueWithdrawConfig, NativeBalancePreconditionConfig, NonNegative, ParaswapBuyConfig, Positive, SlippageGuardConfig, StartsWith0X } from './generated/config.generated.js';
+import { r as routeAmountMod } from './routeAmount-DdbJYJyM.js';
+export { AaveBorrowConfig, AaveClaimRewardsConfig, AaveGetHealthFactorConfig, AaveRepayConfig, AaveRepayWithATokensConfig, AaveSetEModeConfig, BalanceOfMaterialiserConfig, Between010000, Between0255, Between03318, Between05000, CallMaterialiserConfig, ContinuationAssertReadyConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreEmitEvent1Config, CoreEmitEvent2Config, CoreEmitEvent3Config, CoreEmitEvent4Config, CoreInvokeConfig, CoreNumericInvariantGuardConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, Erc20BalancePreconditionConfig, FlashloanMaterialiserConfig, FlySwapConfig, InvariantEqConfig, InvariantGtConfig, InvariantGteConfig, InvariantLtConfig, InvariantLteConfig, InvariantNeqConfig, InvariantNumericConfig, InvariantNumericInRangeConfig, LifiFlashloanRepayConfig, LifiSwapConfig, LifiZapAsyncConfig, LifiZapConfig, MaxItems50, MaxLength64, MaxLength65536, MorphoBlueBorrowConfig, MorphoBlueGetPositionConfig, MorphoBlueRepayConfig, MorphoBlueSupplyCollateralConfig, MorphoBlueSupplyConfig, MorphoBlueWithdrawCollateralConfig, MorphoBlueWithdrawConfig, NativeBalancePreconditionConfig, NonNegative, ParaswapBuyConfig, Positive, SlippageGuardConfig, StartsWith0X } from './generated/config.generated.js';
 import './client.js';
 import './generated/operations.generated.js';
 import './authoring/signatureArgs.js';
@@ -88,6 +89,24 @@ declare const preconditions: typeof preconditionsMod;
  * ```
  */
 declare const resources: typeof resourcesMod;
+/**
+ * Amount constructors for {@link ComposeSdk.route}. Use
+ * {@link routeAmount.exact} to spend a fixed amount of the `fromToken`, and
+ * {@link routeAmount.all} to spend the signer's whole balance.
+ *
+ * @example
+ * ```ts
+ * // USDC into the Aave v3 aEthUSDC position — one routing-catalog edge.
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+ *   toToken: '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c',
+ *   amount: routeAmount.exact(1_000_000n),
+ *   signer: '0xYourAddress...',
+ * });
+ * ```
+ */
+declare const routeAmount: typeof routeAmountMod;
 
 /**
  * Low-level escape hatch for constructing flow nodes, guards, and materialiser
@@ -97,4 +116,4 @@ declare const resources: typeof resourcesMod;
  */
 declare const raw: typeof rawMod;
 
-export { guards, materialisers, preconditions, raw, resources };
+export { guards, materialisers, preconditions, raw, resources, routeAmount };

package/dist/index.js

@@ -13,10 +13,12 @@ import * as materialisersMod from "./generated/materialisers.generated.js";
 import * as preconditionsMod from "./generated/preconditions.generated.js";
 import * as rawMod from "./raw.js";
 import * as resourcesMod from "./resources.js";
+import * as routeAmountMod from "./routeAmount.js";
 const guards = guardsMod;
 const materialisers = materialisersMod;
 const preconditions = preconditionsMod;
 const resources = resourcesMod;
+const routeAmount = routeAmountMod;
 export * from "./generated/config.generated.js";
 const raw = rawMod;
 export {
@@ -34,6 +36,7 @@ export {
   preconditions,
   raw,
   ref,
-  resources
+  resources,
+  routeAmount
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"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} from './types.js';\n\nexport type {\n  GetZapPacksOptions,\n  ZapPackEdge,\n  ZapPackOverview,\n} from './discovery.js';\nexport type {\n  ComposeError,\n  ComposeErrorCode,\n  ComposePreparationOps,\n} from './errors.js';\nexport type {\n  AppliedGuard,\n  ApprovalEntry,\n  Call,\n  ComposeCompilePartialData,\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeCompileSuccessData,\n  ComposeContinuation,\n  ComposeErrorKind,\n  ComposeTransactionRequest,\n  FailedPreparedOp,\n  Flow,\n  InputSpec,\n  MaterialiserConfigOf,\n  MaterialiserInput,\n  Precondition,\n  PreconditionConfigOf,\n  PriceImpact,\n  Ref,\n  Resource,\n  SimulationPolicy,\n  SimulationRevert,\n  SolType,\n  SweepTo,\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  Check,\n  CheckComparator,\n  Phase1ArtifactWire,\n  ContinuationPlanWire,\n} from '@lifi/compose-spec';\nexport {\n  SIMULATE_MAX_TRACKED_BALANCES,\n  SIMULATE_MAX_REQUIREMENTS,\n} from '@lifi/compose-spec';\nexport { isComposeError, isComposePreparationError } from './errors.js';\n\nexport type {\n  Bindable,\n  InputHandle,\n  ResourceInputHandle,\n  OutputHandle,\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 { 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';\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;\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":"AA6EA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB,iCAAiC;AAS1D,SAAS,eAAe,sBAAsB;AAC9C,SAAS,WAAW;AAMpB,SAAS,oBAAoB;AAE7B,SAAS,4BAA4B;AAGrC,SAAS,wBAAwB;AAGjC,YAAY,eAAe;AAC3B,YAAY,sBAAsB;AAClC,YAAY,sBAAsB;AAClC,YAAY,YAAY;AACxB,YAAY,kBAAkB;AAevB,MAAM,SAA2B;AAajC,MAAM,gBAAyC;AAgB/C,MAAM,gBAAyC;AAgB/C,MAAM,YAAiC;AAC9C,cAAc;AAQP,MAAM,MAAqB;","names":[]}
+{"version":3,"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  ComposeError,\n  ComposeErrorCode,\n  ComposePreparationOps,\n} from './errors.js';\nexport type {\n  AppliedGuard,\n  ApprovalEntry,\n  Call,\n  ComposeCompilePartialData,\n  ComposeAction,\n  ComposeFill,\n  ComposeFee,\n  ComposeUserProgramSimulation,\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  ComposeCompileSuccessData,\n  ComposeErrorKind,\n  ComposeRouteRequest,\n  ComposeTransactionRequest,\n  FailedPreparedOp,\n  Flow,\n  InputSpec,\n  MaterialiserConfigOf,\n  MaterialiserInput,\n  Precondition,\n  PreconditionConfigOf,\n  PriceImpact,\n  ProducedResource,\n  Ref,\n  Resource,\n  RouteAmount,\n  RouteAmountAll,\n  RouteAmountExact,\n  SimulatedAmounts,\n  SimulationPolicy,\n  SimulationRevert,\n  SolType,\n  SweepTo,\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  Check,\n  CheckComparator,\n  Phase1ArtifactWire,\n  ContinuationPlanWire,\n} from '@lifi/compose-spec';\nexport {\n  SIMULATE_MAX_TRACKED_BALANCES,\n  SIMULATE_MAX_REQUIREMENTS,\n} from '@lifi/compose-spec';\nexport { isComposeError, isComposePreparationError } from './errors.js';\n\nexport type {\n  Bindable,\n  RefBindable,\n  AnyRefBindable,\n  InputHandle,\n  ResourceInputHandle,\n  OutputHandle,\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 { 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":"AAwFA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB,iCAAiC;AAW1D,SAAS,eAAe,sBAAsB;AAC9C,SAAS,WAAW;AAMpB,SAAS,oBAAoB;AAE7B,SAAS,4BAA4B;AAGrC,SAAS,wBAAwB;AAGjC,YAAY,eAAe;AAC3B,YAAY,sBAAsB;AAClC,YAAY,sBAAsB;AAClC,YAAY,YAAY;AACxB,YAAY,kBAAkB;AAC9B,YAAY,oBAAoB;AAezB,MAAM,SAA2B;AAajC,MAAM,gBAAyC;AAgB/C,MAAM,gBAAyC;AAgB/C,MAAM,YAAiC;AAkBvC,MAAM,cAAqC;AAClD,cAAc;AAQP,MAAM,MAAqB;","names":[]}

package/dist/{raw-IxCF_bSS.d.ts → raw-BvRghN3r.d.ts}

@@ -1,4 +1,4 @@
-import { rawGuard, ref } from './authoring/raw.js';
+import { rawGuard, literal, ref } from './authoring/raw.js';
 import { materialiser } from './run/inputs.js';
 
 /**
@@ -10,10 +10,11 @@ import { materialiser } from './run/inputs.js';
  * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.
  */
 
+declare const rawMod_literal: typeof literal;
 declare const rawMod_materialiser: typeof materialiser;
 declare const rawMod_ref: typeof ref;
 declare namespace rawMod {
-  export { rawGuard as guard, rawMod_materialiser as materialiser, rawMod_ref as ref };
+  export { rawGuard as guard, rawMod_literal as literal, rawMod_materialiser as materialiser, rawMod_ref as ref };
 }
 
 export { rawMod as r };

package/dist/{raw-Dj_2rBSQ.d.cts → raw-s1rer8X3.d.cts}

@@ -1,4 +1,4 @@
-import { rawGuard, ref } from './authoring/raw.cjs';
+import { rawGuard, literal, ref } from './authoring/raw.cjs';
 import { materialiser } from './run/inputs.cjs';
 
 /**
@@ -10,10 +10,11 @@ import { materialiser } from './run/inputs.cjs';
  * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.
  */
 
+declare const rawMod_literal: typeof literal;
 declare const rawMod_materialiser: typeof materialiser;
 declare const rawMod_ref: typeof ref;
 declare namespace rawMod {
-  export { rawGuard as guard, rawMod_materialiser as materialiser, rawMod_ref as ref };
+  export { rawGuard as guard, rawMod_literal as literal, rawMod_materialiser as materialiser, rawMod_ref as ref };
 }
 
 export { rawMod as r };

package/dist/raw.cjs

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var raw_exports = {};
 __export(raw_exports, {
   guard: () => import_raw.rawGuard,
+  literal: () => import_raw.literal,
   materialiser: () => import_inputs.materialiser,
   ref: () => import_raw.ref
 });
@@ -28,6 +29,7 @@ var import_inputs = require("./run/inputs.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   guard,
+  literal,
   materialiser,
   ref
 });

package/dist/raw.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/raw.ts"],"sourcesContent":["/**\n * Low-level escape hatch for constructing flow nodes and guards without the\n * typed builder API. Use these when working with operation kinds not covered\n * by the generated methods, or when you need full control over the JSON shape.\n *\n * For most use cases, prefer the generated operation methods on {@link FlowBuilder}\n * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.\n */\nexport { rawGuard as guard, ref } from './authoring/raw.js';\nexport { materialiser } from './run/inputs.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,iBAAuC;AACvC,oBAA6B;","names":[]}
+{"version":3,"sources":["../src/raw.ts"],"sourcesContent":["/**\n * Low-level escape hatch for constructing flow nodes and guards without the\n * typed builder API. Use these when working with operation kinds not covered\n * by the generated methods, or when you need full control over the JSON shape.\n *\n * For most use cases, prefer the generated operation methods on {@link FlowBuilder}\n * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.\n */\nexport { rawGuard as guard, literal, ref } from './authoring/raw.js';\nexport { materialiser } from './run/inputs.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,iBAAgD;AAChD,oBAA6B;","names":[]}

package/dist/raw.d.cts

@@ -1,4 +1,4 @@
-export { rawGuard as guard, ref } from './authoring/raw.cjs';
+export { rawGuard as guard, literal, ref } from './authoring/raw.cjs';
 export { materialiser } from './run/inputs.cjs';
 import '@lifi/compose-spec';
 import './types.cjs';

package/dist/raw.d.ts

@@ -1,4 +1,4 @@
-export { rawGuard as guard, ref } from './authoring/raw.js';
+export { rawGuard as guard, literal, ref } from './authoring/raw.js';
 export { materialiser } from './run/inputs.js';
 import '@lifi/compose-spec';
 import './types.js';

package/dist/raw.js

@@ -1,7 +1,8 @@
-import { rawGuard, ref } from "./authoring/raw.js";
+import { rawGuard, literal, ref } from "./authoring/raw.js";
 import { materialiser } from "./run/inputs.js";
 export {
   rawGuard as guard,
+  literal,
   materialiser,
   ref
 };

package/dist/raw.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/raw.ts"],"sourcesContent":["/**\n * Low-level escape hatch for constructing flow nodes and guards without the\n * typed builder API. Use these when working with operation kinds not covered\n * by the generated methods, or when you need full control over the JSON shape.\n *\n * For most use cases, prefer the generated operation methods on {@link FlowBuilder}\n * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.\n */\nexport { rawGuard as guard, ref } from './authoring/raw.js';\nexport { materialiser } from './run/inputs.js';\n"],"mappings":"AAQA,SAAqB,UAAO,WAAW;AACvC,SAAS,oBAAoB;","names":[]}
+{"version":3,"sources":["../src/raw.ts"],"sourcesContent":["/**\n * Low-level escape hatch for constructing flow nodes and guards without the\n * typed builder API. Use these when working with operation kinds not covered\n * by the generated methods, or when you need full control over the JSON shape.\n *\n * For most use cases, prefer the generated operation methods on {@link FlowBuilder}\n * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.\n */\nexport { rawGuard as guard, literal, ref } from './authoring/raw.js';\nexport { materialiser } from './run/inputs.js';\n"],"mappings":"AAQA,SAAqB,UAAO,SAAS,WAAW;AAChD,SAAS,oBAAoB;","names":[]}

package/dist/routeAmount-DdbJYJyM.d.cts

@@ -0,0 +1,55 @@
+import { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';
+
+/**
+ * Spend an exact amount of the route's `fromToken`.
+ *
+ * @param amount - Amount in the token's smallest unit. `bigint` is serialised
+ *   to a decimal string when the request is sent.
+ * @returns The `EXACT` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: NATIVE_ETH,
+ *   toToken: WETH,
+ *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+declare const exact: (amount: bigint | string) => RouteAmountExact;
+/**
+ * Spend the signer's entire `fromToken` balance, resolved on-chain at execution
+ * time.
+ *
+ * Not supported when `fromToken` is the chain's native sentinel — the server
+ * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain
+ * balance to sweep; use {@link exact} for native inputs.
+ *
+ * @param simAmount - A realistic estimate of that balance, in the token's
+ *   smallest unit. The server quotes and simulates against this value, so it
+ *   shapes the returned quote and preconditions — but the amount actually moved
+ *   is whatever the balance turns out to be.
+ * @returns The `ALL` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: USDC,
+ *   toToken: A_ETH_USDC,
+ *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+declare const all: (simAmount: bigint | string) => RouteAmountAll;
+
+declare const routeAmountMod_all: typeof all;
+declare const routeAmountMod_exact: typeof exact;
+declare namespace routeAmountMod {
+  export { routeAmountMod_all as all, routeAmountMod_exact as exact };
+}
+
+export { all as a, exact as e, routeAmountMod as r };

package/dist/routeAmount-DdbJYJyM.d.ts

@@ -0,0 +1,55 @@
+import { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';
+
+/**
+ * Spend an exact amount of the route's `fromToken`.
+ *
+ * @param amount - Amount in the token's smallest unit. `bigint` is serialised
+ *   to a decimal string when the request is sent.
+ * @returns The `EXACT` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: NATIVE_ETH,
+ *   toToken: WETH,
+ *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+declare const exact: (amount: bigint | string) => RouteAmountExact;
+/**
+ * Spend the signer's entire `fromToken` balance, resolved on-chain at execution
+ * time.
+ *
+ * Not supported when `fromToken` is the chain's native sentinel — the server
+ * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain
+ * balance to sweep; use {@link exact} for native inputs.
+ *
+ * @param simAmount - A realistic estimate of that balance, in the token's
+ *   smallest unit. The server quotes and simulates against this value, so it
+ *   shapes the returned quote and preconditions — but the amount actually moved
+ *   is whatever the balance turns out to be.
+ * @returns The `ALL` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: USDC,
+ *   toToken: A_ETH_USDC,
+ *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+declare const all: (simAmount: bigint | string) => RouteAmountAll;
+
+declare const routeAmountMod_all: typeof all;
+declare const routeAmountMod_exact: typeof exact;
+declare namespace routeAmountMod {
+  export { routeAmountMod_all as all, routeAmountMod_exact as exact };
+}
+
+export { all as a, exact as e, routeAmountMod as r };

package/dist/routeAmount.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var routeAmount_exports = {};
+__export(routeAmount_exports, {
+  all: () => all,
+  exact: () => exact
+});
+module.exports = __toCommonJS(routeAmount_exports);
+const exact = (amount) => ({
+  type: "EXACT",
+  amount
+});
+const all = (simAmount) => ({
+  type: "ALL",
+  simAmount
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  all,
+  exact
+});
+//# sourceMappingURL=routeAmount.cjs.map

package/dist/routeAmount.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routeAmount.ts"],"sourcesContent":["import type { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';\n\n// Constructors for the `amount` member of a `ComposeRouteRequest`. The wire\n// union is discriminated by `type` and — deliberately, because the two variants\n// mean different things — names its payload field differently in each variant:\n// `amount` is the sum actually moved, `simAmount` is only a quoting stand-in for\n// a balance resolved on-chain. These helpers keep call sites from having to\n// remember which name goes with which discriminant.\n\n/**\n * Spend an exact amount of the route's `fromToken`.\n *\n * @param amount - Amount in the token's smallest unit. `bigint` is serialised\n *   to a decimal string when the request is sent.\n * @returns The `EXACT` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: NATIVE_ETH,\n *   toToken: WETH,\n *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped\n *   signer: OWNER,\n * });\n * ```\n */\nexport const exact = (amount: bigint | string): RouteAmountExact => ({\n  type: 'EXACT',\n  amount,\n});\n\n/**\n * Spend the signer's entire `fromToken` balance, resolved on-chain at execution\n * time.\n *\n * Not supported when `fromToken` is the chain's native sentinel — the server\n * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain\n * balance to sweep; use {@link exact} for native inputs.\n *\n * @param simAmount - A realistic estimate of that balance, in the token's\n *   smallest unit. The server quotes and simulates against this value, so it\n *   shapes the returned quote and preconditions — but the amount actually moved\n *   is whatever the balance turns out to be.\n * @returns The `ALL` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: USDC,\n *   toToken: A_ETH_USDC,\n *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand\n *   signer: OWNER,\n * });\n * ```\n */\nexport const all = (simAmount: bigint | string): RouteAmountAll => ({\n  type: 'ALL',\n  simAmount,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BO,MAAM,QAAQ,CAAC,YAA+C;AAAA,EACnE,MAAM;AAAA,EACN;AACF;AA2BO,MAAM,MAAM,CAAC,eAAgD;AAAA,EAClE,MAAM;AAAA,EACN;AACF;","names":[]}

package/dist/routeAmount.d.cts

@@ -0,0 +1,2 @@
+import '@lifi/compose-spec';
+export { a as all, e as exact } from './routeAmount-DdbJYJyM.cjs';

package/dist/routeAmount.d.ts

@@ -0,0 +1,2 @@
+import '@lifi/compose-spec';
+export { a as all, e as exact } from './routeAmount-DdbJYJyM.js';

package/dist/routeAmount.js

@@ -0,0 +1,13 @@
+const exact = (amount) => ({
+  type: "EXACT",
+  amount
+});
+const all = (simAmount) => ({
+  type: "ALL",
+  simAmount
+});
+export {
+  all,
+  exact
+};
+//# sourceMappingURL=routeAmount.js.map

package/dist/routeAmount.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routeAmount.ts"],"sourcesContent":["import type { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';\n\n// Constructors for the `amount` member of a `ComposeRouteRequest`. The wire\n// union is discriminated by `type` and — deliberately, because the two variants\n// mean different things — names its payload field differently in each variant:\n// `amount` is the sum actually moved, `simAmount` is only a quoting stand-in for\n// a balance resolved on-chain. These helpers keep call sites from having to\n// remember which name goes with which discriminant.\n\n/**\n * Spend an exact amount of the route's `fromToken`.\n *\n * @param amount - Amount in the token's smallest unit. `bigint` is serialised\n *   to a decimal string when the request is sent.\n * @returns The `EXACT` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: NATIVE_ETH,\n *   toToken: WETH,\n *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped\n *   signer: OWNER,\n * });\n * ```\n */\nexport const exact = (amount: bigint | string): RouteAmountExact => ({\n  type: 'EXACT',\n  amount,\n});\n\n/**\n * Spend the signer's entire `fromToken` balance, resolved on-chain at execution\n * time.\n *\n * Not supported when `fromToken` is the chain's native sentinel — the server\n * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain\n * balance to sweep; use {@link exact} for native inputs.\n *\n * @param simAmount - A realistic estimate of that balance, in the token's\n *   smallest unit. The server quotes and simulates against this value, so it\n *   shapes the returned quote and preconditions — but the amount actually moved\n *   is whatever the balance turns out to be.\n * @returns The `ALL` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: USDC,\n *   toToken: A_ETH_USDC,\n *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand\n *   signer: OWNER,\n * });\n * ```\n */\nexport const all = (simAmount: bigint | string): RouteAmountAll => ({\n  type: 'ALL',\n  simAmount,\n});\n"],"mappings":"AA2BO,MAAM,QAAQ,CAAC,YAA+C;AAAA,EACnE,MAAM;AAAA,EACN;AACF;AA2BO,MAAM,MAAM,CAAC,eAAgD;AAAA,EAClE,MAAM;AAAA,EACN;AACF;","names":[]}

package/dist/run/inputs.cjs

@@ -26,25 +26,24 @@ const materialiser = (kind, config = {}) => ({
   kind,
   ...config
 });
+const pickDefined = (obj) => Object.fromEntries(
+  Object.entries(obj).filter(([, value]) => value !== void 0)
+);
 const buildRun = (run) => ({
   inputs: run.inputs,
-  ...run.preconditions?.length && { preconditions: run.preconditions },
   signer: run.signer,
-  ...run.assumptions && { assumptions: run.assumptions },
-  ...run.referrer !== void 0 && { referrer: run.referrer },
-  ...run.integratorFeeBps !== void 0 && {
-    integratorFeeBps: run.integratorFeeBps
-  },
-  ...run.maxPriceImpactBps !== void 0 && {
-    maxPriceImpactBps: run.maxPriceImpactBps
-  },
-  ...run.sweepTo !== void 0 && { sweepTo: run.sweepTo },
-  ...run.simulationPolicy !== void 0 && {
-    simulationPolicy: run.simulationPolicy
-  },
-  ...run.checkOnChainAllowances !== void 0 && {
+  ...pickDefined({
+    // An empty precondition list is the same as none, so drop it too.
+    preconditions: run.preconditions?.length ? run.preconditions : void 0,
+    assumptions: run.assumptions,
+    referrer: run.referrer,
+    integratorFeeBps: run.integratorFeeBps,
+    maxPriceImpactBps: run.maxPriceImpactBps,
+    sweepTo: run.sweepTo,
+    simulationPolicy: run.simulationPolicy,
+    simulateUserProgram: run.simulateUserProgram,
     checkOnChainAllowances: run.checkOnChainAllowances
-  }
+  })
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/run/inputs.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  ...(run.preconditions?.length && { preconditions: run.preconditions }),\n  signer: run.signer,\n  ...(run.assumptions && { assumptions: run.assumptions }),\n  ...(run.referrer !== undefined && { referrer: run.referrer }),\n  ...(run.integratorFeeBps !== undefined && {\n    integratorFeeBps: run.integratorFeeBps,\n  }),\n  ...(run.maxPriceImpactBps !== undefined && {\n    maxPriceImpactBps: run.maxPriceImpactBps,\n  }),\n  ...(run.sweepTo !== undefined && { sweepTo: run.sweepTo }),\n  ...(run.simulationPolicy !== undefined && {\n    simulationPolicy: run.simulationPolicy,\n  }),\n  ...(run.checkOnChainAllowances !== undefined && {\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmFO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAQO,MAAM,WAAW,CAAC,SAWN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,GAAI,IAAI,eAAe,UAAU,EAAE,eAAe,IAAI,cAAc;AAAA,EACpE,QAAQ,IAAI;AAAA,EACZ,GAAI,IAAI,eAAe,EAAE,aAAa,IAAI,YAAY;AAAA,EACtD,GAAI,IAAI,aAAa,UAAa,EAAE,UAAU,IAAI,SAAS;AAAA,EAC3D,GAAI,IAAI,qBAAqB,UAAa;AAAA,IACxC,kBAAkB,IAAI;AAAA,EACxB;AAAA,EACA,GAAI,IAAI,sBAAsB,UAAa;AAAA,IACzC,mBAAmB,IAAI;AAAA,EACzB;AAAA,EACA,GAAI,IAAI,YAAY,UAAa,EAAE,SAAS,IAAI,QAAQ;AAAA,EACxD,GAAI,IAAI,qBAAqB,UAAa;AAAA,IACxC,kBAAkB,IAAI;AAAA,EACxB;AAAA,EACA,GAAI,IAAI,2BAA2B,UAAa;AAAA,IAC9C,wBAAwB,IAAI;AAAA,EAC9B;AACF;","names":[]}
+{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    integratorFeeBps: run.integratorFeeBps,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0FO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAUA,MAAM,cAAc,CAClB,QAEA,OAAO;AAAA,EACL,OAAO,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,MAAM,UAAU,MAAS;AAC/D;AAQK,MAAM,WAAW,CAAC,SAYN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,QAAQ,IAAI;AAAA,EACZ,GAAG,YAAY;AAAA;AAAA,IAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB;AAAA,IAC/D,aAAa,IAAI;AAAA,IACjB,UAAU,IAAI;AAAA,IACd,kBAAkB,IAAI;AAAA,IACtB,mBAAmB,IAAI;AAAA,IACvB,SAAS,IAAI;AAAA,IACb,kBAAkB,IAAI;AAAA,IACtB,qBAAqB,IAAI;AAAA,IACzB,wBAAwB,IAAI;AAAA,EAC9B,CAAC;AACH;","names":[]}

package/dist/run/inputs.d.cts

@@ -50,6 +50,13 @@ interface ComposeRunInput<T extends InputSchema = InputSchema> {
      * result with the transaction and revert diagnostics.
      */
     readonly simulationPolicy?: SimulationPolicy;
+    /**
+     * When `true`, the server also simulates the final user-facing transaction
+     * after the structured simulation succeeds; reverts honour
+     * `simulationPolicy`. On success the result is echoed back on the response as
+     * `userProgramSimulation`. Defaults to `false`.
+     */
+    readonly simulateUserProgram?: boolean;
     /**
      * When `true`, the server checks on-chain ERC-20 allowances and omits
      * approvals that are already sufficient. Defaults to `false`.
@@ -93,6 +100,7 @@ declare const buildRun: (run: {
     maxPriceImpactBps?: number;
     sweepTo?: SweepTo;
     simulationPolicy?: SimulationPolicy;
+    simulateUserProgram?: boolean;
     checkOnChainAllowances?: boolean;
 }) => ComposeRun;
 

package/dist/run/inputs.d.ts

@@ -50,6 +50,13 @@ interface ComposeRunInput<T extends InputSchema = InputSchema> {
      * result with the transaction and revert diagnostics.
      */
     readonly simulationPolicy?: SimulationPolicy;
+    /**
+     * When `true`, the server also simulates the final user-facing transaction
+     * after the structured simulation succeeds; reverts honour
+     * `simulationPolicy`. On success the result is echoed back on the response as
+     * `userProgramSimulation`. Defaults to `false`.
+     */
+    readonly simulateUserProgram?: boolean;
     /**
      * When `true`, the server checks on-chain ERC-20 allowances and omits
      * approvals that are already sufficient. Defaults to `false`.
@@ -93,6 +100,7 @@ declare const buildRun: (run: {
     maxPriceImpactBps?: number;
     sweepTo?: SweepTo;
     simulationPolicy?: SimulationPolicy;
+    simulateUserProgram?: boolean;
     checkOnChainAllowances?: boolean;
 }) => ComposeRun;
 

package/dist/run/inputs.js

@@ -2,25 +2,24 @@ const materialiser = (kind, config = {}) => ({
   kind,
   ...config
 });
+const pickDefined = (obj) => Object.fromEntries(
+  Object.entries(obj).filter(([, value]) => value !== void 0)
+);
 const buildRun = (run) => ({
   inputs: run.inputs,
-  ...run.preconditions?.length && { preconditions: run.preconditions },
   signer: run.signer,
-  ...run.assumptions && { assumptions: run.assumptions },
-  ...run.referrer !== void 0 && { referrer: run.referrer },
-  ...run.integratorFeeBps !== void 0 && {
-    integratorFeeBps: run.integratorFeeBps
-  },
-  ...run.maxPriceImpactBps !== void 0 && {
-    maxPriceImpactBps: run.maxPriceImpactBps
-  },
-  ...run.sweepTo !== void 0 && { sweepTo: run.sweepTo },
-  ...run.simulationPolicy !== void 0 && {
-    simulationPolicy: run.simulationPolicy
-  },
-  ...run.checkOnChainAllowances !== void 0 && {
+  ...pickDefined({
+    // An empty precondition list is the same as none, so drop it too.
+    preconditions: run.preconditions?.length ? run.preconditions : void 0,
+    assumptions: run.assumptions,
+    referrer: run.referrer,
+    integratorFeeBps: run.integratorFeeBps,
+    maxPriceImpactBps: run.maxPriceImpactBps,
+    sweepTo: run.sweepTo,
+    simulationPolicy: run.simulationPolicy,
+    simulateUserProgram: run.simulateUserProgram,
     checkOnChainAllowances: run.checkOnChainAllowances
-  }
+  })
 });
 export {
   buildRun,

package/dist/run/inputs.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  ...(run.preconditions?.length && { preconditions: run.preconditions }),\n  signer: run.signer,\n  ...(run.assumptions && { assumptions: run.assumptions }),\n  ...(run.referrer !== undefined && { referrer: run.referrer }),\n  ...(run.integratorFeeBps !== undefined && {\n    integratorFeeBps: run.integratorFeeBps,\n  }),\n  ...(run.maxPriceImpactBps !== undefined && {\n    maxPriceImpactBps: run.maxPriceImpactBps,\n  }),\n  ...(run.sweepTo !== undefined && { sweepTo: run.sweepTo }),\n  ...(run.simulationPolicy !== undefined && {\n    simulationPolicy: run.simulationPolicy,\n  }),\n  ...(run.checkOnChainAllowances !== undefined && {\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":"AAmFO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAQO,MAAM,WAAW,CAAC,SAWN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,GAAI,IAAI,eAAe,UAAU,EAAE,eAAe,IAAI,cAAc;AAAA,EACpE,QAAQ,IAAI;AAAA,EACZ,GAAI,IAAI,eAAe,EAAE,aAAa,IAAI,YAAY;AAAA,EACtD,GAAI,IAAI,aAAa,UAAa,EAAE,UAAU,IAAI,SAAS;AAAA,EAC3D,GAAI,IAAI,qBAAqB,UAAa;AAAA,IACxC,kBAAkB,IAAI;AAAA,EACxB;AAAA,EACA,GAAI,IAAI,sBAAsB,UAAa;AAAA,IACzC,mBAAmB,IAAI;AAAA,EACzB;AAAA,EACA,GAAI,IAAI,YAAY,UAAa,EAAE,SAAS,IAAI,QAAQ;AAAA,EACxD,GAAI,IAAI,qBAAqB,UAAa;AAAA,IACxC,kBAAkB,IAAI;AAAA,EACxB;AAAA,EACA,GAAI,IAAI,2BAA2B,UAAa;AAAA,IAC9C,wBAAwB,IAAI;AAAA,EAC9B;AACF;","names":[]}
+{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    integratorFeeBps: run.integratorFeeBps,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":"AA0FO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAUA,MAAM,cAAc,CAClB,QAEA,OAAO;AAAA,EACL,OAAO,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,MAAM,UAAU,MAAS;AAC/D;AAQK,MAAM,WAAW,CAAC,SAYN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,QAAQ,IAAI;AAAA,EACZ,GAAG,YAAY;AAAA;AAAA,IAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB;AAAA,IAC/D,aAAa,IAAI;AAAA,IACjB,UAAU,IAAI;AAAA,IACd,kBAAkB,IAAI;AAAA,IACtB,mBAAmB,IAAI;AAAA,IACvB,SAAS,IAAI;AAAA,IACb,kBAAkB,IAAI;AAAA,IACtB,qBAAqB,IAAI;AAAA,IACzB,wBAAwB,IAAI;AAAA,EAC9B,CAAC;AACH;","names":[]}

package/dist/run/simulate.cjs

@@ -23,6 +23,11 @@ __export(simulate_exports, {
 module.exports = __toCommonJS(simulate_exports);
 const buildSimulateRequest = (input) => {
   const { result, chainId, signer, trackedBalances, requirements, block } = input;
+  if (result.transactionRequest === void 0) {
+    throw new Error(
+      "buildSimulateRequest: the compile result has no transactionRequest (empty compiled program \u2014 a settle-only external-funding flow); submit the `actions` entries instead of simulating"
+    );
+  }
   return {
     chainId,
     from: signer,