@boostxyz/sdk 2.0.0-alpha.34 → 2.0.0

package/src/Incentives/ERC20VariableIncentive.test.ts

@@ -16,6 +16,7 @@ import {
   zeroAddress
 } from "viem";
 import { beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { decodeClaimData } from "../Validators/Validator";
 import { ERC20VariableIncentive } from "./ERC20VariableIncentive";
 
 
@@ -83,6 +84,46 @@ describe("ERC20VariableIncentive", () => {
     ).toBe(1n);
   });
 
+  test("can test claimability", 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
+      trustedSigner = accounts.at(0)!;
+    const erc20VariableIncentive = new fixtures.bases.ERC20VariableIncentive(
+      defaultOptions,
+      {
+        asset: budgets.erc20.assertValidAddress(),
+        reward: 1n,
+        limit: 1n,
+        manager: zeroAddress,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20VariableIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData: erc20VariableIncentive.buildClaimData(parseEther("1")),
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+  });
+
   test("cannot claim twice", async () => {
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)!.account!;
@@ -130,6 +171,39 @@ describe("ERC20VariableIncentive", () => {
     }
   });
 
+  test("can decode a claimed amount from claim data", 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 erc20VariableIncentive = new fixtures.bases.ERC20VariableIncentive(
+      defaultOptions,
+      {
+        asset: budgets.erc20.assertValidAddress(),
+        reward: 1n,
+        limit: 1n,
+        manager: zeroAddress,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20VariableIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData: erc20VariableIncentive.buildClaimData(parseEther("1")),
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    const { incentiveData } = decodeClaimData(claimDataPayload)
+    expect(erc20VariableIncentive.decodeClaimData(incentiveData)).toBe(parseEther("1"))
+  });
+
   test("can properly encode a uint256", () => {
     //@ts-ignore
     const incentive = fixtures.core.ERC20VariableIncentive();

package/src/Incentives/ERC20VariableIncentive.ts

@@ -20,6 +20,7 @@ import {
   type Address,
   type ContractEventName,
   type Hex,
+  decodeAbiParameters,
   encodeAbiParameters,
 } from 'viem';
 import { ERC20VariableIncentive as ERC20VariableIncentiveBases } from '../../dist/deployments.json';
@@ -366,6 +367,34 @@ export class ERC20VariableIncentive<
     return await this.limit(params);
   }
 
+  /**
+   * Check if any claims remain by comparing the incentive's total claimed amount against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if limit minus total claimed is greater than 0
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how much of the underlying asset remains by comparing the the limit against the total amount claimed. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - Limit minus total claimed
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [totalClaimed, limit] = await Promise.all([
+      this.totalClaimed(params),
+      this.limit(params),
+    ]);
+    return limit - totalClaimed;
+  }
+
   /**
    * Builds the claim data for the ERC20VariableIncentive.
    *
@@ -381,6 +410,18 @@ export class ERC20VariableIncentive<
     );
   }
 
+  /**
+   * Decodes claim data for the ERC20VariableIncentive, returning the encoded claim amount.
+   * Useful when deriving amount claimed from logs.
+   *
+   * @public
+   * @param {Hex} claimData
+   * @returns {BigInt} Returns the reward amount from a claim data payload
+   */
+  public decodeClaimData(data: Hex) {
+    return BigInt(decodeAbiParameters([{ type: 'uint256' }], data)[0]);
+  }
+
   /**
    * Encodes an amount to clawback from the incentive
    *

package/src/Incentives/PointsIncentive.test.ts

@@ -1,7 +1,4 @@
 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 {
@@ -11,6 +8,9 @@ import {
   freshBoost,
   freshPoints,
 } from "@boostxyz/test/helpers";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { isAddress, pad, parseEther, zeroAddress } from "viem";
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { bytes4 } from "../utils";
 import { PointsIncentive } from "./PointsIncentive";
 
@@ -81,6 +81,50 @@ describe("PointsIncentive", () => {
     ).toBe(1n);
   });
 
+  test("can test claimability", 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 = fixtures.core.PointsIncentive({
+      venue: points.assertValidAddress(),
+      selector: bytes4("issue(address,uint256)"),
+      reward: 1n,
+      limit: 1n,
+    });
+    const boost = await freshBoost(fixtures, {
+      incentives: [pointsIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+
+    await writePointsGrantRoles(defaultOptions.config, {
+      address: points.assertValidAddress(),
+      args: [pointsIncentive.assertValidAddress(), 2n],
+      account: defaultOptions.account,
+    });
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+  });
+
   test("cannot claim twice", async () => {
     const reward = 1n;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined

package/src/Incentives/PointsIncentive.ts

@@ -296,6 +296,34 @@ export class PointsIncentive extends DeployableTarget<
     });
   }
 
+  /**
+   * Check if any claims remain by comparing the incentive's total claims against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if total claims is less than limit
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how many claims remain by comparing the incentive's total claims against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - True if total claims is less than limit
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [claims, limit] = await Promise.all([
+      this.claims(params),
+      this.limit(params),
+    ]);
+    return limit - claims;
+  }
+
   /**
    * @inheritdoc
    *

package/src/Validators/SignerValidator.ts

@@ -17,7 +17,6 @@ import {
   type PrivateKeyAccount,
   encodeAbiParameters,
 } from 'viem';
-import { signTypedData } from 'viem/accounts';
 import { SignerValidator as SignerValidatorBases } from '../../dist/deployments.json';
 import type {
   DeployableOptions,

package/src/Validators/Validator.ts

@@ -5,7 +5,7 @@ import {
   // ALimitedSignerValidator,
 } from '@boostxyz/evm/deploys/componentInterfaces.json';
 import { readContract } from '@wagmi/core';
-import type { Address, Hex } from 'viem';
+import { type Address, type Hex, decodeAbiParameters } from 'viem';
 import type { DeployableOptions } from '../Deployable/Deployable';
 import { InvalidComponentInterfaceError } from '../errors';
 import { LimitedSignerValidator } from './LimitedSignerValidator';
@@ -80,3 +80,26 @@ export const BoostValidatorEOA = {
   MAINNET: import.meta.env.VITE_BOOST_MAINNET_SIGNER_EOA as Address,
   TESTNET: import.meta.env.VITE_BOOST_TESTNET_SIGNER_EOA as Address,
 };
+
+/**
+ * Decodes a claim data hex string into its validator data and incentive data components.
+ *
+ * @export
+ * @param {Hex} data - The hex-encoded claim data to decode
+ * @returns {{ validatorData: Hex; incentiveData: Hex }} The decoded claim data components
+ */
+export function decodeClaimData(data: Hex) {
+  return decodeAbiParameters(
+    [
+      {
+        type: 'tuple',
+        name: 'BoostClaimData',
+        components: [
+          { type: 'bytes', name: 'validatorData' },
+          { type: 'bytes', name: 'incentiveData' },
+        ],
+      },
+    ],
+    data,
+  )[0];
+}

package/src/utils.ts

@@ -5,6 +5,7 @@ import {
   type WatchContractEventParameters,
   getAccount,
   getChainId,
+  readContract,
   waitForTransactionReceipt,
 } from '@wagmi/core';
 import type { ExtractAbiEvent } from 'abitype';
@@ -255,3 +256,48 @@ export function assertValidAddressByChainId(
   // biome-ignore lint/style/noNonNullAssertion: this type should be narrowed by the above statement but isn't?
   return { chainId, address: addressByChainId[chainId]! };
 }
+
+/**
+ * Check an ERC20's balance for a given asset and
+ *
+ * @public
+ * @async
+ * @param {Config} [config]
+ * @param {Address} [asset]
+ * @param {Address} [owner]
+ * @param {?ReadParams} [params]
+ * @returns {Promise<bigint>} - The erc20 balance
+ */
+export async function getErc20Balance(
+  config: Config,
+  asset: Address,
+  owner: Address,
+  params?: ReadParams,
+) {
+  return await readContract(config, {
+    ...params,
+    functionName: 'balanceOf',
+    address: asset,
+    args: [owner],
+    abi: [
+      {
+        constant: true,
+        inputs: [
+          {
+            name: '_owner',
+            type: 'address',
+          },
+        ],
+        name: 'balanceOf',
+        outputs: [
+          {
+            name: 'balance',
+            type: 'uint256',
+          },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+      },
+    ],
+  });
+}