@lifi/composer-sdk 0.0.1-alpha

package/dist/generated/operations.generated.d.cts

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

package/dist/generated/operations.generated.d.ts

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