@lifi/composer-sdk 0.0.1-alpha

package/src/generated/materialisers.generated.ts

@@ -0,0 +1,44 @@
+// AUTO-GENERATED from manifest.json — do not edit by hand.
+// Regenerate with: yarn workspace @lifi/composer-sdk generate
+
+import type {
+  MaterialiserConfigOf,
+  MaterialiserInput,
+} from '@lifi/compose-spec';
+
+import type {
+  BalanceOfMaterialiserConfig,
+  CallMaterialiserConfig,
+  DirectDepositMaterialiserConfig,
+} from './config.generated.js';
+
+export type BalanceOfMaterialiserInput =
+  MaterialiserConfigOf<BalanceOfMaterialiserConfig>;
+
+/** Read the on-chain token balance of an address as the input amount — accepts: resource */
+export const balanceOf = (
+  config: BalanceOfMaterialiserInput,
+): MaterialiserInput => ({
+  kind: 'balanceOf',
+  ...config,
+});
+
+export type DirectDepositMaterialiserInput =
+  MaterialiserConfigOf<DirectDepositMaterialiserConfig>;
+
+/** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */
+export const directDeposit = (
+  config: DirectDepositMaterialiserInput,
+): MaterialiserInput => ({
+  kind: 'directDeposit',
+  ...config,
+});
+
+export type CallMaterialiserInput =
+  MaterialiserConfigOf<CallMaterialiserConfig>;
+
+/** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */
+export const call = (config: CallMaterialiserInput): MaterialiserInput => ({
+  kind: 'call',
+  ...config,
+});

package/src/generated/operations.generated.ts

@@ -0,0 +1,568 @@
+// AUTO-GENERATED from manifest.json — do not edit by hand.
+// Regenerate with: yarn workspace @lifi/composer-sdk generate
+
+import type {
+  AnyBindable,
+  FlowBuilderInternal,
+} from '../authoring/FlowBuilderCore.js';
+import type { Bindable, OutputHandle } from '../authoring/handles.js';
+import type {
+  CoreCallResult,
+  SignatureBind,
+  StaticCallResult,
+} from '../authoring/signatureArgs.js';
+import {
+  buildCallWireFormat,
+  buildStaticCallWireFormat,
+} from '../authoring/signatureArgs.js';
+import type { TypedGuard } from '../types.js';
+
+import type {
+  CoreApproveConfig,
+  CoreAsResourceConfig,
+  CoreBalanceOfConfig,
+  CoreBpsDownConfig,
+  CoreBpsUpConfig,
+  CoreCallConfig,
+  CorePeekConfig,
+  CoreRawCallConfig,
+  CoreSplitConfig,
+  CoreStaticCallConfig,
+  CoreTransferConfig,
+  LifiSwapConfig,
+  LifiZapConfig,
+} from './config.generated.js';
+
+/** Split a resource into two outputs by basis-point ratio */
+export 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 */
+export 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 */
+export 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 */
+export 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 */
+export interface LifiZapArgs {
+  readonly bind: {
+    readonly amountIn: Bindable<'resource'>;
+  };
+  readonly config: LifiZapConfig;
+  readonly guards?: readonly TypedGuard<'amountOut'>[];
+}
+
+/** Add two unsigned integers (a + b) */
+export 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 */
+export interface CoreSubtractArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<'result'>[];
+}
+
+/** Multiply two unsigned integers (a * b) */
+export interface CoreMultiplyArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<'result'>[];
+}
+
+/** Divide a by b, rounding toward zero */
+export 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 */
+export 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 */
+export 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 */
+export interface CoreBpsUpArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: CoreBpsUpConfig;
+  readonly guards?: readonly TypedGuard<'result'>[];
+}
+
+/** Assert a == b; reverts if not equal */
+export interface CoreAssertEqualArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a != b; reverts if equal */
+export interface CoreAssertNotEqualArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a > b; reverts if a <= b */
+export interface CoreAssertGtArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a >= b; reverts if a < b */
+export interface CoreAssertGteArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a < b; reverts if a >= b */
+export interface CoreAssertLtArgs {
+  readonly bind: {
+    readonly a: Bindable<'uint256'>;
+    readonly b: Bindable<'uint256'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a <= b; reverts if a > b */
+export 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 */
+export 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 */
+export interface CoreApproveArgs {
+  readonly bind: {
+    readonly amount: Bindable<'resource'>;
+  };
+  readonly config: CoreApproveConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Read an ERC20 balance, producing a resource */
+export 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 */
+export 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 */
+export 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 */
+export 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 */
+export 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 */
+export 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 */
+export interface CorePeekArgs {
+  readonly bind: Record<string, never>;
+  readonly config: CorePeekConfig;
+  readonly guards?: readonly TypedGuard<'result'>[];
+}
+
+export interface CoreSplitOutputs {
+  readonly a: OutputHandle<'resource'>;
+  readonly b: OutputHandle<'resource'>;
+}
+
+export interface CoreMergeOutputs {
+  readonly merged: OutputHandle<'resource'>;
+}
+
+export interface LifiSwapOutputs {
+  readonly amountOut: OutputHandle<'resource'>;
+  readonly unspentIn: OutputHandle<'resource'>;
+}
+
+export interface LifiZapOutputs {
+  readonly amountOut: OutputHandle<'resource'>;
+}
+
+export interface CoreAddOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreSubtractOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreMultiplyOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreDivideDownOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreDivideUpOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreBpsDownOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreBpsUpOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreBalanceOfOutputs {
+  readonly balance: OutputHandle<'resource'>;
+}
+
+export interface CoreTransferOutputs {
+  readonly transferred: OutputHandle<'resource'>;
+  readonly remainder: OutputHandle<'resource'>;
+}
+
+export interface CoreRawCallOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export interface CoreAsResourceOutputs {
+  readonly resource: OutputHandle<'resource'>;
+}
+
+export interface CorePeekOutputs {
+  readonly result: OutputHandle<'uint256'>;
+}
+
+export 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;
+  };
+};
+
+export const bindGeneratedOps = (
+  builder: FlowBuilderInternal,
+): GeneratedOps => ({
+  core: {
+    split: (nodeId: string, args: CoreSplitArgs) =>
+      builder.call(nodeId, 'core.split', args, {
+        a: 'resource',
+        b: 'resource',
+      } as const),
+    merge: (nodeId: string, args: CoreMergeArgs) =>
+      builder.call(nodeId, 'core.merge', { ...args, config: {} }, {
+        merged: 'resource',
+      } as const),
+    add: (nodeId: string, args: CoreAddArgs) =>
+      builder.call(nodeId, 'core.add', { ...args, config: {} }, {
+        result: 'uint256',
+      } as const),
+    subtract: (nodeId: string, args: CoreSubtractArgs) =>
+      builder.call(nodeId, 'core.subtract', { ...args, config: {} }, {
+        result: 'uint256',
+      } as const),
+    multiply: (nodeId: string, args: CoreMultiplyArgs) =>
+      builder.call(nodeId, 'core.multiply', { ...args, config: {} }, {
+        result: 'uint256',
+      } as const),
+    divideDown: (nodeId: string, args: CoreDivideDownArgs) =>
+      builder.call(nodeId, 'core.divideDown', { ...args, config: {} }, {
+        result: 'uint256',
+      } as const),
+    divideUp: (nodeId: string, args: CoreDivideUpArgs) =>
+      builder.call(nodeId, 'core.divideUp', { ...args, config: {} }, {
+        result: 'uint256',
+      } as const),
+    bpsDown: (nodeId: string, args: CoreBpsDownArgs) =>
+      builder.call(nodeId, 'core.bpsDown', args, {
+        result: 'uint256',
+      } as const),
+    bpsUp: (nodeId: string, args: CoreBpsUpArgs) =>
+      builder.call(nodeId, 'core.bpsUp', args, { result: 'uint256' } as const),
+    assertEqual: (nodeId: string, args: CoreAssertEqualArgs) =>
+      builder.call(nodeId, 'core.assertEqual', { ...args, config: {} }, {}),
+    assertNotEqual: (nodeId: string, args: CoreAssertNotEqualArgs) =>
+      builder.call(nodeId, 'core.assertNotEqual', { ...args, config: {} }, {}),
+    assertGt: (nodeId: string, args: CoreAssertGtArgs) =>
+      builder.call(nodeId, 'core.assertGt', { ...args, config: {} }, {}),
+    assertGte: (nodeId: string, args: CoreAssertGteArgs) =>
+      builder.call(nodeId, 'core.assertGte', { ...args, config: {} }, {}),
+    assertLt: (nodeId: string, args: CoreAssertLtArgs) =>
+      builder.call(nodeId, 'core.assertLt', { ...args, config: {} }, {}),
+    assertLte: (nodeId: string, args: CoreAssertLteArgs) =>
+      builder.call(nodeId, 'core.assertLte', { ...args, config: {} }, {}),
+    assertInRange: (nodeId: string, args: CoreAssertInRangeArgs) =>
+      builder.call(nodeId, 'core.assertInRange', { ...args, config: {} }, {}),
+    approve: (nodeId: string, args: CoreApproveArgs) =>
+      builder.call(nodeId, 'core.approve', args, {}),
+    balanceOf: (nodeId: string, args: CoreBalanceOfArgs) =>
+      builder.call(nodeId, 'core.balanceOf', args, {
+        balance: 'resource',
+      } as const),
+    transfer: (nodeId: string, args: CoreTransferArgs) =>
+      builder.call(nodeId, 'core.transfer', args, {
+        transferred: 'resource',
+        remainder: 'resource',
+      } as const),
+    call: <TSig extends string>(nodeId: string, args: CoreCallArgs<TSig>) => {
+      const wire = buildCallWireFormat({
+        resource: args.resource,
+        bind: args.bind as Record<string, AnyBindable>,
+        config: args.config as Record<string, unknown>,
+        guards: args.guards,
+      });
+      return builder.call(nodeId, wire.op, wire, {
+        result: 'uint256',
+      } as const) as unknown as CoreCallResult<TSig>;
+    },
+    staticCall: <TSig extends string>(
+      nodeId: string,
+      args: CoreStaticCallArgs<TSig>,
+    ) =>
+      builder.call(
+        nodeId,
+        'core.staticCall',
+        buildStaticCallWireFormat({
+          bind: args.bind as Record<string, AnyBindable>,
+          config: args.config as Record<string, unknown>,
+          guards: args.guards,
+        }),
+        { result: 'uint256' } as const,
+      ) as unknown as StaticCallResult<TSig>,
+    rawCall: (nodeId: string, args: CoreRawCallArgs) =>
+      builder.call(nodeId, 'core.rawCall', args, {
+        result: 'uint256',
+      } as const),
+    asResource: (nodeId: string, args: CoreAsResourceArgs) =>
+      builder.call(nodeId, 'core.asResource', args, {
+        resource: 'resource',
+      } as const),
+    peek: (nodeId: string, args: CorePeekArgs) =>
+      builder.call(nodeId, 'core.peek', args, { result: 'uint256' } as const),
+  },
+  lifi: {
+    swap: (nodeId: string, args: LifiSwapArgs) =>
+      builder.call(nodeId, 'lifi.swap', args, {
+        amountOut: 'resource',
+        unspentIn: 'resource',
+      } as const),
+    zap: (nodeId: string, args: LifiZapArgs) =>
+      builder.call(nodeId, 'lifi.zap', args, {
+        amountOut: 'resource',
+      } as const),
+  },
+  invariant: {
+    balanceAtLeast: (nodeId: string, args: InvariantBalanceAtLeastArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceAtLeast',
+        { ...args, config: {} },
+        {},
+      ),
+  },
+});

package/src/generated/preconditions.generated.ts

@@ -0,0 +1,43 @@
+// AUTO-GENERATED from manifest.json — do not edit by hand.
+// Regenerate with: yarn workspace @lifi/composer-sdk generate
+
+import type { Precondition, PreconditionConfigOf } from '@lifi/compose-spec';
+
+import type {
+  Erc20AllowancePreconditionConfig,
+  Erc20BalancePreconditionConfig,
+  NativeBalancePreconditionConfig,
+} from './config.generated.js';
+
+export type Erc20BalancePreconditionInput =
+  PreconditionConfigOf<Erc20BalancePreconditionConfig>;
+
+/** Assert that a wallet holds at least a given ERC-20 token balance */
+export const erc20Balance = (
+  config: Erc20BalancePreconditionInput,
+): Precondition => ({
+  type: 'Erc20Balance',
+  ...config,
+});
+
+export type NativeBalancePreconditionInput =
+  PreconditionConfigOf<NativeBalancePreconditionConfig>;
+
+/** Assert that a wallet holds at least a given native coin balance */
+export const nativeBalance = (
+  config: NativeBalancePreconditionInput,
+): Precondition => ({
+  type: 'NativeBalance',
+  ...config,
+});
+
+export type Erc20AllowancePreconditionInput =
+  PreconditionConfigOf<Erc20AllowancePreconditionConfig>;
+
+/** Assert that an ERC-20 allowance is at least a given amount */
+export const erc20Allowance = (
+  config: Erc20AllowancePreconditionInput,
+): Precondition => ({
+  type: 'Erc20Allowance',
+  ...config,
+});