@lifi/composer-sdk 0.0.1-alpha

package/dist/generated/operations.generated.js

@@ -0,0 +1,89 @@
+import {
+  buildCallWireFormat,
+  buildStaticCallWireFormat
+} from "../authoring/signatureArgs.js";
+const bindGeneratedOps = (builder) => ({
+  core: {
+    split: (nodeId, args) => builder.call(nodeId, "core.split", args, {
+      a: "resource",
+      b: "resource"
+    }),
+    merge: (nodeId, args) => builder.call(nodeId, "core.merge", args, { merged: "resource" }),
+    add: (nodeId, args) => builder.call(nodeId, "core.add", args, { result: "uint256" }),
+    subtract: (nodeId, args) => builder.call(nodeId, "core.subtract", args, {
+      result: "uint256"
+    }),
+    multiply: (nodeId, args) => builder.call(nodeId, "core.multiply", args, {
+      result: "uint256"
+    }),
+    divideDown: (nodeId, args) => builder.call(nodeId, "core.divideDown", args, {
+      result: "uint256"
+    }),
+    divideUp: (nodeId, args) => builder.call(nodeId, "core.divideUp", args, {
+      result: "uint256"
+    }),
+    bpsDown: (nodeId, args) => builder.call(nodeId, "core.bpsDown", args, {
+      result: "uint256"
+    }),
+    bpsUp: (nodeId, args) => builder.call(nodeId, "core.bpsUp", args, { result: "uint256" }),
+    assertEqual: (nodeId, args) => builder.call(nodeId, "core.assertEqual", args, {}),
+    assertNotEqual: (nodeId, args) => builder.call(nodeId, "core.assertNotEqual", args, {}),
+    assertGt: (nodeId, args) => builder.call(nodeId, "core.assertGt", args, {}),
+    assertGte: (nodeId, args) => builder.call(nodeId, "core.assertGte", args, {}),
+    assertLt: (nodeId, args) => builder.call(nodeId, "core.assertLt", args, {}),
+    assertLte: (nodeId, args) => builder.call(nodeId, "core.assertLte", args, {}),
+    assertInRange: (nodeId, args) => builder.call(nodeId, "core.assertInRange", args, {}),
+    approve: (nodeId, args) => builder.call(nodeId, "core.approve", args, {}),
+    balanceOf: (nodeId, args) => builder.call(nodeId, "core.balanceOf", args, {
+      balance: "resource"
+    }),
+    transfer: (nodeId, args) => builder.call(nodeId, "core.transfer", args, {
+      transferred: "resource",
+      remainder: "resource"
+    }),
+    call: (nodeId, args) => {
+      const wire = buildCallWireFormat({
+        resource: args.resource,
+        bind: args.bind,
+        config: args.config,
+        guards: args.guards
+      });
+      return builder.call(nodeId, wire.op, wire, {
+        result: "uint256"
+      });
+    },
+    staticCall: (nodeId, args) => builder.call(
+      nodeId,
+      "core.staticCall",
+      buildStaticCallWireFormat({
+        bind: args.bind,
+        config: args.config,
+        guards: args.guards
+      }),
+      { result: "uint256" }
+    ),
+    rawCall: (nodeId, args) => builder.call(nodeId, "core.rawCall", args, {
+      result: "uint256"
+    }),
+    asResource: (nodeId, args) => builder.call(nodeId, "core.asResource", args, {
+      resource: "resource"
+    }),
+    peek: (nodeId, args) => builder.call(nodeId, "core.peek", args, { result: "uint256" })
+  },
+  lifi: {
+    swap: (nodeId, args) => builder.call(nodeId, "lifi.swap", args, {
+      amountOut: "resource",
+      unspentIn: "resource"
+    }),
+    zap: (nodeId, args) => builder.call(nodeId, "lifi.zap", args, {
+      amountOut: "resource"
+    })
+  },
+  invariant: {
+    balanceAtLeast: (nodeId, args) => builder.call(nodeId, "invariant.balanceAtLeast", args, {})
+  }
+});
+export {
+  bindGeneratedOps
+};
+//# sourceMappingURL=operations.generated.js.map

package/dist/generated/operations.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/operations.generated.ts"],"sourcesContent":["// AUTO-GENERATED from manifest.json — do not edit by hand.\n// Regenerate with: yarn workspace @lifi/composer-sdk generate\n\nimport type {\n  AnyBindable,\n  FlowBuilderInternal,\n} from '../authoring/FlowBuilderCore.js';\nimport type { Bindable, OutputHandle } from '../authoring/handles.js';\nimport type {\n  CoreCallResult,\n  SignatureBind,\n  StaticCallResult,\n} from '../authoring/signatureArgs.js';\nimport {\n  buildCallWireFormat,\n  buildStaticCallWireFormat,\n} from '../authoring/signatureArgs.js';\nimport type { TypedGuard } from '../types.js';\n\nimport type {\n  CoreApproveConfig,\n  CoreAsResourceConfig,\n  CoreBalanceOfConfig,\n  CoreBpsDownConfig,\n  CoreBpsUpConfig,\n  CoreCallConfig,\n  CorePeekConfig,\n  CoreRawCallConfig,\n  CoreSplitConfig,\n  CoreStaticCallConfig,\n  CoreTransferConfig,\n  LifiSwapConfig,\n  LifiZapConfig,\n} from './config.generated.js';\n\n/** Split a resource into two outputs by basis-point ratio */\nexport interface CoreSplitArgs {\n  readonly bind: {\n    readonly source: Bindable<'resource'>;\n  };\n  readonly config: CoreSplitConfig;\n  readonly guards?: readonly TypedGuard<'a' | 'b'>[];\n}\n\n/** Merge two same-token resources into one by addition */\nexport interface CoreMergeArgs {\n  readonly bind: {\n    readonly a: Bindable<'resource'>;\n    readonly b: Bindable<'resource'>;\n  };\n  readonly guards?: readonly TypedGuard<'merged'>[];\n}\n\n/** Swap tokens via the LI.FI aggregator API */\nexport interface LifiSwapArgs {\n  readonly bind: {\n    readonly amountIn: Bindable<'resource'>;\n  };\n  readonly config: LifiSwapConfig;\n  readonly guards?: readonly TypedGuard<'unspentIn'>[];\n}\n\n/** Assert that an account holds at least a minimum token balance */\nexport interface InvariantBalanceAtLeastArgs {\n  readonly bind: {\n    readonly minimumAmount: Bindable<'resource'>;\n    readonly account: Bindable<'address'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Route tokens into a DeFi protocol position via the edge catalog */\nexport interface LifiZapArgs {\n  readonly bind: {\n    readonly amountIn: Bindable<'resource'>;\n  };\n  readonly config: LifiZapConfig;\n  readonly guards?: readonly TypedGuard<'amountOut'>[];\n}\n\n/** Add two unsigned integers (a + b) */\nexport interface CoreAddArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Subtract b from a (a - b); reverts on underflow */\nexport interface CoreSubtractArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Multiply two unsigned integers (a * b) */\nexport interface CoreMultiplyArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Divide a by b, rounding toward zero */\nexport interface CoreDivideDownArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Divide a by b, rounding away from zero */\nexport interface CoreDivideUpArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Multiply value by basis points and divide by 10000, rounding down */\nexport interface CoreBpsDownArgs {\n  readonly bind: {\n    readonly value: Bindable<'uint256'>;\n  };\n  readonly config: CoreBpsDownConfig;\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Multiply value by basis points and divide by 10000, rounding up */\nexport interface CoreBpsUpArgs {\n  readonly bind: {\n    readonly value: Bindable<'uint256'>;\n  };\n  readonly config: CoreBpsUpConfig;\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Assert a == b; reverts if not equal */\nexport interface CoreAssertEqualArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Assert a != b; reverts if equal */\nexport interface CoreAssertNotEqualArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Assert a > b; reverts if a <= b */\nexport interface CoreAssertGtArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Assert a >= b; reverts if a < b */\nexport interface CoreAssertGteArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Assert a < b; reverts if a >= b */\nexport interface CoreAssertLtArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Assert a <= b; reverts if a > b */\nexport interface CoreAssertLteArgs {\n  readonly bind: {\n    readonly a: Bindable<'uint256'>;\n    readonly b: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Assert min <= value <= max; reverts if value is outside the range */\nexport interface CoreAssertInRangeArgs {\n  readonly bind: {\n    readonly value: Bindable<'uint256'>;\n    readonly min: Bindable<'uint256'>;\n    readonly max: Bindable<'uint256'>;\n  };\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Approve an ERC20 spender for the given token and amount */\nexport interface CoreApproveArgs {\n  readonly bind: {\n    readonly amount: Bindable<'resource'>;\n  };\n  readonly config: CoreApproveConfig;\n  readonly guards?: readonly TypedGuard<never>[];\n}\n\n/** Read an ERC20 balance, producing a resource */\nexport interface CoreBalanceOfArgs {\n  readonly bind: Record<string, never>;\n  readonly config: CoreBalanceOfConfig;\n  readonly guards?: readonly TypedGuard<'balance'>[];\n}\n\n/** Transfer tokens to a recipient address, optionally specifying a partial amount */\nexport interface CoreTransferArgs {\n  readonly bind: {\n    readonly amount: Bindable<'resource'>;\n    readonly recipient: Bindable<'address'>;\n  };\n  readonly config: CoreTransferConfig;\n  readonly guards?: readonly TypedGuard<'transferred' | 'remainder'>[];\n}\n\n/** Invoke a smart contract function, optionally spending a token resource */\nexport interface CoreCallArgs<TSig extends string = string> {\n  readonly resource?: Bindable<'resource'>;\n  readonly bind: SignatureBind<TSig>;\n  readonly config: Omit<CoreCallConfig, 'args' | 'functionSignature'> & {\n    readonly functionSignature: TSig;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Read from a smart contract at runtime (StaticCall); result is fresh at execution time */\nexport interface CoreStaticCallArgs<TSig extends string = string> {\n  readonly bind: SignatureBind<TSig>;\n  readonly config: Omit<CoreStaticCallConfig, 'args' | 'functionSignature'> & {\n    readonly functionSignature: TSig;\n  };\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Invoke a contract with pre-encoded calldata */\nexport interface CoreRawCallArgs {\n  readonly bind: Record<string, never>;\n  readonly config: CoreRawCallConfig;\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Graduate a raw handle to a resource, enabling slippage surfacing and linearity tracking */\nexport interface CoreAsResourceArgs {\n  readonly bind: {\n    readonly handle: Bindable<'uint256'>;\n  };\n  readonly config: CoreAsResourceConfig;\n  readonly guards?: readonly TypedGuard<'resource'>[];\n}\n\n/** Read a smart contract value at compile time (off-chain eth_call); result is baked as a literal */\nexport interface CorePeekArgs {\n  readonly bind: Record<string, never>;\n  readonly config: CorePeekConfig;\n  readonly guards?: readonly TypedGuard<'result'>[];\n}\n\nexport interface CoreSplitOutputs {\n  readonly a: OutputHandle<'resource'>;\n  readonly b: OutputHandle<'resource'>;\n}\n\nexport interface CoreMergeOutputs {\n  readonly merged: OutputHandle<'resource'>;\n}\n\nexport interface LifiSwapOutputs {\n  readonly amountOut: OutputHandle<'resource'>;\n  readonly unspentIn: OutputHandle<'resource'>;\n}\n\nexport interface LifiZapOutputs {\n  readonly amountOut: OutputHandle<'resource'>;\n}\n\nexport interface CoreAddOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreSubtractOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreMultiplyOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreDivideDownOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreDivideUpOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreBpsDownOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreBpsUpOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreBalanceOfOutputs {\n  readonly balance: OutputHandle<'resource'>;\n}\n\nexport interface CoreTransferOutputs {\n  readonly transferred: OutputHandle<'resource'>;\n  readonly remainder: OutputHandle<'resource'>;\n}\n\nexport interface CoreRawCallOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreAsResourceOutputs {\n  readonly resource: OutputHandle<'resource'>;\n}\n\nexport interface CorePeekOutputs {\n  readonly result: OutputHandle<'uint256'>;\n}\n\nexport type GeneratedOps = {\n  readonly core: {\n    /** Split a resource into two outputs by basis-point ratio — original id: \"core.split\" */\n    readonly split: (nodeId: string, args: CoreSplitArgs) => CoreSplitOutputs;\n    /** Merge two same-token resources into one by addition — original id: \"core.merge\" */\n    readonly merge: (nodeId: string, args: CoreMergeArgs) => CoreMergeOutputs;\n    /** Add two unsigned integers (a + b) — original id: \"core.add\" */\n    readonly add: (nodeId: string, args: CoreAddArgs) => CoreAddOutputs;\n    /** Subtract b from a (a - b); reverts on underflow — original id: \"core.subtract\" */\n    readonly subtract: (\n      nodeId: string,\n      args: CoreSubtractArgs,\n    ) => CoreSubtractOutputs;\n    /** Multiply two unsigned integers (a * b) — original id: \"core.multiply\" */\n    readonly multiply: (\n      nodeId: string,\n      args: CoreMultiplyArgs,\n    ) => CoreMultiplyOutputs;\n    /** Divide a by b, rounding toward zero — original id: \"core.divideDown\" */\n    readonly divideDown: (\n      nodeId: string,\n      args: CoreDivideDownArgs,\n    ) => CoreDivideDownOutputs;\n    /** Divide a by b, rounding away from zero — original id: \"core.divideUp\" */\n    readonly divideUp: (\n      nodeId: string,\n      args: CoreDivideUpArgs,\n    ) => CoreDivideUpOutputs;\n    /** Multiply value by basis points and divide by 10000, rounding down — original id: \"core.bpsDown\" */\n    readonly bpsDown: (\n      nodeId: string,\n      args: CoreBpsDownArgs,\n    ) => CoreBpsDownOutputs;\n    /** Multiply value by basis points and divide by 10000, rounding up — original id: \"core.bpsUp\" */\n    readonly bpsUp: (nodeId: string, args: CoreBpsUpArgs) => CoreBpsUpOutputs;\n    /** Assert a == b; reverts if not equal — original id: \"core.assertEqual\" */\n    readonly assertEqual: (nodeId: string, args: CoreAssertEqualArgs) => void;\n    /** Assert a != b; reverts if equal — original id: \"core.assertNotEqual\" */\n    readonly assertNotEqual: (\n      nodeId: string,\n      args: CoreAssertNotEqualArgs,\n    ) => void;\n    /** Assert a > b; reverts if a <= b — original id: \"core.assertGt\" */\n    readonly assertGt: (nodeId: string, args: CoreAssertGtArgs) => void;\n    /** Assert a >= b; reverts if a < b — original id: \"core.assertGte\" */\n    readonly assertGte: (nodeId: string, args: CoreAssertGteArgs) => void;\n    /** Assert a < b; reverts if a >= b — original id: \"core.assertLt\" */\n    readonly assertLt: (nodeId: string, args: CoreAssertLtArgs) => void;\n    /** Assert a <= b; reverts if a > b — original id: \"core.assertLte\" */\n    readonly assertLte: (nodeId: string, args: CoreAssertLteArgs) => void;\n    /** Assert min <= value <= max; reverts if value is outside the range — original id: \"core.assertInRange\" */\n    readonly assertInRange: (\n      nodeId: string,\n      args: CoreAssertInRangeArgs,\n    ) => void;\n    /** Approve an ERC20 spender for the given token and amount — original id: \"core.approve\" */\n    readonly approve: (nodeId: string, args: CoreApproveArgs) => void;\n    /** Read an ERC20 balance, producing a resource — original id: \"core.balanceOf\" */\n    readonly balanceOf: (\n      nodeId: string,\n      args: CoreBalanceOfArgs,\n    ) => CoreBalanceOfOutputs;\n    /** Transfer tokens to a recipient address, optionally specifying a partial amount — original id: \"core.transfer\" */\n    readonly transfer: (\n      nodeId: string,\n      args: CoreTransferArgs,\n    ) => CoreTransferOutputs;\n    /** Invoke a smart contract function, optionally spending a token resource — original id: \"core.call\" */\n    readonly call: <TSig extends string>(\n      nodeId: string,\n      args: CoreCallArgs<TSig>,\n    ) => CoreCallResult<TSig>;\n    /** Read from a smart contract at runtime (StaticCall); result is fresh at execution time — original id: \"core.staticCall\" */\n    readonly staticCall: <TSig extends string>(\n      nodeId: string,\n      args: CoreStaticCallArgs<TSig>,\n    ) => StaticCallResult<TSig>;\n    /** Invoke a contract with pre-encoded calldata — original id: \"core.rawCall\" */\n    readonly rawCall: (\n      nodeId: string,\n      args: CoreRawCallArgs,\n    ) => CoreRawCallOutputs;\n    /** Graduate a raw handle to a resource, enabling slippage surfacing and linearity tracking — original id: \"core.asResource\" */\n    readonly asResource: (\n      nodeId: string,\n      args: CoreAsResourceArgs,\n    ) => CoreAsResourceOutputs;\n    /** Read a smart contract value at compile time (off-chain eth_call); result is baked as a literal — original id: \"core.peek\" */\n    readonly peek: (nodeId: string, args: CorePeekArgs) => CorePeekOutputs;\n  };\n  readonly lifi: {\n    /** Swap tokens via the LI.FI aggregator API — original id: \"lifi.swap\" */\n    readonly swap: (nodeId: string, args: LifiSwapArgs) => LifiSwapOutputs;\n    /** Route tokens into a DeFi protocol position via the edge catalog — original id: \"lifi.zap\" */\n    readonly zap: (nodeId: string, args: LifiZapArgs) => LifiZapOutputs;\n  };\n  readonly invariant: {\n    /** Assert that an account holds at least a minimum token balance — original id: \"invariant.balanceAtLeast\" */\n    readonly balanceAtLeast: (\n      nodeId: string,\n      args: InvariantBalanceAtLeastArgs,\n    ) => void;\n  };\n};\n\nexport const bindGeneratedOps = (\n  builder: FlowBuilderInternal,\n): GeneratedOps => ({\n  core: {\n    split: (nodeId: string, args: CoreSplitArgs) =>\n      builder.call(nodeId, 'core.split', args, {\n        a: 'resource',\n        b: 'resource',\n      } as const),\n    merge: (nodeId: string, args: CoreMergeArgs) =>\n      builder.call(nodeId, 'core.merge', args, { merged: 'resource' } as const),\n    add: (nodeId: string, args: CoreAddArgs) =>\n      builder.call(nodeId, 'core.add', args, { result: 'uint256' } as const),\n    subtract: (nodeId: string, args: CoreSubtractArgs) =>\n      builder.call(nodeId, 'core.subtract', args, {\n        result: 'uint256',\n      } as const),\n    multiply: (nodeId: string, args: CoreMultiplyArgs) =>\n      builder.call(nodeId, 'core.multiply', args, {\n        result: 'uint256',\n      } as const),\n    divideDown: (nodeId: string, args: CoreDivideDownArgs) =>\n      builder.call(nodeId, 'core.divideDown', args, {\n        result: 'uint256',\n      } as const),\n    divideUp: (nodeId: string, args: CoreDivideUpArgs) =>\n      builder.call(nodeId, 'core.divideUp', args, {\n        result: 'uint256',\n      } as const),\n    bpsDown: (nodeId: string, args: CoreBpsDownArgs) =>\n      builder.call(nodeId, 'core.bpsDown', args, {\n        result: 'uint256',\n      } as const),\n    bpsUp: (nodeId: string, args: CoreBpsUpArgs) =>\n      builder.call(nodeId, 'core.bpsUp', args, { result: 'uint256' } as const),\n    assertEqual: (nodeId: string, args: CoreAssertEqualArgs) =>\n      builder.call(nodeId, 'core.assertEqual', args, {}),\n    assertNotEqual: (nodeId: string, args: CoreAssertNotEqualArgs) =>\n      builder.call(nodeId, 'core.assertNotEqual', args, {}),\n    assertGt: (nodeId: string, args: CoreAssertGtArgs) =>\n      builder.call(nodeId, 'core.assertGt', args, {}),\n    assertGte: (nodeId: string, args: CoreAssertGteArgs) =>\n      builder.call(nodeId, 'core.assertGte', args, {}),\n    assertLt: (nodeId: string, args: CoreAssertLtArgs) =>\n      builder.call(nodeId, 'core.assertLt', args, {}),\n    assertLte: (nodeId: string, args: CoreAssertLteArgs) =>\n      builder.call(nodeId, 'core.assertLte', args, {}),\n    assertInRange: (nodeId: string, args: CoreAssertInRangeArgs) =>\n      builder.call(nodeId, 'core.assertInRange', args, {}),\n    approve: (nodeId: string, args: CoreApproveArgs) =>\n      builder.call(nodeId, 'core.approve', args, {}),\n    balanceOf: (nodeId: string, args: CoreBalanceOfArgs) =>\n      builder.call(nodeId, 'core.balanceOf', args, {\n        balance: 'resource',\n      } as const),\n    transfer: (nodeId: string, args: CoreTransferArgs) =>\n      builder.call(nodeId, 'core.transfer', args, {\n        transferred: 'resource',\n        remainder: 'resource',\n      } as const),\n    call: <TSig extends string>(nodeId: string, args: CoreCallArgs<TSig>) => {\n      const wire = buildCallWireFormat({\n        resource: args.resource,\n        bind: args.bind as Record<string, AnyBindable>,\n        config: args.config as Record<string, unknown>,\n        guards: args.guards,\n      });\n      return builder.call(nodeId, wire.op, wire, {\n        result: 'uint256',\n      } as const) as unknown as CoreCallResult<TSig>;\n    },\n    staticCall: <TSig extends string>(\n      nodeId: string,\n      args: CoreStaticCallArgs<TSig>,\n    ) =>\n      builder.call(\n        nodeId,\n        'core.staticCall',\n        buildStaticCallWireFormat({\n          bind: args.bind as Record<string, AnyBindable>,\n          config: args.config as Record<string, unknown>,\n          guards: args.guards,\n        }),\n        { result: 'uint256' } as const,\n      ) as unknown as StaticCallResult<TSig>,\n    rawCall: (nodeId: string, args: CoreRawCallArgs) =>\n      builder.call(nodeId, 'core.rawCall', args, {\n        result: 'uint256',\n      } as const),\n    asResource: (nodeId: string, args: CoreAsResourceArgs) =>\n      builder.call(nodeId, 'core.asResource', args, {\n        resource: 'resource',\n      } as const),\n    peek: (nodeId: string, args: CorePeekArgs) =>\n      builder.call(nodeId, 'core.peek', args, { result: 'uint256' } as const),\n  },\n  lifi: {\n    swap: (nodeId: string, args: LifiSwapArgs) =>\n      builder.call(nodeId, 'lifi.swap', args, {\n        amountOut: 'resource',\n        unspentIn: 'resource',\n      } as const),\n    zap: (nodeId: string, args: LifiZapArgs) =>\n      builder.call(nodeId, 'lifi.zap', args, {\n        amountOut: 'resource',\n      } as const),\n  },\n  invariant: {\n    balanceAtLeast: (nodeId: string, args: InvariantBalanceAtLeastArgs) =>\n      builder.call(nodeId, 'invariant.balanceAtLeast', args, {}),\n  },\n});\n"],"mappings":"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","names":[]}

package/dist/generated/preconditions.generated.cjs

@@ -0,0 +1,44 @@
+"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 preconditions_generated_exports = {};
+__export(preconditions_generated_exports, {
+  erc20Allowance: () => erc20Allowance,
+  erc20Balance: () => erc20Balance,
+  nativeBalance: () => nativeBalance
+});
+module.exports = __toCommonJS(preconditions_generated_exports);
+const erc20Balance = (config) => ({
+  type: "Erc20Balance",
+  ...config
+});
+const nativeBalance = (config) => ({
+  type: "NativeBalance",
+  ...config
+});
+const erc20Allowance = (config) => ({
+  type: "Erc20Allowance",
+  ...config
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  erc20Allowance,
+  erc20Balance,
+  nativeBalance
+});
+//# sourceMappingURL=preconditions.generated.cjs.map

package/dist/generated/preconditions.generated.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/preconditions.generated.ts"],"sourcesContent":["// AUTO-GENERATED from manifest.json — do not edit by hand.\n// Regenerate with: yarn workspace @lifi/composer-sdk generate\n\nimport type { Precondition, PreconditionConfigOf } from '@lifi/compose-spec';\n\nimport type {\n  Erc20AllowancePreconditionConfig,\n  Erc20BalancePreconditionConfig,\n  NativeBalancePreconditionConfig,\n} from './config.generated.js';\n\nexport type Erc20BalancePreconditionInput =\n  PreconditionConfigOf<Erc20BalancePreconditionConfig>;\n\n/** Assert that a wallet holds at least a given ERC-20 token balance */\nexport const erc20Balance = (\n  config: Erc20BalancePreconditionInput,\n): Precondition => ({\n  type: 'Erc20Balance',\n  ...config,\n});\n\nexport type NativeBalancePreconditionInput =\n  PreconditionConfigOf<NativeBalancePreconditionConfig>;\n\n/** Assert that a wallet holds at least a given native coin balance */\nexport const nativeBalance = (\n  config: NativeBalancePreconditionInput,\n): Precondition => ({\n  type: 'NativeBalance',\n  ...config,\n});\n\nexport type Erc20AllowancePreconditionInput =\n  PreconditionConfigOf<Erc20AllowancePreconditionConfig>;\n\n/** Assert that an ERC-20 allowance is at least a given amount */\nexport const erc20Allowance = (\n  config: Erc20AllowancePreconditionInput,\n): Precondition => ({\n  type: 'Erc20Allowance',\n  ...config,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,MAAM,eAAe,CAC1B,YACkB;AAAA,EAClB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,gBAAgB,CAC3B,YACkB;AAAA,EAClB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,iBAAiB,CAC5B,YACkB;AAAA,EAClB,MAAM;AAAA,EACN,GAAG;AACL;","names":[]}

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

@@ -0,0 +1,4 @@
+import '@lifi/compose-spec';
+import './config.generated.cjs';
+export { E as Erc20AllowancePreconditionInput, a as Erc20BalancePreconditionInput, N as NativeBalancePreconditionInput, e as erc20Allowance, b as erc20Balance, n as nativeBalance } from '../preconditions.generated-DblS13Wq.cjs';
+import '../types.cjs';

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

@@ -0,0 +1,4 @@
+import '@lifi/compose-spec';
+import './config.generated.js';
+export { E as Erc20AllowancePreconditionInput, a as Erc20BalancePreconditionInput, N as NativeBalancePreconditionInput, e as erc20Allowance, b as erc20Balance, n as nativeBalance } from '../preconditions.generated-U7YpVh30.js';
+import '../types.js';

package/dist/generated/preconditions.generated.js

@@ -0,0 +1,18 @@
+const erc20Balance = (config) => ({
+  type: "Erc20Balance",
+  ...config
+});
+const nativeBalance = (config) => ({
+  type: "NativeBalance",
+  ...config
+});
+const erc20Allowance = (config) => ({
+  type: "Erc20Allowance",
+  ...config
+});
+export {
+  erc20Allowance,
+  erc20Balance,
+  nativeBalance
+};
+//# sourceMappingURL=preconditions.generated.js.map

package/dist/generated/preconditions.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/preconditions.generated.ts"],"sourcesContent":["// AUTO-GENERATED from manifest.json — do not edit by hand.\n// Regenerate with: yarn workspace @lifi/composer-sdk generate\n\nimport type { Precondition, PreconditionConfigOf } from '@lifi/compose-spec';\n\nimport type {\n  Erc20AllowancePreconditionConfig,\n  Erc20BalancePreconditionConfig,\n  NativeBalancePreconditionConfig,\n} from './config.generated.js';\n\nexport type Erc20BalancePreconditionInput =\n  PreconditionConfigOf<Erc20BalancePreconditionConfig>;\n\n/** Assert that a wallet holds at least a given ERC-20 token balance */\nexport const erc20Balance = (\n  config: Erc20BalancePreconditionInput,\n): Precondition => ({\n  type: 'Erc20Balance',\n  ...config,\n});\n\nexport type NativeBalancePreconditionInput =\n  PreconditionConfigOf<NativeBalancePreconditionConfig>;\n\n/** Assert that a wallet holds at least a given native coin balance */\nexport const nativeBalance = (\n  config: NativeBalancePreconditionInput,\n): Precondition => ({\n  type: 'NativeBalance',\n  ...config,\n});\n\nexport type Erc20AllowancePreconditionInput =\n  PreconditionConfigOf<Erc20AllowancePreconditionConfig>;\n\n/** Assert that an ERC-20 allowance is at least a given amount */\nexport const erc20Allowance = (\n  config: Erc20AllowancePreconditionInput,\n): Precondition => ({\n  type: 'Erc20Allowance',\n  ...config,\n});\n"],"mappings":"AAeO,MAAM,eAAe,CAC1B,YACkB;AAAA,EAClB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,gBAAgB,CAC3B,YACkB;AAAA,EAClB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,iBAAiB,CAC5B,YACkB;AAAA,EAClB,MAAM;AAAA,EACN,GAAG;AACL;","names":[]}

package/dist/guards.generated-DKKDKREA.d.ts

@@ -0,0 +1,14 @@
+import { TypedGuard } from './types.js';
+import { SlippageGuardConfig } from './generated/config.generated.js';
+
+/** Assert that output amounts are within a slippage tolerance in basis points */
+declare const slippage: <P extends string>(config: Omit<SlippageGuardConfig, "port"> & {
+    port: P;
+}) => TypedGuard<P>;
+
+declare const guardsMod_slippage: typeof slippage;
+declare namespace guardsMod {
+  export { guardsMod_slippage as slippage };
+}
+
+export { guardsMod as g, slippage as s };

package/dist/guards.generated-hrQ1KPNv.d.cts

@@ -0,0 +1,14 @@
+import { TypedGuard } from './types.cjs';
+import { SlippageGuardConfig } from './generated/config.generated.cjs';
+
+/** Assert that output amounts are within a slippage tolerance in basis points */
+declare const slippage: <P extends string>(config: Omit<SlippageGuardConfig, "port"> & {
+    port: P;
+}) => TypedGuard<P>;
+
+declare const guardsMod_slippage: typeof slippage;
+declare namespace guardsMod {
+  export { guardsMod_slippage as slippage };
+}
+
+export { guardsMod as g, slippage as s };

package/dist/index.cjs

@@ -0,0 +1,76 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  createComposeSdk: () => import_sdk.createComposeSdk,
+  guards: () => guards,
+  isComposeError: () => import_errors.isComposeError,
+  isInputHandle: () => import_handles.isInputHandle,
+  isOutputHandle: () => import_handles.isOutputHandle,
+  materialiser: () => import_inputs.materialiser,
+  materialisers: () => materialisers,
+  preconditions: () => preconditions,
+  raw: () => raw,
+  ref: () => import_raw.ref,
+  resources: () => resources
+});
+module.exports = __toCommonJS(index_exports);
+var import_errors = require("./errors.js");
+var import_handles = require("./authoring/handles.js");
+var import_raw = require("./authoring/raw.js");
+var import_inputs = require("./run/inputs.js");
+var import_sdk = require("./sdk.js");
+var guardsMod = __toESM(require("./generated/guards.generated.js"), 1);
+var materialisersMod = __toESM(require("./generated/materialisers.generated.js"), 1);
+var preconditionsMod = __toESM(require("./generated/preconditions.generated.js"), 1);
+var rawMod = __toESM(require("./raw.js"), 1);
+var resourcesMod = __toESM(require("./resources.js"), 1);
+__reExport(index_exports, require("./generated/config.generated.js"), module.exports);
+const guards = guardsMod;
+const materialisers = materialisersMod;
+const preconditions = preconditionsMod;
+const resources = resourcesMod;
+const raw = rawMod;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createComposeSdk,
+  guards,
+  isComposeError,
+  isInputHandle,
+  isOutputHandle,
+  materialiser,
+  materialisers,
+  preconditions,
+  raw,
+  ref,
+  resources,
+  ...require("./generated/config.generated.js")
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +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 { ComposeError, ComposeErrorCode } 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  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} from '@lifi/compose-spec';\nexport { isComposeError } 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 { 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsDA,oBAA+B;AAS/B,qBAA8C;AAC9C,iBAAoB;AAMpB,oBAA6B;AAE7B,iBAAiC;AAGjC,gBAA2B;AAC3B,uBAAkC;AAClC,uBAAkC;AAClC,aAAwB;AACxB,mBAA8B;AA6D9B,0BAAc,4CA5Id;AA8FO,MAAM,SAA2B;AAajC,MAAM,gBAAyC;AAgB/C,MAAM,gBAAyC;AAgB/C,MAAM,YAAiC;AASvC,MAAM,MAAqB;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,99 @@
+export { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef } from './types.cjs';
+export { GetZapPacksOptions, ZapPackEdge, ZapPackOverview } from './discovery.cjs';
+export { ComposeError, ComposeErrorCode, isComposeError } from './errors.cjs';
+export { AppliedGuard, ApprovalEntry, Call, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeContinuation, ComposeErrorKind, ComposeTransactionRequest, Flow, InputSpec, MaterialiserConfigOf, MaterialiserInput, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, SimulationPolicy, SimulationRevert, SolType, SweepTo } from '@lifi/compose-spec';
+export { AnyHandle, Bindable, InputHandle, OutputHandle, ResourceInputHandle, isInputHandle, isOutputHandle } from './authoring/handles.cjs';
+export { ref } from './authoring/raw.cjs';
+export { AnyBindable, FlowOptions, TypedFlow } from './authoring/FlowBuilderCore.cjs';
+export { ComposeRunInput, materialiser } from './run/inputs.cjs';
+export { ComposeSdk, ComposeSdkOptions, FlowBuilder, createComposeSdk } from './sdk.cjs';
+import { g as guardsMod } from './guards.generated-hrQ1KPNv.cjs';
+import { m as materialisersMod } from './materialisers.generated-nMxTAaVi.cjs';
+import { p as preconditionsMod } from './preconditions.generated-DblS13Wq.cjs';
+import { r as rawMod } from './raw-Dj_2rBSQ.cjs';
+import { r as resourcesMod } from './resources-BKlFxjo8.cjs';
+export { BalanceOfMaterialiserConfig, Between010000, CallMaterialiserConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreInvokeConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, Erc20BalancePreconditionConfig, LifiSwapConfig, LifiZapConfig, NativeBalancePreconditionConfig, Positive, SlippageGuardConfig, Unknown } from './generated/config.generated.cjs';
+import './client.cjs';
+import './generated/operations.generated.cjs';
+import './authoring/signatureArgs.cjs';
+import 'abitype';
+
+/**
+ * `@lifi/composer-sdk` — TypeScript SDK for building and compiling
+ * Compose flows into executable EVM calldata.
+ *
+ * Start by creating an SDK instance with {@link createComposeSdk}, then use
+ * {@link ComposeSdk.flow} to build flows and compile them.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Guard factories for protecting operation outputs (e.g. slippage tolerance).
+ * Pass guards to an operation's `guards` array.
+ *
+ * @example
+ * ```ts
+ * builder.lifi.swap('swap1', {
+ *   bind: { amountIn: builder.inputs.token },
+ *   config: { resourceOut: resources.native(1) },
+ *   guards: [guards.slippage({ port: 'amountOut', bps: 300 })],
+ * });
+ * ```
+ */
+declare const guards: typeof guardsMod;
+/**
+ * Materialiser factories that tell the runtime how to resolve token input
+ * amounts on-chain (e.g. read a wallet balance, accept a direct deposit).
+ *
+ * @example
+ * ```ts
+ * await builder.compile({
+ *   inputs: { token: materialisers.balanceOf({}) },
+ *   signer: '0x...',
+ * });
+ * ```
+ */
+declare const materialisers: typeof materialisersMod;
+/**
+ * Precondition factories for asserting on-chain state before a flow executes
+ * (e.g. minimum token balances, ERC-20 allowances).
+ *
+ * @example
+ * ```ts
+ * await builder.compile({
+ *   inputs: { token: materialisers.balanceOf({}) },
+ *   preconditions: [
+ *     preconditions.erc20Balance({ wallet: '0x...', token: '0x...', balance: 1000n }),
+ *   ],
+ *   signer: '0x...',
+ * });
+ * ```
+ */
+declare const preconditions: typeof preconditionsMod;
+/**
+ * Resource declaration helpers for defining token inputs in a flow schema.
+ * Use {@link resources.erc20} for ERC-20 tokens and {@link resources.native}
+ * for the chain's native coin (ETH, MATIC, etc.).
+ *
+ * @example
+ * ```ts
+ * const builder = sdk.flow(1, {
+ *   inputs: {
+ *     usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1),
+ *     eth: resources.native(1),
+ *   },
+ * });
+ * ```
+ */
+declare const resources: typeof resourcesMod;
+
+/**
+ * Low-level escape hatch for constructing flow nodes, guards, and materialiser
+ * inputs without the typed builder API. Prefer the generated operation methods
+ * on {@link FlowBuilder} and the typed `guards`/`materialisers` namespaces
+ * for most use cases.
+ */
+declare const raw: typeof rawMod;
+
+export { guards, materialisers, preconditions, raw, resources };

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+export { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef } from './types.js';
+export { GetZapPacksOptions, ZapPackEdge, ZapPackOverview } from './discovery.js';
+export { ComposeError, ComposeErrorCode, isComposeError } from './errors.js';
+export { AppliedGuard, ApprovalEntry, Call, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeContinuation, ComposeErrorKind, ComposeTransactionRequest, Flow, InputSpec, MaterialiserConfigOf, MaterialiserInput, Precondition, PreconditionConfigOf, PriceImpact, Ref, Resource, SimulationPolicy, SimulationRevert, SolType, SweepTo } from '@lifi/compose-spec';
+export { AnyHandle, Bindable, InputHandle, OutputHandle, 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';
+export { ComposeSdk, ComposeSdkOptions, FlowBuilder, createComposeSdk } from './sdk.js';
+import { g as guardsMod } from './guards.generated-DKKDKREA.js';
+import { m as materialisersMod } from './materialisers.generated-BsA1uDW8.js';
+import { p as preconditionsMod } from './preconditions.generated-U7YpVh30.js';
+import { r as rawMod } from './raw-IxCF_bSS.js';
+import { r as resourcesMod } from './resources-CYis1_DS.js';
+export { BalanceOfMaterialiserConfig, Between010000, CallMaterialiserConfig, CoreApproveConfig, CoreAsResourceConfig, CoreBalanceOfConfig, CoreBpsDownConfig, CoreBpsUpConfig, CoreCallConfig, CoreInvokeConfig, CorePeekConfig, CoreRawCallConfig, CoreSplitConfig, CoreStaticCallConfig, CoreTransferConfig, DirectDepositMaterialiserConfig, Erc20AllowancePreconditionConfig, Erc20BalancePreconditionConfig, LifiSwapConfig, LifiZapConfig, NativeBalancePreconditionConfig, Positive, SlippageGuardConfig, Unknown } from './generated/config.generated.js';
+import './client.js';
+import './generated/operations.generated.js';
+import './authoring/signatureArgs.js';
+import 'abitype';
+
+/**
+ * `@lifi/composer-sdk` — TypeScript SDK for building and compiling
+ * Compose flows into executable EVM calldata.
+ *
+ * Start by creating an SDK instance with {@link createComposeSdk}, then use
+ * {@link ComposeSdk.flow} to build flows and compile them.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Guard factories for protecting operation outputs (e.g. slippage tolerance).
+ * Pass guards to an operation's `guards` array.
+ *
+ * @example
+ * ```ts
+ * builder.lifi.swap('swap1', {
+ *   bind: { amountIn: builder.inputs.token },
+ *   config: { resourceOut: resources.native(1) },
+ *   guards: [guards.slippage({ port: 'amountOut', bps: 300 })],
+ * });
+ * ```
+ */
+declare const guards: typeof guardsMod;
+/**
+ * Materialiser factories that tell the runtime how to resolve token input
+ * amounts on-chain (e.g. read a wallet balance, accept a direct deposit).
+ *
+ * @example
+ * ```ts
+ * await builder.compile({
+ *   inputs: { token: materialisers.balanceOf({}) },
+ *   signer: '0x...',
+ * });
+ * ```
+ */
+declare const materialisers: typeof materialisersMod;
+/**
+ * Precondition factories for asserting on-chain state before a flow executes
+ * (e.g. minimum token balances, ERC-20 allowances).
+ *
+ * @example
+ * ```ts
+ * await builder.compile({
+ *   inputs: { token: materialisers.balanceOf({}) },
+ *   preconditions: [
+ *     preconditions.erc20Balance({ wallet: '0x...', token: '0x...', balance: 1000n }),
+ *   ],
+ *   signer: '0x...',
+ * });
+ * ```
+ */
+declare const preconditions: typeof preconditionsMod;
+/**
+ * Resource declaration helpers for defining token inputs in a flow schema.
+ * Use {@link resources.erc20} for ERC-20 tokens and {@link resources.native}
+ * for the chain's native coin (ETH, MATIC, etc.).
+ *
+ * @example
+ * ```ts
+ * const builder = sdk.flow(1, {
+ *   inputs: {
+ *     usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1),
+ *     eth: resources.native(1),
+ *   },
+ * });
+ * ```
+ */
+declare const resources: typeof resourcesMod;
+
+/**
+ * Low-level escape hatch for constructing flow nodes, guards, and materialiser
+ * inputs without the typed builder API. Prefer the generated operation methods
+ * on {@link FlowBuilder} and the typed `guards`/`materialisers` namespaces
+ * for most use cases.
+ */
+declare const raw: typeof rawMod;
+
+export { guards, materialisers, preconditions, raw, resources };

package/dist/index.js

@@ -0,0 +1,30 @@
+import { isComposeError } from "./errors.js";
+import { isInputHandle, isOutputHandle } from "./authoring/handles.js";
+import { ref } from "./authoring/raw.js";
+import { materialiser } from "./run/inputs.js";
+import { createComposeSdk } from "./sdk.js";
+import * as guardsMod from "./generated/guards.generated.js";
+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";
+const guards = guardsMod;
+const materialisers = materialisersMod;
+const preconditions = preconditionsMod;
+const resources = resourcesMod;
+export * from "./generated/config.generated.js";
+const raw = rawMod;
+export {
+  createComposeSdk,
+  guards,
+  isComposeError,
+  isInputHandle,
+  isOutputHandle,
+  materialiser,
+  materialisers,
+  preconditions,
+  raw,
+  ref,
+  resources
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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 { ComposeError, ComposeErrorCode } 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  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} from '@lifi/compose-spec';\nexport { isComposeError } 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 { 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":"AAsDA,SAAS,sBAAsB;AAS/B,SAAS,eAAe,sBAAsB;AAC9C,SAAS,WAAW;AAMpB,SAAS,oBAAoB;AAE7B,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":[]}

package/dist/materialisers.generated-BsA1uDW8.d.ts

@@ -0,0 +1,24 @@
+import { MaterialiserConfigOf, MaterialiserInput } from '@lifi/compose-spec';
+import { BalanceOfMaterialiserConfig, CallMaterialiserConfig, DirectDepositMaterialiserConfig } from './generated/config.generated.js';
+
+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 };