@boostxyz/sdk 6.0.3 → 6.1.0

package/src/BoostCore.test.ts

@@ -17,7 +17,7 @@ import { StrategyType } from "./claiming";
 import { BoostNotFoundError, IncentiveNotCloneableError } from "./errors";
 import type { ERC20Incentive } from "./Incentives/ERC20Incentive";
 import { bytes4 } from "./utils";
-import { BoostValidatorEOA } from "./Validators/Validator";
+import { BoostValidatorEOA } from './Validators/Validator';
 import { AssetType } from "./transfers";
 import { waitForTransactionReceipt } from "@wagmi/core";
 import { SignatureType } from "./Actions/EventAction";
@@ -1279,3 +1279,84 @@ describe("ERC20PeggedVariableCriteriaIncentive Top-Ups", () => {
     expect(newLimit).toBe(originalLimit + expectedNetTopup);
   });
 });
+
+describe("ERC20PeggedVariableCriteriaIncentive with LimitedSignerValidator", () => {
+  test("enforces validator claim limit", async () => {
+    const referrer = accounts[1].account!;
+    const signer = accounts[0];
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+
+    const erc721 = await loadFixture(fundErc721(defaultOptions));
+    const incentive = core.ERC20PeggedVariableCriteriaIncentive({
+      asset: erc20.assertValidAddress(),
+      peg: erc20.assertValidAddress(),
+      reward: parseEther("1"),
+      limit: parseEther("10"), 
+      maxReward: parseEther("2"),
+      manager: budget.assertValidAddress(),
+      criteria: {
+        criteriaType: SignatureType.FUNC,
+        signature: pad(bytes4("transferFrom(address,address,uint256)")),
+        fieldIndex: 2,
+        targetContract: erc721.assertValidAddress(),
+      },
+    });
+    await erc20.mint(defaultOptions.account.address, parseEther("110"));
+    await erc20.approve(budget.assertValidAddress(), parseEther("110"));
+    await budget.allocate({
+      amount: parseEther("110"),
+      asset: erc20.assertValidAddress(),
+      target: defaultOptions.account.address,
+    });
+
+    const boost = await core.createBoost({
+      protocolFee: 0n,
+      maxParticipants: 5n,
+      budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [incentive],
+    });
+
+    const claimant = defaultOptions.account.address;
+    const signedAmount = parseEther("1");
+    const incentiveData = incentive.buildClaimData(signedAmount);
+
+    // First claim
+    const firstClaimPayload = await boost.validator.encodeClaimData({
+      signer: signer,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    // First claim should succeed
+    await core.claimIncentive(boost.id, 0n, referrer, firstClaimPayload);
+
+    // Generate new signature for second claim
+    const secondClaimPayload = await boost.validator.encodeClaimData({
+      signer: signer,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    // Second claim should fail due to validator limit (specific error code)
+    await expect(
+      core.claimIncentive(boost.id, 0n, referrer, secondClaimPayload)
+    ).rejects.toThrow("0x059b7045"); // BoostError.MaximumClaimed
+  });
+});

package/src/BoostCore.ts

@@ -527,13 +527,22 @@ export class BoostCore extends Deployable<
           Object.keys(this.addresses).map(Number),
         );
       const testnet = chain.testnet || chain.id === 31337;
-      payload.validator = this.SignerValidator({
-        signers: [
-          (testnet
-            ? BoostValidatorEOA.TESTNET
-            : BoostValidatorEOA.MAINNET) as unknown as Address,
-        ],
+      const signers = [
+        (testnet
+          ? BoostValidatorEOA.TESTNET
+          : BoostValidatorEOA.MAINNET) as unknown as Address,
+      ];
+
+      // This seemed like the best approach - I didn't want to use the testnet PK even in local testing
+      // May be another approach but this works for now and is pretty well isolated
+      if (chain.id === 31337) {
+        signers.push('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266');
+      }
+
+      payload.validator = this.LimitedSignerValidator({
+        signers,
         validatorCaller: coreAddress,
+        maxClaimCount: 1,
       });
     }