@lifi/composer-sdk 0.2.0-staging.3 → 0.2.0-staging.5

package/src/examples/staged/registry.ts

@@ -0,0 +1,80 @@
+// Registry of staged (not-yet-prod) examples for the live runner. This is data,
+// not a runner: src/examples/run.ts imports it via a non-literal dynamic import
+// when invoked with `--staged`, so this file (which references staged definitions)
+// is never pulled into the production type-check. It IS type-checked under
+// tsconfig.staged.json (see verify:staged).
+//
+// Running these requires the SDK regenerated with `--staged`; the example:staged
+// wrapper does that and restores production afterward.
+import type { ComposeCompileRequest } from '@lifi/compose-spec';
+
+import { OWNER, RECIPIENT } from '../config.js';
+
+import { buildAaveBorrow } from './aaveBorrow.js';
+import { buildAaveDebtRebalanceExactOut } from './aaveDebtRebalanceExactOut.js';
+import { buildAaveHealthFactorExplode } from './aaveHealthFactorExplode.js';
+import { buildAaveToMorphoDebtMigration } from './aaveToMorphoDebtMigration.js';
+import { buildAaveToMorphoDebtMigrationWithSwap } from './aaveToMorphoDebtMigrationWithSwap.js';
+import { buildAaveToMorphoDebtMigrationWithSwapExactOut } from './aaveToMorphoDebtMigrationWithSwapExactOut.js';
+import { buildTrivialFlashloanRepay } from './flashloanRepay.js';
+import { buildMorphoBlueBorrow } from './morphoBlueBorrow.js';
+import { buildMorphoBlueRepay } from './morphoBlueRepay.js';
+
+export const STAGED_EXAMPLES: Record<string, () => ComposeCompileRequest> = {
+  'aave-borrow': () =>
+    buildAaveBorrow({
+      owner: OWNER,
+      recipient: RECIPIENT,
+      collateralAmount: '1000000000',
+      borrowAmount: '500000000',
+    }).request,
+  'aave-hf-explode': () =>
+    buildAaveHealthFactorExplode({ signer: OWNER }).request,
+  'morpho-borrow': () =>
+    buildMorphoBlueBorrow({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      borrowAmount: '1200000000',
+    }).request,
+  'morpho-repay': () =>
+    buildMorphoBlueRepay({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      borrowAmount: '500000000',
+      repayAmount: '501000000',
+    }).request,
+  'debt-rebalance': () =>
+    buildAaveDebtRebalanceExactOut({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      debtAmount: '1000000000',
+      newDebtBorrowAmount: '965000000',
+    }).request,
+  'debt-migration-swap-exact-out': () =>
+    buildAaveToMorphoDebtMigrationWithSwapExactOut({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      debtAmount: '1000000000',
+      morphoBorrowAmount: '975000000',
+    }).request,
+  'flashloan-repay': () =>
+    buildTrivialFlashloanRepay({
+      owner: OWNER,
+      amount: '10000000000',
+      fee: '5000000',
+    }).request,
+  'debt-migration': () =>
+    buildAaveToMorphoDebtMigration({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      debtAmount: '1000000000',
+      debtFlashloanFee: '500000',
+    }).request,
+  'debt-migration-swap': () =>
+    buildAaveToMorphoDebtMigrationWithSwap({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      debtAmount: '1000000000',
+      morphoBorrowAmount: '1100000000',
+    }).request,
+};

package/src/examples/untypedOpWithTypedRef.ts

@@ -1,25 +1,32 @@
 import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
 
-import { createComposeSdk, materialisers, raw, resources } from '../index.js';
+import { createComposeSdk, raw } from '../index.js';
 import type { Address } from '../types.js';
 
 import { BASE_URL } from './config.js';
 
-const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
-// Example custom vault that the typed builder doesn't cover yet
-const CUSTOM_VAULT = '0x1111111111111111111111111111111111111111';
+// Real ERC-4626 vault (Steakhouse USDC on Ethereum mainnet) queried through
+// the untyped escape hatch.
+const VAULT = '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB';
 
 export interface UntypedOpWithTypedRefInput {
   readonly owner: Address;
 }
 
 /**
- * Insert an untyped operation node for an unsupported operation, then feed
- * its output into typed builder methods using `raw.ref<T>()`.
+ * Insert an untyped operation node, then feed its output into typed builder
+ * methods using `raw.ref<T>()`.
+ *
+ * `untypedOp` is the escape hatch for ops the installed SDK's typed surface
+ * doesn't cover — typically backend ops newer than your SDK version. The op
+ * id is passed as a plain string and its bind/config shapes are not
+ * type-checked, so the backend validates them at compile time instead.
+ *
+ * This example routes a real op (`core.staticCall`) through the untyped path
+ * so the flow compiles end-to-end; the mechanism is identical for any op id.
  *
  * Demonstrates:
- * - `builder.untypedOp()` to add a node the typed API doesn't cover
- *   (e.g. a custom vault query).
+ * - `builder.untypedOp()` to add a node the typed API doesn't cover.
  * - `raw.ref<'uint256'>()` to reference the untyped node's output in a typed
  *   `Bindable<'uint256'>` slot — the explicit type parameter is required
  *   so the compiler verifies the ref is used in a compatible slot.
@@ -35,16 +42,17 @@ export const buildUntypedOpWithTypedRef = ({
 
   const builder = sdk.flow(1, {
     name: 'untyped-op-with-typed-ref',
-    inputs: {
-      amountIn: resources.erc20(USDC, 1),
-    },
+    inputs: {},
   });
 
-  // Insert an untyped node for a custom vault query. untypedOp returns void —
+  // Insert an untyped node querying the vault. untypedOp returns void —
   // the typed builder has no knowledge of this node's outputs.
-  builder.untypedOp('vault-query', 'custom.vaultQuery', {
-    bind: { amount: { $ref: 'input.amountIn' } },
-    config: { target: CUSTOM_VAULT },
+  builder.untypedOp('vault-query', 'core.staticCall', {
+    bind: {},
+    config: {
+      target: VAULT,
+      functionSignature: 'function totalAssets() view returns (uint256)',
+    },
   });
 
   // Use raw.ref to bridge the untyped node's output into a typed operation.
@@ -60,17 +68,15 @@ export const buildUntypedOpWithTypedRef = ({
 
   // Continue with fully typed operations downstream.
   builder.core.assertGte('check-min', {
-    bind: { a: scaled.result, b: builder.inputs.amountIn },
+    bind: { a: scaled.result, b: vaultResult },
   });
 
   const flow = builder.build();
 
+  // No sweepTo: the flow reads state and asserts — it produces no resources.
   const request = sdk.request(flow, {
     signer: owner,
-    inputs: {
-      amountIn: materialisers.directDeposit({ amount: '1000000' }),
-    },
-    sweepTo: builder.context.sender,
+    inputs: {},
   });
 
   return { flow, request };

package/src/generated/config.generated.ts

@@ -55,6 +55,40 @@ export interface LifiSwapConfig {
   };
 }
 
+export interface InvariantNumericConfig {
+  op: 'gte' | 'gt' | 'lte' | 'lt' | 'eq' | 'neq';
+  threshold: IntegerStringInput;
+}
+
+export interface InvariantNumericInRangeConfig {
+  min: IntegerStringInput;
+  max: IntegerStringInput;
+}
+
+export interface InvariantGteConfig {
+  threshold: IntegerStringInput;
+}
+
+export interface InvariantGtConfig {
+  threshold: IntegerStringInput;
+}
+
+export interface InvariantLteConfig {
+  threshold: IntegerStringInput;
+}
+
+export interface InvariantLtConfig {
+  threshold: IntegerStringInput;
+}
+
+export interface InvariantEqConfig {
+  threshold: IntegerStringInput;
+}
+
+export interface InvariantNeqConfig {
+  threshold: IntegerStringInput;
+}
+
 export interface CoreBpsDownConfig {
   bps: number;
 }
@@ -76,6 +110,22 @@ export interface CoreTransferConfig {
   amount?: IntegerStringInput;
 }
 
+export interface CoreEmitEvent1Config {
+  signature: string;
+}
+
+export interface CoreEmitEvent2Config {
+  signature: string;
+}
+
+export interface CoreEmitEvent3Config {
+  signature: string;
+}
+
+export interface CoreEmitEvent4Config {
+  signature: string;
+}
+
 export interface CoreCallConfig {
   target: Address;
   functionSignature: string;

package/src/generated/operations.generated.ts

@@ -30,11 +30,23 @@ import type {
   CoreBpsDownConfig,
   CoreBpsUpConfig,
   CoreCallConfig,
+  CoreEmitEvent1Config,
+  CoreEmitEvent2Config,
+  CoreEmitEvent3Config,
+  CoreEmitEvent4Config,
   CorePeekConfig,
   CoreRawCallConfig,
   CoreSplitConfig,
   CoreStaticCallConfig,
   CoreTransferConfig,
+  InvariantEqConfig,
+  InvariantGtConfig,
+  InvariantGteConfig,
+  InvariantLtConfig,
+  InvariantLteConfig,
+  InvariantNeqConfig,
+  InvariantNumericConfig,
+  InvariantNumericInRangeConfig,
   LifiFlashloanRepayConfig,
   LifiSwapConfig,
   LifiZapConfig,
@@ -84,6 +96,147 @@ export interface InvariantBalanceAtLeastArgs {
   readonly guards?: readonly TypedGuard<never>[];
 }
 
+/** Assert that an account holds exactly an expected token balance */
+export interface InvariantBalanceEqualsArgs {
+  readonly bind: {
+    readonly expectedAmount: Bindable<'resource'>;
+    readonly account: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that an account holds at most a maximum token balance */
+export interface InvariantBalanceAtMostArgs {
+  readonly bind: {
+    readonly maximumAmount: Bindable<'resource'>;
+    readonly account: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that an account's token balance is between a minimum and a maximum (inclusive) */
+export interface InvariantBalanceInRangeArgs {
+  readonly bind: {
+    readonly minimumAmount: Bindable<'resource'>;
+    readonly maximumAmount: Bindable<'uint256'>;
+    readonly account: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender is permitted to move at least a minimum allowance on behalf of an owner */
+export interface InvariantAllowanceAtLeastArgs {
+  readonly bind: {
+    readonly minimumAmount: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender's allowance on behalf of an owner exactly equals an expected amount */
+export interface InvariantAllowanceEqualsArgs {
+  readonly bind: {
+    readonly expectedAmount: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender is permitted to move at most a maximum allowance on behalf of an owner */
+export interface InvariantAllowanceAtMostArgs {
+  readonly bind: {
+    readonly maximumAmount: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender's allowance on behalf of an owner is between a minimum and a maximum (inclusive) */
+export interface InvariantAllowanceInRangeArgs {
+  readonly bind: {
+    readonly minimumAmount: Bindable<'resource'>;
+    readonly maximumAmount: Bindable<'uint256'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value satisfies a comparison against a constant threshold; reverts on violation */
+export interface InvariantNumericArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantNumericConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert min <= value <= max against constant bounds; reverts if outside the range */
+export interface InvariantNumericInRangeArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantNumericInRangeConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is greater than or equal to a constant threshold; reverts on violation */
+export interface InvariantGteArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantGteConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is strictly greater than a constant threshold; reverts on violation */
+export interface InvariantGtArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantGtConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is less than or equal to a constant threshold; reverts on violation */
+export interface InvariantLteArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantLteConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is strictly less than a constant threshold; reverts on violation */
+export interface InvariantLtArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantLtConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value equals a constant threshold; reverts on violation */
+export interface InvariantEqArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantEqConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value does not equal a constant threshold; reverts on violation */
+export interface InvariantNeqArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantNeqConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 /** Add two unsigned integers (a + b) */
 export interface CoreAddArgs {
   readonly bind: {
@@ -237,6 +390,48 @@ export interface CoreTransferArgs {
   readonly guards?: readonly TypedGuard<'transferred' | 'remainder'>[];
 }
 
+/** Emit a custom on-chain event carrying 1 32-byte payload value. The value becomes a non-indexed data word in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent1Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent1Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Emit a custom on-chain event carrying 2 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent2Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+    readonly value1: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent2Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Emit a custom on-chain event carrying 3 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent3Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+    readonly value1: Bindable<'bytes32'>;
+    readonly value2: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent3Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Emit a custom on-chain event carrying 4 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent4Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+    readonly value1: Bindable<'bytes32'>;
+    readonly value2: Bindable<'bytes32'>;
+    readonly value3: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent4Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 /** Invoke a smart contract function, optionally spending a token resource */
 export interface CoreCallArgs<TSig extends string = string> {
   readonly resource?: Bindable<'resource'>;
@@ -616,6 +811,14 @@ export type GeneratedOps = {
       nodeId: string,
       args: CoreTransferArgs,
     ) => CoreTransferOutputs;
+    /** Emit a custom on-chain event carrying 1 32-byte payload value. The value becomes a non-indexed data word in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent1" */
+    readonly emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) => void;
+    /** Emit a custom on-chain event carrying 2 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent2" */
+    readonly emitEvent2: (nodeId: string, args: CoreEmitEvent2Args) => void;
+    /** Emit a custom on-chain event carrying 3 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent3" */
+    readonly emitEvent3: (nodeId: string, args: CoreEmitEvent3Args) => void;
+    /** Emit a custom on-chain event carrying 4 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent4" */
+    readonly emitEvent4: (nodeId: string, args: CoreEmitEvent4Args) => void;
     /** Invoke a smart contract function, optionally spending a token resource — original id: "core.call" */
     readonly call: <TSig extends string>(
       nodeId: string,
@@ -656,6 +859,60 @@ export type GeneratedOps = {
       nodeId: string,
       args: InvariantBalanceAtLeastArgs,
     ) => void;
+    /** Assert that an account holds exactly an expected token balance — original id: "invariant.balanceEquals" */
+    readonly balanceEquals: (
+      nodeId: string,
+      args: InvariantBalanceEqualsArgs,
+    ) => void;
+    /** Assert that an account holds at most a maximum token balance — original id: "invariant.balanceAtMost" */
+    readonly balanceAtMost: (
+      nodeId: string,
+      args: InvariantBalanceAtMostArgs,
+    ) => void;
+    /** Assert that an account's token balance is between a minimum and a maximum (inclusive) — original id: "invariant.balanceInRange" */
+    readonly balanceInRange: (
+      nodeId: string,
+      args: InvariantBalanceInRangeArgs,
+    ) => void;
+    /** Assert that a spender is permitted to move at least a minimum allowance on behalf of an owner — original id: "invariant.allowanceAtLeast" */
+    readonly allowanceAtLeast: (
+      nodeId: string,
+      args: InvariantAllowanceAtLeastArgs,
+    ) => void;
+    /** Assert that a spender's allowance on behalf of an owner exactly equals an expected amount — original id: "invariant.allowanceEquals" */
+    readonly allowanceEquals: (
+      nodeId: string,
+      args: InvariantAllowanceEqualsArgs,
+    ) => void;
+    /** Assert that a spender is permitted to move at most a maximum allowance on behalf of an owner — original id: "invariant.allowanceAtMost" */
+    readonly allowanceAtMost: (
+      nodeId: string,
+      args: InvariantAllowanceAtMostArgs,
+    ) => void;
+    /** Assert that a spender's allowance on behalf of an owner is between a minimum and a maximum (inclusive) — original id: "invariant.allowanceInRange" */
+    readonly allowanceInRange: (
+      nodeId: string,
+      args: InvariantAllowanceInRangeArgs,
+    ) => void;
+    /** Assert a uint256 value satisfies a comparison against a constant threshold; reverts on violation — original id: "invariant.numeric" */
+    readonly numeric: (nodeId: string, args: InvariantNumericArgs) => void;
+    /** Assert min <= value <= max against constant bounds; reverts if outside the range — original id: "invariant.numericInRange" */
+    readonly numericInRange: (
+      nodeId: string,
+      args: InvariantNumericInRangeArgs,
+    ) => void;
+    /** Assert a uint256 value is greater than or equal to a constant threshold; reverts on violation — original id: "invariant.gte" */
+    readonly gte: (nodeId: string, args: InvariantGteArgs) => void;
+    /** Assert a uint256 value is strictly greater than a constant threshold; reverts on violation — original id: "invariant.gt" */
+    readonly gt: (nodeId: string, args: InvariantGtArgs) => void;
+    /** Assert a uint256 value is less than or equal to a constant threshold; reverts on violation — original id: "invariant.lte" */
+    readonly lte: (nodeId: string, args: InvariantLteArgs) => void;
+    /** Assert a uint256 value is strictly less than a constant threshold; reverts on violation — original id: "invariant.lt" */
+    readonly lt: (nodeId: string, args: InvariantLtArgs) => void;
+    /** Assert a uint256 value equals a constant threshold; reverts on violation — original id: "invariant.eq" */
+    readonly eq: (nodeId: string, args: InvariantEqArgs) => void;
+    /** Assert a uint256 value does not equal a constant threshold; reverts on violation — original id: "invariant.neq" */
+    readonly neq: (nodeId: string, args: InvariantNeqArgs) => void;
   };
   readonly aave: {
     /** Borrow an asset from an Aave v3 pool against existing collateral, exposing the borrowed asset as a Resource — original id: "aave.borrow" */
@@ -790,6 +1047,14 @@ export const bindGeneratedOps = (
         transferred: 'resource',
         remainder: 'resource',
       } as const),
+    emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) =>
+      builder.call(nodeId, 'core.emitEvent1', args, {}),
+    emitEvent2: (nodeId: string, args: CoreEmitEvent2Args) =>
+      builder.call(nodeId, 'core.emitEvent2', args, {}),
+    emitEvent3: (nodeId: string, args: CoreEmitEvent3Args) =>
+      builder.call(nodeId, 'core.emitEvent3', args, {}),
+    emitEvent4: (nodeId: string, args: CoreEmitEvent4Args) =>
+      builder.call(nodeId, 'core.emitEvent4', args, {}),
     call: <TSig extends string>(nodeId: string, args: CoreCallArgs<TSig>) => {
       const wire = buildCallWireFormat({
         resource: args.resource,
@@ -847,6 +1112,71 @@ export const bindGeneratedOps = (
         { ...args, config: {} },
         {},
       ),
+    balanceEquals: (nodeId: string, args: InvariantBalanceEqualsArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceEquals',
+        { ...args, config: {} },
+        {},
+      ),
+    balanceAtMost: (nodeId: string, args: InvariantBalanceAtMostArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceAtMost',
+        { ...args, config: {} },
+        {},
+      ),
+    balanceInRange: (nodeId: string, args: InvariantBalanceInRangeArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceInRange',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceAtLeast: (nodeId: string, args: InvariantAllowanceAtLeastArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceAtLeast',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceEquals: (nodeId: string, args: InvariantAllowanceEqualsArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceEquals',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceAtMost: (nodeId: string, args: InvariantAllowanceAtMostArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceAtMost',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceInRange: (nodeId: string, args: InvariantAllowanceInRangeArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceInRange',
+        { ...args, config: {} },
+        {},
+      ),
+    numeric: (nodeId: string, args: InvariantNumericArgs) =>
+      builder.call(nodeId, 'invariant.numeric', args, {}),
+    numericInRange: (nodeId: string, args: InvariantNumericInRangeArgs) =>
+      builder.call(nodeId, 'invariant.numericInRange', args, {}),
+    gte: (nodeId: string, args: InvariantGteArgs) =>
+      builder.call(nodeId, 'invariant.gte', args, {}),
+    gt: (nodeId: string, args: InvariantGtArgs) =>
+      builder.call(nodeId, 'invariant.gt', args, {}),
+    lte: (nodeId: string, args: InvariantLteArgs) =>
+      builder.call(nodeId, 'invariant.lte', args, {}),
+    lt: (nodeId: string, args: InvariantLtArgs) =>
+      builder.call(nodeId, 'invariant.lt', args, {}),
+    eq: (nodeId: string, args: InvariantEqArgs) =>
+      builder.call(nodeId, 'invariant.eq', args, {}),
+    neq: (nodeId: string, args: InvariantNeqArgs) =>
+      builder.call(nodeId, 'invariant.neq', args, {}),
   },
   aave: {
     borrow: (nodeId: string, args: AaveBorrowArgs) =>