@lifi/composer-sdk 0.0.1-alpha

package/dist/generated/guards.generated.cjs

@@ -0,0 +1,32 @@
+"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 guards_generated_exports = {};
+__export(guards_generated_exports, {
+  slippage: () => slippage
+});
+module.exports = __toCommonJS(guards_generated_exports);
+const slippage = (config) => ({
+  kind: "slippage",
+  ...config
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  slippage
+});
+//# sourceMappingURL=guards.generated.cjs.map

package/dist/generated/guards.generated.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/guards.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 { TypedGuard } from '../types.js';\n\nimport type { SlippageGuardConfig } from './config.generated.js';\n\n/** Assert that output amounts are within a slippage tolerance in basis points */\nexport const slippage = <P extends string>(\n  config: Omit<SlippageGuardConfig, 'port'> & { port: P },\n): TypedGuard<P> => ({\n  kind: 'slippage',\n  ...config,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQO,MAAM,WAAW,CACtB,YACmB;AAAA,EACnB,MAAM;AAAA,EACN,GAAG;AACL;","names":[]}

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

@@ -0,0 +1,4 @@
+import '../types.cjs';
+import './config.generated.cjs';
+export { s as slippage } from '../guards.generated-hrQ1KPNv.cjs';
+import '@lifi/compose-spec';

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

@@ -0,0 +1,4 @@
+import '../types.js';
+import './config.generated.js';
+export { s as slippage } from '../guards.generated-DKKDKREA.js';
+import '@lifi/compose-spec';

package/dist/generated/guards.generated.js

@@ -0,0 +1,8 @@
+const slippage = (config) => ({
+  kind: "slippage",
+  ...config
+});
+export {
+  slippage
+};
+//# sourceMappingURL=guards.generated.js.map

package/dist/generated/guards.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/guards.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 { TypedGuard } from '../types.js';\n\nimport type { SlippageGuardConfig } from './config.generated.js';\n\n/** Assert that output amounts are within a slippage tolerance in basis points */\nexport const slippage = <P extends string>(\n  config: Omit<SlippageGuardConfig, 'port'> & { port: P },\n): TypedGuard<P> => ({\n  kind: 'slippage',\n  ...config,\n});\n"],"mappings":"AAQO,MAAM,WAAW,CACtB,YACmB;AAAA,EACnB,MAAM;AAAA,EACN,GAAG;AACL;","names":[]}

package/dist/generated/materialisers.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 materialisers_generated_exports = {};
+__export(materialisers_generated_exports, {
+  balanceOf: () => balanceOf,
+  call: () => call,
+  directDeposit: () => directDeposit
+});
+module.exports = __toCommonJS(materialisers_generated_exports);
+const balanceOf = (config) => ({
+  kind: "balanceOf",
+  ...config
+});
+const directDeposit = (config) => ({
+  kind: "directDeposit",
+  ...config
+});
+const call = (config) => ({
+  kind: "call",
+  ...config
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  balanceOf,
+  call,
+  directDeposit
+});
+//# sourceMappingURL=materialisers.generated.cjs.map

package/dist/generated/materialisers.generated.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/materialisers.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  MaterialiserConfigOf,\n  MaterialiserInput,\n} from '@lifi/compose-spec';\n\nimport type {\n  BalanceOfMaterialiserConfig,\n  CallMaterialiserConfig,\n  DirectDepositMaterialiserConfig,\n} from './config.generated.js';\n\nexport type BalanceOfMaterialiserInput =\n  MaterialiserConfigOf<BalanceOfMaterialiserConfig>;\n\n/** Read the on-chain token balance of an address as the input amount — accepts: resource */\nexport const balanceOf = (\n  config: BalanceOfMaterialiserInput,\n): MaterialiserInput => ({\n  kind: 'balanceOf',\n  ...config,\n});\n\nexport type DirectDepositMaterialiserInput =\n  MaterialiserConfigOf<DirectDepositMaterialiserConfig>;\n\n/** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */\nexport const directDeposit = (\n  config: DirectDepositMaterialiserInput,\n): MaterialiserInput => ({\n  kind: 'directDeposit',\n  ...config,\n});\n\nexport type CallMaterialiserInput =\n  MaterialiserConfigOf<CallMaterialiserConfig>;\n\n/** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */\nexport const call = (config: CallMaterialiserInput): MaterialiserInput => ({\n  kind: 'call',\n  ...config,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,MAAM,YAAY,CACvB,YACuB;AAAA,EACvB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,gBAAgB,CAC3B,YACuB;AAAA,EACvB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,OAAO,CAAC,YAAsD;AAAA,EACzE,MAAM;AAAA,EACN,GAAG;AACL;","names":[]}

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

@@ -0,0 +1,4 @@
+import '@lifi/compose-spec';
+import './config.generated.cjs';
+export { B as BalanceOfMaterialiserInput, C as CallMaterialiserInput, D as DirectDepositMaterialiserInput, b as balanceOf, c as call, d as directDeposit } from '../materialisers.generated-nMxTAaVi.cjs';
+import '../types.cjs';

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

@@ -0,0 +1,4 @@
+import '@lifi/compose-spec';
+import './config.generated.js';
+export { B as BalanceOfMaterialiserInput, C as CallMaterialiserInput, D as DirectDepositMaterialiserInput, b as balanceOf, c as call, d as directDeposit } from '../materialisers.generated-BsA1uDW8.js';
+import '../types.js';

package/dist/generated/materialisers.generated.js

@@ -0,0 +1,18 @@
+const balanceOf = (config) => ({
+  kind: "balanceOf",
+  ...config
+});
+const directDeposit = (config) => ({
+  kind: "directDeposit",
+  ...config
+});
+const call = (config) => ({
+  kind: "call",
+  ...config
+});
+export {
+  balanceOf,
+  call,
+  directDeposit
+};
+//# sourceMappingURL=materialisers.generated.js.map

package/dist/generated/materialisers.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generated/materialisers.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  MaterialiserConfigOf,\n  MaterialiserInput,\n} from '@lifi/compose-spec';\n\nimport type {\n  BalanceOfMaterialiserConfig,\n  CallMaterialiserConfig,\n  DirectDepositMaterialiserConfig,\n} from './config.generated.js';\n\nexport type BalanceOfMaterialiserInput =\n  MaterialiserConfigOf<BalanceOfMaterialiserConfig>;\n\n/** Read the on-chain token balance of an address as the input amount — accepts: resource */\nexport const balanceOf = (\n  config: BalanceOfMaterialiserInput,\n): MaterialiserInput => ({\n  kind: 'balanceOf',\n  ...config,\n});\n\nexport type DirectDepositMaterialiserInput =\n  MaterialiserConfigOf<DirectDepositMaterialiserConfig>;\n\n/** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */\nexport const directDeposit = (\n  config: DirectDepositMaterialiserInput,\n): MaterialiserInput => ({\n  kind: 'directDeposit',\n  ...config,\n});\n\nexport type CallMaterialiserInput =\n  MaterialiserConfigOf<CallMaterialiserConfig>;\n\n/** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */\nexport const call = (config: CallMaterialiserInput): MaterialiserInput => ({\n  kind: 'call',\n  ...config,\n});\n"],"mappings":"AAkBO,MAAM,YAAY,CACvB,YACuB;AAAA,EACvB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,gBAAgB,CAC3B,YACuB;AAAA,EACvB,MAAM;AAAA,EACN,GAAG;AACL;AAMO,MAAM,OAAO,CAAC,YAAsD;AAAA,EACzE,MAAM;AAAA,EACN,GAAG;AACL;","names":[]}

package/dist/generated/operations.generated.cjs

@@ -0,0 +1,110 @@
+"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 operations_generated_exports = {};
+__export(operations_generated_exports, {
+  bindGeneratedOps: () => bindGeneratedOps
+});
+module.exports = __toCommonJS(operations_generated_exports);
+var import_signatureArgs = require("../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 = (0, import_signatureArgs.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",
+      (0, import_signatureArgs.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, {})
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindGeneratedOps
+});
+//# sourceMappingURL=operations.generated.cjs.map

package/dist/generated/operations.generated.cjs.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":[]}