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

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) =>