@boostxyz/sdk 0.0.0-alpha.8 → 1.1.0-alpha.22

package/src/Incentives/ERC20VariableIncentive.ts

@@ -15,25 +15,60 @@ import {
   writeErc20VariableIncentiveClawback,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/ERC20VariableIncentive.sol/ERC20VariableIncentive.json';
-import type { Address, ContractEventName, Hex } from 'viem';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+} from 'viem';
+import { ERC20VariableIncentive as ERC20VariableIncentiveBases } from '../../dist/deployments.json';
 import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { type ClaimPayload, prepareClaimPayload } from '../claiming';
 import {
-  type ClaimPayload,
-  type ERC20VariableIncentivePayload,
   type GenericLog,
   type ReadParams,
   RegistryType,
   type WriteParams,
-  prepareClaimPayload,
-  prepareERC20VariableIncentivePayload,
 } from '../utils';
 
 export { erc20VariableIncentiveAbi };
-export type { ERC20VariableIncentivePayload };
+/**
+ * The object representation of a `ERC20VariableIncentivePayload.InitPayload`
+ *
+ * @export
+ * @interface ERC20VariableIncentivePayload
+ * @typedef {ERC20VariableIncentivePayload}
+ */
+export interface ERC20VariableIncentivePayload {
+  /**
+   * The address of the incentivized asset.
+   *
+   * @type {Address}
+   */
+  asset: Address;
+  /**
+   * The amount of the asset to distribute.
+   *
+   * @type {bigint}
+   */
+  reward: bigint;
+  /**
+   * The total spending limit of the asset that will be distributed.
+   *
+   * @type {bigint}
+   */
+  limit: bigint;
+  /**
+   * The entity that can `clawback` funds
+   *
+   * @type {Address}
+   */
+  manager: Address;
+}
 
 /**
  * A generic `viem.Log` event with support for `ERC20VariableIncentive` event types.
@@ -51,7 +86,7 @@ export type ERC20VariableIncentiveLog<
 > = GenericLog<typeof erc20VariableIncentiveAbi, event>;
 
 /**
- * A simple ERC20 incentive implementation that allows claiming of tokens
+ *  A modified ERC20 incentive implementation that allows claiming of variable token amounts with a spending limit
  *
  * @export
  * @class ERC20VariableIncentive
@@ -68,10 +103,11 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @static
-   * @type {Address}
+   * @type {Record<number, Address>}
    */
-  public static override base: Address = import.meta.env
-    .VITE_ERC20_VARIABLE_INCENTIVE_BASE;
+  public static override bases: Record<number, Address> = {
+    ...(ERC20VariableIncentiveBases as Record<number, Address>),
+  };
   /**
    * @inheritdoc
    *
@@ -86,13 +122,13 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'owner'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>}
    */
   public async owner(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'owner'>,
   ) {
-    return readErc20VariableIncentiveOwner(this._config, {
+    return await readErc20VariableIncentiveOwner(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
@@ -101,17 +137,17 @@ export class ERC20VariableIncentive extends DeployableTarget<
   }
 
   /**
-   * The current reward
+   * The total amount of rewards claimed
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>} [params]
-   * @returns {Promise<bigint>} - The current reward
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public async totalClaimed(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'totalClaimed'>,
   ) {
-    return readErc20VariableIncentiveTotalClaimed(this._config, {
+    return await readErc20VariableIncentiveTotalClaimed(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
@@ -124,13 +160,13 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The current reward
    */
   public async currentReward(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>,
   ) {
-    return readErc20VariableIncentiveCurrentReward(this._config, {
+    return await readErc20VariableIncentiveCurrentReward(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
@@ -143,13 +179,13 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'claims'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async claims(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'claims'>,
   ) {
-    return readErc20VariableIncentiveClaims(this._config, {
+    return await readErc20VariableIncentiveClaims(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
@@ -163,14 +199,14 @@ export class ERC20VariableIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {Address} address
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'claimed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>}
    */
   public async claimed(
     address: Address,
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'claimed'>,
   ) {
-    return readErc20VariableIncentiveClaimed(this._config, {
+    return await readErc20VariableIncentiveClaimed(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
@@ -183,13 +219,13 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'asset'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>}
    */
   public async asset(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'asset'>,
   ) {
-    return readErc20VariableIncentiveAsset(this._config, {
+    return await readErc20VariableIncentiveAsset(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),
@@ -201,13 +237,13 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'reward'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async reward(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'reward'>,
   ) {
-    return readErc20VariableIncentiveReward(this._config, {
+    return await readErc20VariableIncentiveReward(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),
@@ -219,13 +255,13 @@ export class ERC20VariableIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'limit'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public async limit(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'limit'>,
   ) {
-    return readErc20VariableIncentiveLimit(this._config, {
+    return await readErc20VariableIncentiveLimit(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),
@@ -238,14 +274,14 @@ export class ERC20VariableIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - Returns true if successfully claimed
    */
-  public async claim(
+  protected async claim(
     payload: ClaimPayload,
     params?: WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>,
   ) {
-    return this.awaitResult(this.claimRaw(payload, params));
+    return await this.awaitResult(this.claimRaw(payload, params));
   }
 
   /**
@@ -254,10 +290,10 @@ export class ERC20VariableIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>} [params]
-   * @returns {Promise<boolean>} - Returns true if successfully claimed
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - Returns true if successfully claimed
    */
-  public async claimRaw(
+  protected async claimRaw(
     payload: ClaimPayload,
     params?: WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>,
   ) {
@@ -281,14 +317,14 @@ export class ERC20VariableIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
    */
   public async clawback(
     payload: ClaimPayload,
     params?: WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>,
   ) {
-    return this.awaitResult(this.clawbackRaw(payload, params));
+    return await this.awaitResult(this.clawbackRaw(payload, params));
   }
 
   /**
@@ -297,8 +333,8 @@ export class ERC20VariableIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>} [params]
-   * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} -  True if the assets were successfully clawbacked
    */
   public async clawbackRaw(
     payload: ClaimPayload,
@@ -327,14 +363,14 @@ export class ERC20VariableIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'isClaimable'>} [params]
-   * @returns {unknown} = True if the incentive is claimable based on the data payload
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} = True if the incentive is claimable based on the data payload
    */
   public async isClaimable(
     payload: ClaimPayload,
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'isClaimable'>,
   ) {
-    return readErc20VariableIncentiveIsClaimable(this._config, {
+    return await readErc20VariableIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -342,6 +378,21 @@ export class ERC20VariableIncentive extends DeployableTarget<
     });
   }
 
+  /**
+   * Builds the claim data for the ERC20VariableIncentive.
+   *
+   * @public
+   * @param {bigint} rewardAmount
+   * @returns {Hex} Returns the encoded claim data
+   * @description This function returns the encoded claim data for the ERC20VariableIncentive.
+   */
+  public buildClaimData(rewardAmount: bigint) {
+    return encodeAbiParameters(
+      [{ type: 'uint256', name: 'rewardAmount' }],
+      [rewardAmount],
+    );
+  }
+
   /**
    * @inheritdoc
    *
@@ -366,3 +417,27 @@ export class ERC20VariableIncentive extends DeployableTarget<
     };
   }
 }
+
+/**
+ * Given a {@link ERC20VariableIncentivePayload}, properly encode a ` ERC20VariableIncentive.InitPayload` for use with {@link ERC20VariableIncentive} initialization.
+ *
+ * @param {ERC20VariableIncentivePayload} param0
+ * @param {Address} param0.asset - The address of the incentivized asset.
+ * @param {bigint} param0.reward - The amount of the asset to distribute.
+ * @param {bigint} param0.limit - How many times can this incentive be claimed.
+ * @returns {Hex}
+ */
+export function prepareERC20VariableIncentivePayload({
+  asset,
+  reward,
+  limit,
+}: ERC20VariableIncentivePayload) {
+  return encodeAbiParameters(
+    [
+      { type: 'address', name: 'asset' },
+      { type: 'uint256', name: 'reward' },
+      { type: 'uint256', name: 'limit' },
+    ],
+    [asset, reward, limit],
+  );
+}

package/src/Incentives/Incentive.test.ts

@@ -1,7 +1,7 @@
 import { zeroAddress } from 'viem';
 import { describe, expect, test } from 'vitest';
-import { defaultOptions } from '../../test/helpers';
-import { StrategyType } from '../utils';
+import { defaultOptions } from '@boostxyz/test/helpers';
+import { StrategyType } from '../claiming';
 import {
   AllowListIncentive,
   CGDAIncentive,
@@ -49,6 +49,7 @@ describe('Incentive', () => {
       totalBudget: 10n,
       rewardBoost: 1n,
       rewardDecay: 1n,
+      manager: zeroAddress,
     });
     await incentive.deploy();
     expect(
@@ -65,6 +66,7 @@ describe('Incentive', () => {
       strategy: StrategyType.POOL,
       reward: 1n,
       limit: 10n,
+      manager: zeroAddress,
     });
     await incentive.deploy();
     expect(
@@ -80,6 +82,7 @@ describe('Incentive', () => {
       asset: zeroAddress,
       reward: 1n,
       limit: 10n,
+      manager: zeroAddress,
     });
     await incentive.deploy();
     expect(

package/src/Incentives/Incentive.ts

@@ -13,6 +13,7 @@ import { InvalidComponentInterfaceError } from '../errors';
 import { AllowListIncentive } from './AllowListIncentive';
 import { CGDAIncentive } from './CGDAIncentive';
 import { ERC20Incentive } from './ERC20Incentive';
+import type { ERC20VariableCriteriaIncentive } from './ERC20VariableCriteriaIncentive';
 import { ERC20VariableIncentive } from './ERC20VariableIncentive';
 // import { ERC1155Incentive } from './ERC1155Incentive';
 import { PointsIncentive } from './PointsIncentive';
@@ -38,19 +39,19 @@ export type Incentive =
   | ERC20Incentive
   // | ERC1155Incentive
   | PointsIncentive
-  | ERC20VariableIncentive;
+  | ERC20VariableIncentive
+  | ERC20VariableCriteriaIncentive;
 
 /**
  * A map of Incentive component interfaces to their constructors.
  *
- * @type {{ "0xc5b24b8e": typeof PointsIncentive; "0x8c901437": typeof ERC20Incentive; "0x0a466e6f": typeof AllowListIncentive; "0xa39e44d9": typeof CGDAIncentive; "0x6060409d": typeof ERC20VariableIncentive }}
+ * @type {{ "0xc5b24b8e": typeof PointsIncentive; "0x8c901437": typeof ERC20Incentive; "0x4414fbb4": typeof AllowListIncentive; "0xa39e44d9": typeof CGDAIncentive; "0xa8e4af1e": typeof ERC20VariableIncentive }}
  */
 export const IncentiveByComponentInterface = {
   [APointsIncentive as Hex]: PointsIncentive,
   [AERC20Incentive as Hex]: ERC20Incentive,
-  // TODO: figure out why evm generates bad bytes4 here
-  ['0x0a466e6f']: AllowListIncentive,
-  // [APointsIncentive as Hex]: ERC1155Incentive,
+  [AAllowListIncentive]: AllowListIncentive,
+  // [AERC1155Incentive as Hex]: ERC1155Incentive,
   [ACGDAIncentive as Hex]: CGDAIncentive,
   [AERC20VariableIncentive as Hex]: ERC20VariableIncentive,
 };
@@ -62,7 +63,7 @@ export const IncentiveByComponentInterface = {
  * @async
  * @param {DeployableOptions} options
  * @param {Address} address
- * @returns {unknown}
+ * @returns {Incentive}
  * @throws {@link InvalidComponentInterfaceError}
  */
 export async function incentiveFromAddress(

package/src/Incentives/PointsIncentive.test.ts

@@ -1,35 +1,34 @@
-import { readPointsBalanceOf, writePointsGrantRoles } from '@boostxyz/evm';
-import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
-import { signMessage } from '@wagmi/core';
-import { isAddress, pad, parseEther, zeroAddress } from 'viem';
-import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import type { MockPoints } from '../../test/MockPoints';
-import { accounts } from '../../test/accounts';
+import { readPointsBalanceOf, writePointsGrantRoles } from "@boostxyz/evm";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { isAddress, pad, parseEther, zeroAddress } from "viem";
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
+import type { MockPoints } from "@boostxyz/test/MockPoints";
+import { accounts } from "@boostxyz/test/accounts";
 import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
   freshBoost,
   freshPoints,
-} from '../../test/helpers';
-import { bytes4, prepareSignerValidatorClaimDataPayload } from '../utils';
-import { PointsIncentive } from './PointsIncentive';
+} from "@boostxyz/test/helpers";
+import { bytes4 } from "../utils";
+import { PointsIncentive } from "./PointsIncentive";
 
 let fixtures: Fixtures, points: MockPoints;
 
-describe('PointsIncentive', () => {
+describe("PointsIncentive", () => {
   beforeAll(async () => {
-    fixtures = await loadFixture(deployFixtures);
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
   });
 
   beforeEach(async () => {
     points = await loadFixture(freshPoints);
   });
 
-  test('can successfully be deployed', async () => {
+  test("can successfully be deployed", async () => {
     const action = new PointsIncentive(defaultOptions, {
       venue: zeroAddress,
-      selector: '0xdeadb33f',
+      selector: "0xdeadb33f",
       reward: 1n,
       limit: 1n,
     });
@@ -37,14 +36,14 @@ describe('PointsIncentive', () => {
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
 
-  test('can claim', async () => {
+  test("can claim", async () => {
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)!.account!;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const trustedSigner = accounts.at(0)!;
-    const pointsIncentive = new fixtures.bases.PointsIncentive(defaultOptions, {
+    const pointsIncentive = fixtures.core.PointsIncentive({
       venue: points.assertValidAddress(),
-      selector: bytes4('issue(address,uint256)'),
+      selector: bytes4("issue(address,uint256)"),
       reward: 1n,
       limit: 10n,
     });
@@ -53,13 +52,12 @@ describe('PointsIncentive', () => {
     });
 
     const claimant = trustedSigner.account;
-    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
     const incentiveQuantity = 1;
-    const claimDataPayload = await prepareSignerValidatorClaimDataPayload({
+    const claimDataPayload = await boost.validator.encodeClaimData({
       signer: trustedSigner,
       incentiveData,
       chainId: defaultOptions.config.chains[0].id,
-      validator: boost.validator.assertValidAddress(),
       incentiveQuantity,
       claimant,
       boostId: boost.id,
@@ -74,8 +72,7 @@ describe('PointsIncentive', () => {
       boost.id,
       0n,
       referrer,
-      claimDataPayload,
-      { value: parseEther('0.000075') },
+      claimDataPayload
     );
     expect(
       await readPointsBalanceOf(defaultOptions.config, {
@@ -85,16 +82,16 @@ describe('PointsIncentive', () => {
     ).toBe(1n);
   });
 
-  test('cannot claim twice', async () => {
+  test("cannot claim twice", async () => {
     const reward = 1n;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)!.account!;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const trustedSigner = accounts.at(0)!;
 
-    const pointsIncentive = new fixtures.bases.PointsIncentive(defaultOptions, {
+    const pointsIncentive = fixtures.core.PointsIncentive({
       venue: points.assertValidAddress(),
-      selector: bytes4('issue(address,uint256)'),
+      selector: bytes4("issue(address,uint256)"),
       reward,
       limit: 10n,
     });
@@ -103,13 +100,12 @@ describe('PointsIncentive', () => {
     });
 
     const claimant = trustedSigner.account;
-    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
     const incentiveQuantity = 1;
-    const claimDataPayload = await prepareSignerValidatorClaimDataPayload({
+    const claimDataPayload = await boost.validator.encodeClaimData({
       signer: trustedSigner,
       incentiveData,
       chainId: defaultOptions.config.chains[0].id,
-      validator: boost.validator.assertValidAddress(),
       incentiveQuantity,
       claimant,
       boostId: boost.id,
@@ -125,7 +121,7 @@ describe('PointsIncentive', () => {
       0n,
       referrer,
       claimDataPayload,
-      { value: parseEther('0.000075') },
+      { value: parseEther("0.000075") },
     );
     try {
       await fixtures.core.claimIncentive(
@@ -133,7 +129,7 @@ describe('PointsIncentive', () => {
         0n,
         referrer,
         claimDataPayload,
-        { value: parseEther('0.000075') },
+        { value: parseEther("0.000075") },
       );
     } catch (e) {
       expect(e).toBeInstanceOf(Error);