@lifi/composer-sdk 0.0.1-alpha

package/dist/materialisers.generated-nMxTAaVi.d.cts

@@ -0,0 +1,24 @@
+import { MaterialiserConfigOf, MaterialiserInput } from '@lifi/compose-spec';
+import { BalanceOfMaterialiserConfig, CallMaterialiserConfig, DirectDepositMaterialiserConfig } from './generated/config.generated.cjs';
+
+type BalanceOfMaterialiserInput = MaterialiserConfigOf<BalanceOfMaterialiserConfig>;
+/** Read the on-chain token balance of an address as the input amount — accepts: resource */
+declare const balanceOf: (config: BalanceOfMaterialiserInput) => MaterialiserInput;
+type DirectDepositMaterialiserInput = MaterialiserConfigOf<DirectDepositMaterialiserConfig>;
+/** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */
+declare const directDeposit: (config: DirectDepositMaterialiserInput) => MaterialiserInput;
+type CallMaterialiserInput = MaterialiserConfigOf<CallMaterialiserConfig>;
+/** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */
+declare const call: (config: CallMaterialiserInput) => MaterialiserInput;
+
+type materialisersMod_BalanceOfMaterialiserInput = BalanceOfMaterialiserInput;
+type materialisersMod_CallMaterialiserInput = CallMaterialiserInput;
+type materialisersMod_DirectDepositMaterialiserInput = DirectDepositMaterialiserInput;
+declare const materialisersMod_balanceOf: typeof balanceOf;
+declare const materialisersMod_call: typeof call;
+declare const materialisersMod_directDeposit: typeof directDeposit;
+declare namespace materialisersMod {
+  export { type materialisersMod_BalanceOfMaterialiserInput as BalanceOfMaterialiserInput, type materialisersMod_CallMaterialiserInput as CallMaterialiserInput, type materialisersMod_DirectDepositMaterialiserInput as DirectDepositMaterialiserInput, materialisersMod_balanceOf as balanceOf, materialisersMod_call as call, materialisersMod_directDeposit as directDeposit };
+}
+
+export { type BalanceOfMaterialiserInput as B, type CallMaterialiserInput as C, type DirectDepositMaterialiserInput as D, balanceOf as b, call as c, directDeposit as d, materialisersMod as m };

package/dist/preconditions.generated-DblS13Wq.d.cts

@@ -0,0 +1,24 @@
+import { PreconditionConfigOf, Precondition } from '@lifi/compose-spec';
+import { Erc20AllowancePreconditionConfig, Erc20BalancePreconditionConfig, NativeBalancePreconditionConfig } from './generated/config.generated.cjs';
+
+type Erc20BalancePreconditionInput = PreconditionConfigOf<Erc20BalancePreconditionConfig>;
+/** Assert that a wallet holds at least a given ERC-20 token balance */
+declare const erc20Balance: (config: Erc20BalancePreconditionInput) => Precondition;
+type NativeBalancePreconditionInput = PreconditionConfigOf<NativeBalancePreconditionConfig>;
+/** Assert that a wallet holds at least a given native coin balance */
+declare const nativeBalance: (config: NativeBalancePreconditionInput) => Precondition;
+type Erc20AllowancePreconditionInput = PreconditionConfigOf<Erc20AllowancePreconditionConfig>;
+/** Assert that an ERC-20 allowance is at least a given amount */
+declare const erc20Allowance: (config: Erc20AllowancePreconditionInput) => Precondition;
+
+type preconditionsMod_Erc20AllowancePreconditionInput = Erc20AllowancePreconditionInput;
+type preconditionsMod_Erc20BalancePreconditionInput = Erc20BalancePreconditionInput;
+type preconditionsMod_NativeBalancePreconditionInput = NativeBalancePreconditionInput;
+declare const preconditionsMod_erc20Allowance: typeof erc20Allowance;
+declare const preconditionsMod_erc20Balance: typeof erc20Balance;
+declare const preconditionsMod_nativeBalance: typeof nativeBalance;
+declare namespace preconditionsMod {
+  export { type preconditionsMod_Erc20AllowancePreconditionInput as Erc20AllowancePreconditionInput, type preconditionsMod_Erc20BalancePreconditionInput as Erc20BalancePreconditionInput, type preconditionsMod_NativeBalancePreconditionInput as NativeBalancePreconditionInput, preconditionsMod_erc20Allowance as erc20Allowance, preconditionsMod_erc20Balance as erc20Balance, preconditionsMod_nativeBalance as nativeBalance };
+}
+
+export { type Erc20AllowancePreconditionInput as E, type NativeBalancePreconditionInput as N, type Erc20BalancePreconditionInput as a, erc20Balance as b, erc20Allowance as e, nativeBalance as n, preconditionsMod as p };

package/dist/preconditions.generated-U7YpVh30.d.ts

@@ -0,0 +1,24 @@
+import { PreconditionConfigOf, Precondition } from '@lifi/compose-spec';
+import { Erc20AllowancePreconditionConfig, Erc20BalancePreconditionConfig, NativeBalancePreconditionConfig } from './generated/config.generated.js';
+
+type Erc20BalancePreconditionInput = PreconditionConfigOf<Erc20BalancePreconditionConfig>;
+/** Assert that a wallet holds at least a given ERC-20 token balance */
+declare const erc20Balance: (config: Erc20BalancePreconditionInput) => Precondition;
+type NativeBalancePreconditionInput = PreconditionConfigOf<NativeBalancePreconditionConfig>;
+/** Assert that a wallet holds at least a given native coin balance */
+declare const nativeBalance: (config: NativeBalancePreconditionInput) => Precondition;
+type Erc20AllowancePreconditionInput = PreconditionConfigOf<Erc20AllowancePreconditionConfig>;
+/** Assert that an ERC-20 allowance is at least a given amount */
+declare const erc20Allowance: (config: Erc20AllowancePreconditionInput) => Precondition;
+
+type preconditionsMod_Erc20AllowancePreconditionInput = Erc20AllowancePreconditionInput;
+type preconditionsMod_Erc20BalancePreconditionInput = Erc20BalancePreconditionInput;
+type preconditionsMod_NativeBalancePreconditionInput = NativeBalancePreconditionInput;
+declare const preconditionsMod_erc20Allowance: typeof erc20Allowance;
+declare const preconditionsMod_erc20Balance: typeof erc20Balance;
+declare const preconditionsMod_nativeBalance: typeof nativeBalance;
+declare namespace preconditionsMod {
+  export { type preconditionsMod_Erc20AllowancePreconditionInput as Erc20AllowancePreconditionInput, type preconditionsMod_Erc20BalancePreconditionInput as Erc20BalancePreconditionInput, type preconditionsMod_NativeBalancePreconditionInput as NativeBalancePreconditionInput, preconditionsMod_erc20Allowance as erc20Allowance, preconditionsMod_erc20Balance as erc20Balance, preconditionsMod_nativeBalance as nativeBalance };
+}
+
+export { type Erc20AllowancePreconditionInput as E, type NativeBalancePreconditionInput as N, type Erc20BalancePreconditionInput as a, erc20Balance as b, erc20Allowance as e, nativeBalance as n, preconditionsMod as p };

package/dist/raw-Dj_2rBSQ.d.cts

@@ -0,0 +1,19 @@
+import { rawGuard, ref } from './authoring/raw.cjs';
+import { materialiser } from './run/inputs.cjs';
+
+/**
+ * Low-level escape hatch for constructing flow nodes and guards without the
+ * typed builder API. Use these when working with operation kinds not covered
+ * by the generated methods, or when you need full control over the JSON shape.
+ *
+ * For most use cases, prefer the generated operation methods on {@link FlowBuilder}
+ * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.
+ */
+
+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 { rawMod as r };

package/dist/raw-IxCF_bSS.d.ts

@@ -0,0 +1,19 @@
+import { rawGuard, ref } from './authoring/raw.js';
+import { materialiser } from './run/inputs.js';
+
+/**
+ * Low-level escape hatch for constructing flow nodes and guards without the
+ * typed builder API. Use these when working with operation kinds not covered
+ * by the generated methods, or when you need full control over the JSON shape.
+ *
+ * For most use cases, prefer the generated operation methods on {@link FlowBuilder}
+ * (e.g. `builder.lifi.swap(...)`) and the typed guard/materialiser helpers.
+ */
+
+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 { rawMod as r };

package/dist/raw.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[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 raw_exports = {};
+__export(raw_exports, {
+  guard: () => import_raw.rawGuard,
+  materialiser: () => import_inputs.materialiser,
+  ref: () => import_raw.ref
+});
+module.exports = __toCommonJS(raw_exports);
+var import_raw = require("./authoring/raw.js");
+var import_inputs = require("./run/inputs.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  guard,
+  materialiser,
+  ref
+});
+//# sourceMappingURL=raw.cjs.map

package/dist/raw.cjs.map

@@ -0,0 +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":[]}

package/dist/raw.d.cts

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

package/dist/raw.d.ts

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

package/dist/raw.js

@@ -0,0 +1,8 @@
+import { rawGuard, ref } from "./authoring/raw.js";
+import { materialiser } from "./run/inputs.js";
+export {
+  rawGuard as guard,
+  materialiser,
+  ref
+};
+//# sourceMappingURL=raw.js.map

package/dist/raw.js.map

@@ -0,0 +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":[]}

package/dist/resources-BKlFxjo8.d.cts

@@ -0,0 +1,56 @@
+import { Address } from './types.cjs';
+
+/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */
+interface NativeResource {
+    readonly kind: 'native';
+    readonly chainId: number;
+}
+/** A resource declaration representing an ERC-20 token at a specific address. */
+interface Erc20Resource {
+    readonly kind: 'erc20';
+    readonly token: Address;
+    readonly chainId: number;
+}
+/** A token resource — either the chain's native token or an ERC-20. */
+type Resource = NativeResource | Erc20Resource;
+/**
+ * Creates a native token resource declaration.
+ *
+ * @param chainId - The EVM chain ID the native token belongs to.
+ * @returns A {@link NativeResource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const builder = sdk.flow(1, {
+ *   inputs: { eth: native(1) },
+ * });
+ * ```
+ */
+declare const native: (chainId: number) => NativeResource;
+/**
+ * Creates an ERC-20 token resource declaration.
+ *
+ * @param token - The `0x`-prefixed contract address of the ERC-20 token.
+ * @param chainId - The EVM chain ID the token is deployed on.
+ * @returns An {@link Erc20Resource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+ * const builder = sdk.flow(1, {
+ *   inputs: { usdc: erc20(USDC, 1) },
+ * });
+ * ```
+ */
+declare const erc20: (token: Address, chainId: number) => Erc20Resource;
+
+type resourcesMod_Erc20Resource = Erc20Resource;
+type resourcesMod_NativeResource = NativeResource;
+type resourcesMod_Resource = Resource;
+declare const resourcesMod_erc20: typeof erc20;
+declare const resourcesMod_native: typeof native;
+declare namespace resourcesMod {
+  export { type resourcesMod_Erc20Resource as Erc20Resource, type resourcesMod_NativeResource as NativeResource, type resourcesMod_Resource as Resource, resourcesMod_erc20 as erc20, resourcesMod_native as native };
+}
+
+export { type Erc20Resource as E, type NativeResource as N, type Resource as R, erc20 as e, native as n, resourcesMod as r };

package/dist/resources-CYis1_DS.d.ts

@@ -0,0 +1,56 @@
+import { Address } from './types.js';
+
+/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */
+interface NativeResource {
+    readonly kind: 'native';
+    readonly chainId: number;
+}
+/** A resource declaration representing an ERC-20 token at a specific address. */
+interface Erc20Resource {
+    readonly kind: 'erc20';
+    readonly token: Address;
+    readonly chainId: number;
+}
+/** A token resource — either the chain's native token or an ERC-20. */
+type Resource = NativeResource | Erc20Resource;
+/**
+ * Creates a native token resource declaration.
+ *
+ * @param chainId - The EVM chain ID the native token belongs to.
+ * @returns A {@link NativeResource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const builder = sdk.flow(1, {
+ *   inputs: { eth: native(1) },
+ * });
+ * ```
+ */
+declare const native: (chainId: number) => NativeResource;
+/**
+ * Creates an ERC-20 token resource declaration.
+ *
+ * @param token - The `0x`-prefixed contract address of the ERC-20 token.
+ * @param chainId - The EVM chain ID the token is deployed on.
+ * @returns An {@link Erc20Resource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+ * const builder = sdk.flow(1, {
+ *   inputs: { usdc: erc20(USDC, 1) },
+ * });
+ * ```
+ */
+declare const erc20: (token: Address, chainId: number) => Erc20Resource;
+
+type resourcesMod_Erc20Resource = Erc20Resource;
+type resourcesMod_NativeResource = NativeResource;
+type resourcesMod_Resource = Resource;
+declare const resourcesMod_erc20: typeof erc20;
+declare const resourcesMod_native: typeof native;
+declare namespace resourcesMod {
+  export { type resourcesMod_Erc20Resource as Erc20Resource, type resourcesMod_NativeResource as NativeResource, type resourcesMod_Resource as Resource, resourcesMod_erc20 as erc20, resourcesMod_native as native };
+}
+
+export { type Erc20Resource as E, type NativeResource as N, type Resource as R, erc20 as e, native as n, resourcesMod as r };

package/dist/resources.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[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 resources_exports = {};
+__export(resources_exports, {
+  erc20: () => erc20,
+  native: () => native
+});
+module.exports = __toCommonJS(resources_exports);
+const native = (chainId) => ({
+  kind: "native",
+  chainId
+});
+const erc20 = (token, chainId) => ({
+  kind: "erc20",
+  token,
+  chainId
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  erc20,
+  native
+});
+//# sourceMappingURL=resources.cjs.map

package/dist/resources.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources.ts"],"sourcesContent":["import type { Address } from './types.js';\n\n// These resource types are SDK-local declarations that mirror the shape of\n// `Resource` from `@lifi/compose-spec`. They exist so the SDK can be used\n// without directly depending on `@lifi/compose-spec` at the call site.\n// The types are structurally compatible, so they are assignable to each other.\n\n/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */\nexport interface NativeResource {\n  readonly kind: 'native';\n  readonly chainId: number;\n}\n\n/** A resource declaration representing an ERC-20 token at a specific address. */\nexport interface Erc20Resource {\n  readonly kind: 'erc20';\n  readonly token: Address;\n  readonly chainId: number;\n}\n\n/** A token resource — either the chain's native token or an ERC-20. */\nexport type Resource = NativeResource | Erc20Resource;\n\n/**\n * Creates a native token resource declaration.\n *\n * @param chainId - The EVM chain ID the native token belongs to.\n * @returns A {@link NativeResource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: { eth: native(1) },\n * });\n * ```\n */\nexport const native = (chainId: number): NativeResource => ({\n  kind: 'native',\n  chainId,\n});\n\n/**\n * Creates an ERC-20 token resource declaration.\n *\n * @param token - The `0x`-prefixed contract address of the ERC-20 token.\n * @param chainId - The EVM chain ID the token is deployed on.\n * @returns An {@link Erc20Resource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: erc20(USDC, 1) },\n * });\n * ```\n */\nexport const erc20 = (token: Address, chainId: number): Erc20Resource => ({\n  kind: 'erc20',\n  token,\n  chainId,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoCO,MAAM,SAAS,CAAC,aAAqC;AAAA,EAC1D,MAAM;AAAA,EACN;AACF;AAiBO,MAAM,QAAQ,CAAC,OAAgB,aAAoC;AAAA,EACxE,MAAM;AAAA,EACN;AAAA,EACA;AACF;","names":[]}

package/dist/resources.d.cts

@@ -0,0 +1,3 @@
+import './types.cjs';
+export { E as Erc20Resource, N as NativeResource, R as Resource, e as erc20, n as native } from './resources-BKlFxjo8.cjs';
+import '@lifi/compose-spec';

package/dist/resources.d.ts

@@ -0,0 +1,3 @@
+import './types.js';
+export { E as Erc20Resource, N as NativeResource, R as Resource, e as erc20, n as native } from './resources-CYis1_DS.js';
+import '@lifi/compose-spec';

package/dist/resources.js

@@ -0,0 +1,14 @@
+const native = (chainId) => ({
+  kind: "native",
+  chainId
+});
+const erc20 = (token, chainId) => ({
+  kind: "erc20",
+  token,
+  chainId
+});
+export {
+  erc20,
+  native
+};
+//# sourceMappingURL=resources.js.map

package/dist/resources.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources.ts"],"sourcesContent":["import type { Address } from './types.js';\n\n// These resource types are SDK-local declarations that mirror the shape of\n// `Resource` from `@lifi/compose-spec`. They exist so the SDK can be used\n// without directly depending on `@lifi/compose-spec` at the call site.\n// The types are structurally compatible, so they are assignable to each other.\n\n/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */\nexport interface NativeResource {\n  readonly kind: 'native';\n  readonly chainId: number;\n}\n\n/** A resource declaration representing an ERC-20 token at a specific address. */\nexport interface Erc20Resource {\n  readonly kind: 'erc20';\n  readonly token: Address;\n  readonly chainId: number;\n}\n\n/** A token resource — either the chain's native token or an ERC-20. */\nexport type Resource = NativeResource | Erc20Resource;\n\n/**\n * Creates a native token resource declaration.\n *\n * @param chainId - The EVM chain ID the native token belongs to.\n * @returns A {@link NativeResource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: { eth: native(1) },\n * });\n * ```\n */\nexport const native = (chainId: number): NativeResource => ({\n  kind: 'native',\n  chainId,\n});\n\n/**\n * Creates an ERC-20 token resource declaration.\n *\n * @param token - The `0x`-prefixed contract address of the ERC-20 token.\n * @param chainId - The EVM chain ID the token is deployed on.\n * @returns An {@link Erc20Resource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: erc20(USDC, 1) },\n * });\n * ```\n */\nexport const erc20 = (token: Address, chainId: number): Erc20Resource => ({\n  kind: 'erc20',\n  token,\n  chainId,\n});\n"],"mappings":"AAoCO,MAAM,SAAS,CAAC,aAAqC;AAAA,EAC1D,MAAM;AAAA,EACN;AACF;AAiBO,MAAM,QAAQ,CAAC,OAAgB,aAAoC;AAAA,EACxE,MAAM;AAAA,EACN;AAAA,EACA;AACF;","names":[]}

package/dist/run/inputs.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[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 inputs_exports = {};
+__export(inputs_exports, {
+  buildRun: () => buildRun,
+  materialiser: () => materialiser
+});
+module.exports = __toCommonJS(inputs_exports);
+const materialiser = (kind, config = {}) => ({
+  kind,
+  ...config
+});
+const buildRun = (run) => ({
+  inputs: run.inputs,
+  ...run.preconditions?.length && { preconditions: run.preconditions },
+  signer: run.signer,
+  ...run.assumptions && { assumptions: run.assumptions },
+  ...run.referrer != null && { referrer: run.referrer },
+  ...run.maxPriceImpactBps != null && {
+    maxPriceImpactBps: run.maxPriceImpactBps
+  },
+  ...run.sweepTo != null && { sweepTo: run.sweepTo },
+  ...run.simulationPolicy != null && {
+    simulationPolicy: run.simulationPolicy
+  },
+  ...run.checkOnChainAllowances != null && {
+    checkOnChainAllowances: run.checkOnChainAllowances
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRun,
+  materialiser
+});
+//# sourceMappingURL=inputs.cjs.map

package/dist/run/inputs.cjs.map

@@ -0,0 +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  /** 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  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 != null && { referrer: run.referrer }),\n  ...(run.maxPriceImpactBps != null && {\n    maxPriceImpactBps: run.maxPriceImpactBps,\n  }),\n  ...(run.sweepTo != null && { sweepTo: run.sweepTo }),\n  ...(run.simulationPolicy != null && {\n    simulationPolicy: run.simulationPolicy,\n  }),\n  ...(run.checkOnChainAllowances != null && {\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4EO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAQO,MAAM,WAAW,CAAC,SAUN;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,YAAY,QAAQ,EAAE,UAAU,IAAI,SAAS;AAAA,EACrD,GAAI,IAAI,qBAAqB,QAAQ;AAAA,IACnC,mBAAmB,IAAI;AAAA,EACzB;AAAA,EACA,GAAI,IAAI,WAAW,QAAQ,EAAE,SAAS,IAAI,QAAQ;AAAA,EAClD,GAAI,IAAI,oBAAoB,QAAQ;AAAA,IAClC,kBAAkB,IAAI;AAAA,EACxB;AAAA,EACA,GAAI,IAAI,0BAA0B,QAAQ;AAAA,IACxC,wBAAwB,IAAI;AAAA,EAC9B;AACF;","names":[]}

package/dist/run/inputs.d.cts

@@ -0,0 +1,91 @@
+import { Precondition, SweepTo, SimulationPolicy, MaterialiserInput, InputSpec, ComposeRun } from '@lifi/compose-spec';
+import { InputSchema, InputSpecOf, Address } from '../types.cjs';
+
+/**
+ * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.
+ *
+ * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.
+ */
+interface ComposeRunInput<T extends InputSchema = InputSchema> {
+    /**
+     * Concrete values for each declared flow input. Resource inputs accept a
+     * materialiser or a literal integer amount; scalar inputs accept the matching type.
+     */
+    readonly inputs: {
+        readonly [K in keyof T]: InputSpecOf<T[K]>;
+    };
+    /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */
+    readonly preconditions?: readonly Precondition[];
+    /** The `0x`-prefixed address of the transaction signer. */
+    readonly signer: Address;
+    /**
+     * Optional assumed token amounts for resource inputs, keyed by input name.
+     * When a materialiser resolves amounts at execution time rather than upfront,
+     * assumptions let the compiler plan routes using estimated values. The keys
+     * must match the input names declared in the flow schema.
+     */
+    readonly assumptions?: {
+        readonly [K in keyof T]?: bigint;
+    };
+    /** Optional integrator referrer identifier. */
+    readonly referrer?: string;
+    /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
+    readonly maxPriceImpactBps?: number;
+    /**
+     * Destination for sweeping all proxy-held terminal resources after execution.
+     * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
+     * send remaining tokens to the signer.
+     */
+    readonly sweepTo?: SweepTo;
+    /**
+     * Controls behavior when simulation detects a revert.
+     * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
+     * result with the transaction and revert diagnostics.
+     */
+    readonly simulationPolicy?: SimulationPolicy;
+    /**
+     * When `true`, the server checks on-chain ERC-20 allowances and omits
+     * approvals that are already sufficient. Defaults to `false`.
+     */
+    readonly checkOnChainAllowances?: boolean;
+}
+/**
+ * Creates an untyped materialiser input spec. This is a low-level escape hatch
+ * for materialiser kinds not yet covered by the generated helpers.
+ *
+ * Prefer the typed helpers in the `materialisers` namespace (e.g.
+ * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide
+ * compile-time config validation.
+ *
+ * @param kind - The materialiser type (e.g. `"balanceOf"`, `"directDeposit"`).
+ * @param config - Optional materialiser-specific configuration.
+ * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.
+ *
+ * @example
+ * ```ts
+ * const run = {
+ *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },
+ *   signer: '0x...',
+ * };
+ * ```
+ */
+declare const materialiser: (kind: string, config?: Record<string, unknown>) => MaterialiserInput;
+/**
+ * Assembles a {@link ComposeRun} object from individual parameters.
+ * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.
+ *
+ * @internal
+ */
+declare const buildRun: (run: {
+    inputs: Record<string, InputSpec>;
+    preconditions?: readonly Precondition[];
+    signer: string;
+    assumptions?: Record<string, bigint>;
+    referrer?: string;
+    maxPriceImpactBps?: number;
+    sweepTo?: SweepTo;
+    simulationPolicy?: SimulationPolicy;
+    checkOnChainAllowances?: boolean;
+}) => ComposeRun;
+
+export { type ComposeRunInput, buildRun, materialiser };

package/dist/run/inputs.d.ts

@@ -0,0 +1,91 @@
+import { Precondition, SweepTo, SimulationPolicy, MaterialiserInput, InputSpec, ComposeRun } from '@lifi/compose-spec';
+import { InputSchema, InputSpecOf, Address } from '../types.js';
+
+/**
+ * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.
+ *
+ * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.
+ */
+interface ComposeRunInput<T extends InputSchema = InputSchema> {
+    /**
+     * Concrete values for each declared flow input. Resource inputs accept a
+     * materialiser or a literal integer amount; scalar inputs accept the matching type.
+     */
+    readonly inputs: {
+        readonly [K in keyof T]: InputSpecOf<T[K]>;
+    };
+    /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */
+    readonly preconditions?: readonly Precondition[];
+    /** The `0x`-prefixed address of the transaction signer. */
+    readonly signer: Address;
+    /**
+     * Optional assumed token amounts for resource inputs, keyed by input name.
+     * When a materialiser resolves amounts at execution time rather than upfront,
+     * assumptions let the compiler plan routes using estimated values. The keys
+     * must match the input names declared in the flow schema.
+     */
+    readonly assumptions?: {
+        readonly [K in keyof T]?: bigint;
+    };
+    /** Optional integrator referrer identifier. */
+    readonly referrer?: string;
+    /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
+    readonly maxPriceImpactBps?: number;
+    /**
+     * Destination for sweeping all proxy-held terminal resources after execution.
+     * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
+     * send remaining tokens to the signer.
+     */
+    readonly sweepTo?: SweepTo;
+    /**
+     * Controls behavior when simulation detects a revert.
+     * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
+     * result with the transaction and revert diagnostics.
+     */
+    readonly simulationPolicy?: SimulationPolicy;
+    /**
+     * When `true`, the server checks on-chain ERC-20 allowances and omits
+     * approvals that are already sufficient. Defaults to `false`.
+     */
+    readonly checkOnChainAllowances?: boolean;
+}
+/**
+ * Creates an untyped materialiser input spec. This is a low-level escape hatch
+ * for materialiser kinds not yet covered by the generated helpers.
+ *
+ * Prefer the typed helpers in the `materialisers` namespace (e.g.
+ * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide
+ * compile-time config validation.
+ *
+ * @param kind - The materialiser type (e.g. `"balanceOf"`, `"directDeposit"`).
+ * @param config - Optional materialiser-specific configuration.
+ * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.
+ *
+ * @example
+ * ```ts
+ * const run = {
+ *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },
+ *   signer: '0x...',
+ * };
+ * ```
+ */
+declare const materialiser: (kind: string, config?: Record<string, unknown>) => MaterialiserInput;
+/**
+ * Assembles a {@link ComposeRun} object from individual parameters.
+ * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.
+ *
+ * @internal
+ */
+declare const buildRun: (run: {
+    inputs: Record<string, InputSpec>;
+    preconditions?: readonly Precondition[];
+    signer: string;
+    assumptions?: Record<string, bigint>;
+    referrer?: string;
+    maxPriceImpactBps?: number;
+    sweepTo?: SweepTo;
+    simulationPolicy?: SimulationPolicy;
+    checkOnChainAllowances?: boolean;
+}) => ComposeRun;
+
+export { type ComposeRunInput, buildRun, materialiser };

package/dist/run/inputs.js

@@ -0,0 +1,26 @@
+const materialiser = (kind, config = {}) => ({
+  kind,
+  ...config
+});
+const buildRun = (run) => ({
+  inputs: run.inputs,
+  ...run.preconditions?.length && { preconditions: run.preconditions },
+  signer: run.signer,
+  ...run.assumptions && { assumptions: run.assumptions },
+  ...run.referrer != null && { referrer: run.referrer },
+  ...run.maxPriceImpactBps != null && {
+    maxPriceImpactBps: run.maxPriceImpactBps
+  },
+  ...run.sweepTo != null && { sweepTo: run.sweepTo },
+  ...run.simulationPolicy != null && {
+    simulationPolicy: run.simulationPolicy
+  },
+  ...run.checkOnChainAllowances != null && {
+    checkOnChainAllowances: run.checkOnChainAllowances
+  }
+});
+export {
+  buildRun,
+  materialiser
+};
+//# sourceMappingURL=inputs.js.map