@boostxyz/sdk 6.1.2 → 7.0.0-canary.0

package/src/Incentives/{ERC20PeggedVariableCriteriaIncentive.ts → ERC20PeggedVariableCriteriaIncentiveV2.ts}

@@ -1,24 +1,24 @@
 import {
-  erc20PeggedVariableCriteriaIncentiveAbi,
-  readErc20PeggedVariableCriteriaIncentiveAsset,
-  readErc20PeggedVariableCriteriaIncentiveClaimed,
-  readErc20PeggedVariableCriteriaIncentiveClaims,
-  readErc20PeggedVariableCriteriaIncentiveCurrentReward,
-  readErc20PeggedVariableCriteriaIncentiveGetIncentiveCriteria,
-  readErc20PeggedVariableCriteriaIncentiveGetMaxReward,
-  readErc20PeggedVariableCriteriaIncentiveGetPeg,
-  readErc20PeggedVariableCriteriaIncentiveIsClaimable,
-  readErc20PeggedVariableCriteriaIncentiveLimit,
-  readErc20PeggedVariableCriteriaIncentiveOwner,
-  readErc20PeggedVariableCriteriaIncentivePeg,
-  readErc20PeggedVariableCriteriaIncentiveReward,
-  readErc20PeggedVariableCriteriaIncentiveTotalClaimed,
-  simulateErc20PeggedVariableCriteriaIncentiveClaim,
-  simulateErc20PeggedVariableCriteriaIncentiveClawback,
-  writeErc20PeggedVariableCriteriaIncentiveClaim,
-  writeErc20PeggedVariableCriteriaIncentiveClawback,
+  erc20PeggedVariableCriteriaIncentiveV2Abi,
+  readErc20PeggedVariableCriteriaIncentiveV2Asset,
+  readErc20PeggedVariableCriteriaIncentiveV2Claimed,
+  readErc20PeggedVariableCriteriaIncentiveV2Claims,
+  readErc20PeggedVariableCriteriaIncentiveV2CurrentReward,
+  readErc20PeggedVariableCriteriaIncentiveV2GetIncentiveCriteria,
+  readErc20PeggedVariableCriteriaIncentiveV2GetMaxReward,
+  readErc20PeggedVariableCriteriaIncentiveV2GetPeg,
+  readErc20PeggedVariableCriteriaIncentiveV2IsClaimable,
+  readErc20PeggedVariableCriteriaIncentiveV2Limit,
+  readErc20PeggedVariableCriteriaIncentiveV2Owner,
+  readErc20PeggedVariableCriteriaIncentiveV2Peg,
+  readErc20PeggedVariableCriteriaIncentiveV2Reward,
+  readErc20PeggedVariableCriteriaIncentiveV2TotalClaimed,
+  simulateErc20PeggedVariableCriteriaIncentiveV2Claim,
+  simulateErc20PeggedVariableCriteriaIncentiveV2Clawback,
+  writeErc20PeggedVariableCriteriaIncentiveV2Claim,
+  writeErc20PeggedVariableCriteriaIncentiveV2Clawback,
 } from '@boostxyz/evm';
-import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/ERC20PeggedVariableCriteriaIncentive.sol/ERC20PeggedVariableCriteriaIncentive.json';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/ERC20PeggedVariableCriteriaIncentiveV2.sol/ERC20PeggedVariableCriteriaIncentiveV2.json';
 import { getTransaction, getTransactionReceipt } from '@wagmi/core';
 import type { AbiEvent } from 'abitype';
 import {
@@ -34,7 +34,7 @@ import {
   zeroAddress,
   zeroHash,
 } from 'viem';
-import { ERC20PeggedVariableCriteriaIncentive as ERC20PeggedVariableCriteriaIncentiveBases } from '../../dist/deployments.json';
+import { ERC20PeggedVariableCriteriaIncentiveV2 as ERC20PeggedVariableCriteriaIncentiveV2Bases } from '../../dist/deployments.json';
 import { SignatureType } from '../Actions/EventAction';
 import type {
   DeployableOptions,
@@ -58,18 +58,18 @@ import {
 import type {
   GetIncentiveScalarParams,
   IncentiveCriteria,
-} from './ERC20VariableCriteriaIncentive';
+} from './ERC20VariableCriteriaIncentiveV2';
 
-export { erc20PeggedVariableCriteriaIncentiveAbi };
+export { erc20PeggedVariableCriteriaIncentiveV2Abi };
 
 /**
- * The object representation of a `Erc20PeggedVariableCriteriaIncentive.InitPayload`
+ * The object representation of a `Erc20PeggedVariableCriteriaIncentiveV2.InitPayload`
  *
  * @export
- * @interface Erc20PeggedVariableCriteriaIncentive
- * @typedef {Erc20PeggedVariableCriteriaIncentive}
+ * @interface Erc20PeggedVariableCriteriaIncentiveV2
+ * @typedef {Erc20PeggedVariableCriteriaIncentiveV2}
  */
-export interface ERC20PeggedVariableCriteriaIncentivePayload {
+export interface ERC20PeggedVariableCriteriaIncentiveV2Payload {
   /**
    * The address of the incentivized asset.
    *
@@ -116,33 +116,33 @@ export interface ERC20PeggedVariableCriteriaIncentivePayload {
 }
 
 /**
- * A generic `viem.Log` event with support for `Erc20PeggedVariableCriteriaIncentive` event types.
+ * A generic `viem.Log` event with support for `Erc20PeggedVariableCriteriaIncentiveV2` event types.
  *
  * @export
- * @typedef {Erc20PeggedVariableCriteriaIncentiveLog}
- * @template {ContractEventName<typeof erc20PeggedVariableCriteriaIncentiveAbi>} [event=ContractEventName<
- *     typeof erc20PeggedVariableCriteriaIncentiveAbi
+ * @typedef {Erc20PeggedVariableCriteriaIncentiveV2Log}
+ * @template {ContractEventName<typeof erc20PeggedVariableCriteriaIncentiveV2Abi>} [event=ContractEventName<
+ *     typeof erc20PeggedVariableCriteriaIncentiveV2Abi
  *   >]
  */
-export type Erc20PeggedVariableCriteriaIncentiveLog<
+export type Erc20PeggedVariableCriteriaIncentiveV2Log<
   event extends ContractEventName<
-    typeof erc20PeggedVariableCriteriaIncentiveAbi
-  > = ContractEventName<typeof erc20PeggedVariableCriteriaIncentiveAbi>,
-> = GenericLog<typeof erc20PeggedVariableCriteriaIncentiveAbi, event>;
+    typeof erc20PeggedVariableCriteriaIncentiveV2Abi
+  > = ContractEventName<typeof erc20PeggedVariableCriteriaIncentiveV2Abi>,
+> = GenericLog<typeof erc20PeggedVariableCriteriaIncentiveV2Abi, event>;
 
 /**
  * A simple ERC20 incentive implementation that allows claiming of tokens
  *
  * @export
  * @class Erc20PeggedVariableCriteriaIncentive
- * @typedef {ERC20PeggedVariableCriteriaIncentive}
- * @extends {DeployableTarget<ERC20PeggedVariableCriteriaIncentive>}
+ * @typedef {ERC20PeggedVariableCriteriaIncentiveV2}
+ * @extends {DeployableTarget<ERC20PeggedVariableCriteriaIncentiveV2>}
  */
-export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
-  ERC20PeggedVariableCriteriaIncentivePayload,
-  typeof erc20PeggedVariableCriteriaIncentiveAbi
+export class ERC20PeggedVariableCriteriaIncentiveV2 extends DeployableTarget<
+  ERC20PeggedVariableCriteriaIncentiveV2Payload,
+  typeof erc20PeggedVariableCriteriaIncentiveV2Abi
 > {
-  public override readonly abi = erc20PeggedVariableCriteriaIncentiveAbi;
+  public override readonly abi = erc20PeggedVariableCriteriaIncentiveV2Abi;
   /**
    * @inheritdoc
    *
@@ -151,8 +151,9 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_ERC20_INCENTIVE_BASE,
-    ...(ERC20PeggedVariableCriteriaIncentiveBases as Record<number, Address>),
+    31337: import.meta.env
+      .VITE_ERC20_PEGGED_VARIABLE_CRITERIA_INCENTIVE_V2_BASE,
+    ...(ERC20PeggedVariableCriteriaIncentiveV2Bases as Record<number, Address>),
   };
   /**
    * @inheritdoc
@@ -172,7 +173,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<Address>}
    */
   public async owner(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveOwner(this._config, {
+    return await readErc20PeggedVariableCriteriaIncentiveV2Owner(this._config, {
       address: this.assertValidAddress(),
       args: [],
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -189,7 +190,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<bigint>} - The current reward
    */
   public async currentReward(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveCurrentReward(
+    return await readErc20PeggedVariableCriteriaIncentiveV2CurrentReward(
       this._config,
       {
         address: this.assertValidAddress(),
@@ -210,10 +211,13 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    */
   public async getMaxReward(params?: ReadParams): Promise<bigint> {
     const maxReward =
-      await readErc20PeggedVariableCriteriaIncentiveGetMaxReward(this._config, {
-        ...params,
-        address: this.assertValidAddress(),
-      });
+      await readErc20PeggedVariableCriteriaIncentiveV2GetMaxReward(
+        this._config,
+        {
+          ...params,
+          address: this.assertValidAddress(),
+        },
+      );
 
     return maxReward;
   }
@@ -320,12 +324,15 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<bigint>}
    */
   public async claims(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveClaims(this._config, {
-      address: this.assertValidAddress(),
-      args: [],
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
+    return await readErc20PeggedVariableCriteriaIncentiveV2Claims(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [],
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
   }
 
   /**
@@ -337,7 +344,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<bigint>}
    */
   public async totalClaimed(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveTotalClaimed(
+    return await readErc20PeggedVariableCriteriaIncentiveV2TotalClaimed(
       this._config,
       {
         address: this.assertValidAddress(),
@@ -358,12 +365,15 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<boolean>}
    */
   public async claimed(address: Address, params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveClaimed(this._config, {
-      address: this.assertValidAddress(),
-      args: [address],
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
+    return await readErc20PeggedVariableCriteriaIncentiveV2Claimed(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [address],
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
   }
 
   /**
@@ -375,7 +385,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<Address>}
    */
   public async asset(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveAsset(this._config, {
+    return await readErc20PeggedVariableCriteriaIncentiveV2Asset(this._config, {
       address: this.assertValidAddress(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
       ...(params as any),
@@ -391,7 +401,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<Address>}
    */
   public async peg(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentivePeg(this._config, {
+    return await readErc20PeggedVariableCriteriaIncentiveV2Peg(this._config, {
       address: this.assertValidAddress(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
       ...(params as any),
@@ -407,11 +417,14 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<bigint>}
    */
   public async reward(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveReward(this._config, {
-      address: this.assertValidAddress(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
+    return await readErc20PeggedVariableCriteriaIncentiveV2Reward(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
   }
 
   /**
@@ -423,7 +436,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<bigint>}
    */
   public async limit(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveLimit(this._config, {
+    return await readErc20PeggedVariableCriteriaIncentiveV2Limit(this._config, {
       address: this.assertValidAddress(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
       ...(params as any),
@@ -454,14 +467,14 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    */
   protected async claimRaw(payload: ClaimPayload, params?: WriteParams) {
     const { request, result } =
-      await simulateErc20PeggedVariableCriteriaIncentiveClaim(this._config, {
+      await simulateErc20PeggedVariableCriteriaIncentiveV2Claim(this._config, {
         address: this.assertValidAddress(),
         args: [prepareClaimPayload(payload)],
         ...this.optionallyAttachAccount(),
         // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
         ...(params as any),
       });
-    const hash = await writeErc20PeggedVariableCriteriaIncentiveClaim(
+    const hash = await writeErc20PeggedVariableCriteriaIncentiveV2Claim(
       this._config,
       request,
     );
@@ -492,14 +505,17 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    */
   public async clawbackRaw(payload: ClaimPayload, params?: WriteParams) {
     const { request, result } =
-      await simulateErc20PeggedVariableCriteriaIncentiveClawback(this._config, {
-        address: this.assertValidAddress(),
-        args: [prepareClaimPayload(payload)],
-        ...this.optionallyAttachAccount(),
-        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-        ...(params as any),
-      });
-    const hash = await writeErc20PeggedVariableCriteriaIncentiveClawback(
+      await simulateErc20PeggedVariableCriteriaIncentiveV2Clawback(
+        this._config,
+        {
+          address: this.assertValidAddress(),
+          args: [prepareClaimPayload(payload)],
+          ...this.optionallyAttachAccount(),
+          // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+          ...(params as any),
+        },
+      );
+    const hash = await writeErc20PeggedVariableCriteriaIncentiveV2Clawback(
       this._config,
       request,
     );
@@ -516,7 +532,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<boolean>} = True if the incentive is claimable based on the data payload
    */
   public async isClaimable(payload: ClaimPayload, params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveIsClaimable(
+    return await readErc20PeggedVariableCriteriaIncentiveV2IsClaimable(
       this._config,
       {
         address: this.assertValidAddress(),
@@ -536,12 +552,15 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Promise<Address>} = The address of the token the reward is pegged to
    */
   public async getPeg(params?: ReadParams) {
-    return await readErc20PeggedVariableCriteriaIncentiveGetPeg(this._config, {
-      address: this.assertValidAddress(),
-      args: [],
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
+    return await readErc20PeggedVariableCriteriaIncentiveV2GetPeg(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [],
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
   }
 
   /**
@@ -600,7 +619,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
   ): Promise<IncentiveCriteria> {
     try {
       const criteria =
-        await readErc20PeggedVariableCriteriaIncentiveGetIncentiveCriteria(
+        await readErc20PeggedVariableCriteriaIncentiveV2GetIncentiveCriteria(
           this._config,
           {
             ...params,
@@ -624,7 +643,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @returns {Hex} The ABI-encoded payload with the updated `limit`.
    */
   public async getTopupPayload(netAmount: bigint): Promise<Hex> {
-    return prepareERC20PeggedVariableCriteriaIncentivePayload({
+    return prepareERC20PeggedVariableCriteriaIncentiveV2Payload({
       asset: (await this.asset()) ?? zeroAddress,
       peg: this.payload?.peg ?? zeroAddress,
       reward: this.payload?.reward ?? 0n,
@@ -636,6 +655,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
         signature: zeroHash,
         fieldIndex: 0,
         targetContract: zeroAddress,
+        valueType: 0,
       },
     });
   }
@@ -644,12 +664,12 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @inheritdoc
    *
    * @public
-   * @param {?ERC20PeggedVariableCriteriaIncentivePayload} [_payload]
+   * @param {?ERC20PeggedVariableCriteriaIncentiveV2Payload} [_payload]
    * @param {?DeployableOptions} [_options]
    * @returns {GenericDeployableParams}
    */
   public override buildParameters(
-    _payload?: ERC20PeggedVariableCriteriaIncentivePayload,
+    _payload?: ERC20PeggedVariableCriteriaIncentiveV2Payload,
     _options?: DeployableOptions,
   ): GenericDeployableParams {
     const [payload, options] = this.validateDeploymentConfig(
@@ -657,9 +677,9 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
       _options,
     );
     return {
-      abi: erc20PeggedVariableCriteriaIncentiveAbi,
+      abi: erc20PeggedVariableCriteriaIncentiveV2Abi,
       bytecode: bytecode as Hex,
-      args: [prepareERC20PeggedVariableCriteriaIncentivePayload(payload)],
+      args: [prepareERC20PeggedVariableCriteriaIncentiveV2Payload(payload)],
       ...this.optionallyAttachAccount(options.account),
     };
   }
@@ -681,7 +701,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * @public
    * @param {bigint} signedAmount
    * @returns {Hash} Returns the encoded claim data
-   * @description This function returns the encoded claim data for the ERC20PeggedVariableCriteriaIncentivePayload.
+   * @description This function returns the encoded claim data for the ERC20PeggedVariableCriteriaIncentiveV2Payload.
    */
   public buildClaimData(signedAmount: bigint) {
     return encodeAbiParameters(
@@ -691,12 +711,12 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
   }
 
   /**
-   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentive, returning the claim amount.
+   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentiveV2, returning the claim amount.
    * Useful when deriving amount claimed from logs.
    *
    * @public
    * @param {Hex} claimData
-   * @returns {BigInt} Returns the reward amount from a claim data payload
+   * @returns {Promise<bigint>} Returns the reward amount from a claim data payload
    */
   public async decodeClaimData(claimData: Hex) {
     const boostClaimData = decodeAbiParameters(
@@ -736,7 +756,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
   }
 
   /**
-   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentive, returning the claim amount.
+   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentiveV2, returning the claim amount.
    * Useful when deriving amount claimed from logs.
    * Use this function instead of `decodeClaimData` if you have reward details.
    *
@@ -785,9 +805,9 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
 }
 
 /**
- * Given a {@link ERC20PeggedVariableCriteriaIncentivePayload}, properly encode a `ERC20PeggedVariableCriteriaIncentivePayload.InitPayload` for use with {@link ERC20PeggedVariableCriteriaIncentivePayload} initialization.
+ * Given a {@link ERC20PeggedVariableCriteriaIncentiveV2Payload}, properly encode a `ERC20PeggedVariableCriteriaIncentiveV2Payload.InitPayload` for use with {@link ERC20PeggedVariableCriteriaIncentiveV2Payload} initialization.
  *
- * @param {ERC20PeggedVariableCriteriaIncentivePayload} param0
+ * @param {ERC20PeggedVariableCriteriaIncentiveV2Payload} param0
  * @param {Address} param0.asset - The address of the incentivized asset.
  * @param {Address} param0.peg - The peg to normalize to.
  * @param {bigint} param0.reward - The amount of the asset to distribute.
@@ -796,7 +816,7 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
  * @param {IncentiveCriteria} param0.criteria - The incentive criteria for reward distribution.
  * @returns {Hex}
  */
-export function prepareERC20PeggedVariableCriteriaIncentivePayload({
+export function prepareERC20PeggedVariableCriteriaIncentiveV2Payload({
   asset,
   peg,
   reward,
@@ -804,7 +824,7 @@ export function prepareERC20PeggedVariableCriteriaIncentivePayload({
   maxReward = 0n,
   manager = zeroAddress,
   criteria,
-}: ERC20PeggedVariableCriteriaIncentivePayload) {
+}: ERC20PeggedVariableCriteriaIncentiveV2Payload) {
   return encodeAbiParameters(
     [
       {
@@ -825,6 +845,7 @@ export function prepareERC20PeggedVariableCriteriaIncentivePayload({
               { type: 'bytes32', name: 'signature' },
               { type: 'uint8', name: 'fieldIndex' },
               { type: 'address', name: 'targetContract' },
+              { type: 'uint8', name: 'valueType' },
             ],
           },
         ],
@@ -843,6 +864,7 @@ export function prepareERC20PeggedVariableCriteriaIncentivePayload({
           signature: criteria.signature,
           fieldIndex: criteria.fieldIndex,
           targetContract: criteria.targetContract,
+          valueType: criteria.valueType,
         },
       },
     ],

package/src/Incentives/{ERC20VariableCriteriaIncentive.test.ts → ERC20VariableCriteriaIncentiveV2.test.ts}

@@ -23,14 +23,14 @@ import {
   zeroHash,
 } from "viem";
 import { beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { SignatureType } from "../Actions/EventAction";
+import { SignatureType, ValueType } from "../Actions/EventAction";
 import type { Boost } from "../Boost";
 import {
-  type ERC20VariableCriteriaIncentive,
-  type ERC20VariableCriteriaIncentivePayload,
+  type ERC20VariableCriteriaIncentiveV2,
+  type ERC20VariableCriteriaIncentiveV2Payload,
   type IncentiveCriteria,
   gasRebateIncentiveCriteria,
-} from "./ERC20VariableCriteriaIncentive";
+} from "./ERC20VariableCriteriaIncentiveV2";
 import { allKnownSignatures } from "@boostxyz/test/allKnownSignatures";
 
 /**
@@ -47,6 +47,7 @@ export function basicErc721TransferScalarCriteria(
     signature: funcSelectors["transferFrom(address,address,uint256)"] as Hex, // Function selector for mint
     fieldIndex: 2, // Field where the scalar value resides
     targetContract: erc721.assertValidAddress(),
+    valueType: ValueType.WAD,
   };
 }
 
@@ -66,6 +67,7 @@ export function basicErc721MintScalarCriteria(
     ] as Hex, // Function selector for mint
     fieldIndex: 2, // Field where the scalar value resides
     targetContract: erc721.assertValidAddress(),
+    valueType: ValueType.WAD,
   };
 }
 
@@ -77,7 +79,7 @@ export function basicErc721MintScalarCriteria(
  */
 export function basicErc721TransferScalarPayload(
   erc721: MockERC721,
-): ERC20VariableCriteriaIncentivePayload {
+): ERC20VariableCriteriaIncentiveV2Payload {
   return {
     asset: erc721.assertValidAddress(),
     reward: 1n,
@@ -90,11 +92,11 @@ export function basicErc721TransferScalarPayload(
 let fixtures: Fixtures,
   erc20: MockERC20,
   erc721: MockERC721,
-  erc20Incentive: ERC20VariableCriteriaIncentive,
+  erc20Incentive: ERC20VariableCriteriaIncentiveV2,
   budgets: BudgetFixtures,
   boost: Boost;
 
-describe("ERC20VariableCriteriaIncentive", () => {
+describe("ERC20VariableCriteriaIncentiveV2", () => {
   beforeAll(async () => {
     fixtures = await loadFixture(deployFixtures(defaultOptions));
   });
@@ -103,7 +105,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
     budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
     erc20 = await loadFixture(fundErc20(defaultOptions));
     erc721 = await loadFixture(fundErc721(defaultOptions));
-    erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentive({
+    erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentiveV2({
       asset: budgets.erc20.assertValidAddress(),
       reward: 1n,
       limit: 1n,
@@ -119,13 +121,14 @@ describe("ERC20VariableCriteriaIncentive", () => {
 
   describe("getIncentiveCriteria", () => {
     test("should fetch incentive criteria successfully", async () => {
-      const incentive = boost.incentives[0] as ERC20VariableCriteriaIncentive;
+      const incentive = boost.incentives[0] as ERC20VariableCriteriaIncentiveV2;
       const criteria = await incentive.getIncentiveCriteria();
       expect(criteria).toMatchObject({
         criteriaType: SignatureType.FUNC,
         signature: expect.any(String),
         fieldIndex: expect.any(Number),
         targetContract: expect.any(String),
+        valueType: expect.any(Number),
       });
     });
   });
@@ -149,7 +152,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
     });
 
     test("should return a valid scalar for event-based criteria", async () => {
-      erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentive({
+      erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentiveV2({
         asset: budgets.erc20.assertValidAddress(),
         reward: 1n,
         limit: 1n,
@@ -180,7 +183,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
       // Ensure that the gasRebateIncentiveCriteria returns the correct structure
       const gasRebateCriteria = gasRebateIncentiveCriteria();
 
-      erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentive({
+      erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentiveV2({
         asset: budgets.erc20.assertValidAddress(),
         reward: 1n,
         limit: 1n,
@@ -194,6 +197,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
         signature: zeroHash,
         fieldIndex: 255,
         targetContract: zeroAddress,
+        valueType: ValueType.WAD,
       });
 
       boost = await freshBoost(fixtures, {
@@ -203,12 +207,13 @@ describe("ERC20VariableCriteriaIncentive", () => {
 
       // Validate that the deployed incentive has the correct criteria set up
       const deployedIncentive = (await boost
-        .incentives[0]) as ERC20VariableCriteriaIncentive;
+        .incentives[0]) as ERC20VariableCriteriaIncentiveV2;
       const deployedCriteria = await deployedIncentive.getIncentiveCriteria();
       expect(deployedCriteria.criteriaType).toBe(SignatureType.EVENT);
       expect(deployedCriteria.signature).toBe(zeroHash);
       expect(deployedCriteria.fieldIndex).toBe(255);
       expect(deployedCriteria.targetContract).toBe(zeroAddress);
+      expect(deployedCriteria.valueType).toBe(ValueType.WAD);
     });
 
     test("should throw NoMatchingLogsError for event criteria with no matching logs", async () => {
@@ -245,7 +250,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
 
   test("can properly encode a uint256", () => {
     //@ts-ignore
-    const incentive = fixtures.core.ERC20VariableCriteriaIncentive();
+    const incentive = fixtures.core.ERC20VariableCriteriaIncentiveV2();
     expect(incentive.buildClawbackData(1n)).toBe(
       "0x0000000000000000000000000000000000000000000000000000000000000001",
     );