@boostxyz/sdk 7.3.0 → 7.5.0

package/src/Incentives/ERC20Incentive.ts

@@ -124,7 +124,9 @@ export class ERC20Incentive extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_ERC20_INCENTIVE_BASE,
+    ...(import.meta.env?.VITE_ERC20_INCENTIVE_BASE
+      ? { 31337: import.meta.env.VITE_ERC20_INCENTIVE_BASE }
+      : {}),
     ...(ERC20IncentiveBases as Record<number, Address>),
   };
   /**

package/src/Incentives/ERC20PeggedIncentive.ts

@@ -118,7 +118,9 @@ export class ERC20PeggedIncentive extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_ERC20_INCENTIVE_BASE,
+    ...(import.meta.env?.VITE_ERC20_INCENTIVE_BASE
+      ? { 31337: import.meta.env.VITE_ERC20_INCENTIVE_BASE }
+      : {}),
     ...(ERC20PeggedIncentiveBases as Record<number, Address>),
   };
   /**

package/src/Incentives/ERC20PeggedVariableCriteriaIncentive.ts

@@ -153,7 +153,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,
+    ...(import.meta.env?.VITE_ERC20_INCENTIVE_BASE
+      ? { 31337: import.meta.env.VITE_ERC20_INCENTIVE_BASE }
+      : {}),
     ...(ERC20PeggedVariableCriteriaIncentiveBases as Record<number, Address>),
   };
   /**

package/src/Incentives/ERC20PeggedVariableCriteriaIncentiveV2.ts

@@ -156,8 +156,12 @@ export class ERC20PeggedVariableCriteriaIncentiveV2 extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env
-      .VITE_ERC20_PEGGED_VARIABLE_CRITERIA_INCENTIVE_V2_BASE,
+    ...(import.meta.env?.VITE_ERC20_PEGGED_VARIABLE_CRITERIA_INCENTIVE_V2_BASE
+      ? {
+          31337: import.meta.env
+            .VITE_ERC20_PEGGED_VARIABLE_CRITERIA_INCENTIVE_V2_BASE,
+        }
+      : {}),
     ...(ERC20PeggedVariableCriteriaIncentiveV2Bases as Record<number, Address>),
   };
   /**

package/src/Incentives/ERC20VariableCriteriaIncentive.ts

@@ -128,7 +128,9 @@ export class ERC20VariableCriteriaIncentive extends ERC20VariableIncentive<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_ERC20_VARIABLE_CRITERIA_INCENTIVE_BASE,
+    ...(import.meta.env?.VITE_ERC20_VARIABLE_CRITERIA_INCENTIVE_BASE
+      ? { 31337: import.meta.env.VITE_ERC20_VARIABLE_CRITERIA_INCENTIVE_BASE }
+      : {}),
     ...(ERC20VariableCriteriaIncentiveBases as Record<number, Address>),
   };
 

package/src/Incentives/ERC20VariableCriteriaIncentiveV2.ts

@@ -143,7 +143,11 @@ export class ERC20VariableCriteriaIncentiveV2 extends ERC20VariableIncentive<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_ERC20_VARIABLE_CRITERIA_INCENTIVE_V2_BASE,
+    ...(import.meta.env?.VITE_ERC20_VARIABLE_CRITERIA_INCENTIVE_V2_BASE
+      ? {
+          31337: import.meta.env.VITE_ERC20_VARIABLE_CRITERIA_INCENTIVE_V2_BASE,
+        }
+      : {}),
     ...(ERC20VariableCriteriaIncentiveV2Bases as Record<number, Address>),
   };
 

package/src/Incentives/ERC20VariableIncentive.ts

@@ -113,7 +113,9 @@ export class ERC20VariableIncentive<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_ERC20_VARIABLE_INCENTIVE_BASE,
+    ...(import.meta.env?.VITE_ERC20_VARIABLE_INCENTIVE_BASE
+      ? { 31337: import.meta.env.VITE_ERC20_VARIABLE_INCENTIVE_BASE }
+      : {}),
     ...(ERC20VariableIncentiveBases as Record<number, Address>),
   };
   /**

package/src/Incentives/PointsIncentive.ts

@@ -111,7 +111,9 @@ export class PointsIncentive extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_POINTS_INCENTIVE_BASE,
+    ...(import.meta.env?.VITE_POINTS_INCENTIVE_BASE
+      ? { 31337: import.meta.env.VITE_POINTS_INCENTIVE_BASE }
+      : {}),
     ...(PointsIncentiveBases as Record<number, Address>),
   };
   /**

package/src/Validators/LimitedSignerValidator.ts

@@ -316,7 +316,9 @@ export class LimitedSignerValidator extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
-    31337: import.meta.env.VITE_LIMITED_SIGNER_VALIDATOR_BASE,
+    ...(import.meta.env?.VITE_LIMITED_SIGNER_VALIDATOR_BASE
+      ? { 31337: import.meta.env.VITE_LIMITED_SIGNER_VALIDATOR_BASE }
+      : {}),
     ...(SignerValidatorBases as Record<number, Address>),
   };
   /**

package/src/Validators/PayableLimitedSignerValidator.test.ts

@@ -0,0 +1,202 @@
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { isAddress, parseEther } from "viem";
+import { beforeAll, describe, expect, test } from "vitest";
+import { accounts } from "@boostxyz/test/accounts";
+import { type Fixtures, defaultOptions, deployFixtures } from "@boostxyz/test/helpers";
+import { testAccount } from "@boostxyz/test/viem";
+import { PayableLimitedSignerValidator } from "./PayableLimitedSignerValidator";
+
+let fixtures: Fixtures;
+
+function freshBaseValidator(fixtures: Fixtures) {
+  return async function freshBaseValidator() {    
+    const PayableLimitedSignerValidator = fixtures.bases.PayableLimitedSignerValidator;
+    const baseAddress = PayableLimitedSignerValidator.bases[31337];
+    return new PayableLimitedSignerValidator(
+      defaultOptions,
+      baseAddress
+    );
+  };
+}
+
+function freshCloneValidator(fixtures: Fixtures) {
+  return function freshCloneValidator() {
+    const account = accounts[2].account;
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.PayableLimitedSignerValidator({
+        signers: [account],
+        validatorCaller: testAccount.address,
+        maxClaimCount: 3
+      })
+    );
+  };
+}
+
+describe("PayableLimitedSignerValidator", () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+    // Set the base address in the SDK class so other tests can use it
+    const TPayableLimitedSignerValidator = fixtures.bases.PayableLimitedSignerValidator;
+    if (TPayableLimitedSignerValidator.bases[31337]) {
+      PayableLimitedSignerValidator.bases[31337] = TPayableLimitedSignerValidator.bases[31337];
+    }
+  });
+
+  test("can successfully be deployed as clone", async () => {
+    expect.assertions(1);
+    
+    // Deploy a clone (not a base)
+    const validator = await fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.PayableLimitedSignerValidator({
+        signers: [testAccount.address],
+        validatorCaller: testAccount.address,
+        maxClaimCount: 1
+      })
+    );
+    
+    expect(isAddress(validator.assertValidAddress())).toBe(true);
+  });
+
+  test("initializes successfully as base implementation", async () => {
+    expect.assertions(1);
+    const validator = await loadFixture(freshBaseValidator(fixtures));
+    expect(isAddress(validator.assertValidAddress())).toBe(true);
+  });
+
+  test("initializes successfully as clone", async () => {
+    expect.assertions(2);
+    const cloneValidator = await loadFixture(freshCloneValidator(fixtures));
+
+    expect(await cloneValidator.signers(accounts[2].account)).toBe(true);
+    expect(await cloneValidator.signers(defaultOptions.account.address)).toBe(false);
+  });
+
+  describe("Claim Fee Management", () => {
+    test("should have initial claim fee set from constructor", async () => {
+      expect.assertions(1);
+      const baseValidator = await loadFixture(freshBaseValidator(fixtures));
+      const initialFee = await baseValidator.getClaimFee();
+      
+      // Should have the initial fee set during deployment (0.001 ETH)
+      expect(initialFee).toBe(parseEther("0.001"));
+    });
+
+    test("should update initial claim fee and reflect changes on both base and clones", async () => {
+      expect.assertions(6);
+      const baseValidator = await loadFixture(freshBaseValidator(fixtures));
+      const cloneValidator = await loadFixture(freshCloneValidator(fixtures));
+      const newFee = parseEther("0.005"); // 0.005 ETH
+      
+      // Verify initial fees are set correctly (0.001 ETH from constructor)
+      const initialBaseFee = await baseValidator.getClaimFee();
+      const initialCloneFee = await cloneValidator.getClaimFee();
+      expect(initialBaseFee).toBe(parseEther("0.001"));
+      expect(initialCloneFee).toBe(parseEther("0.001"));
+      
+      // Update the fee on the base implementation
+      await baseValidator.setClaimFee(newFee);
+      
+      // Verify both base and clone now reflect the new fee
+      const updatedBaseFee = await baseValidator.getClaimFee();
+      const updatedCloneFee = await cloneValidator.getClaimFee();
+      expect(updatedBaseFee).toBe(newFee);
+      expect(updatedCloneFee).toBe(newFee);
+      
+      // Verify the fees are different from the initial fees
+      expect(updatedBaseFee).not.toBe(initialBaseFee);
+      expect(updatedCloneFee).not.toBe(initialCloneFee);
+    });
+
+    test("should set and read claim fee on base implementation", async () => {
+      expect.assertions(1);
+      const baseValidator = await loadFixture(freshBaseValidator(fixtures));
+      const claimFee = parseEther("0.01");
+
+      await baseValidator.setClaimFee(claimFee);
+      const retrievedFee = await baseValidator.getClaimFee();
+
+      expect(retrievedFee).toBe(claimFee);
+    });
+
+    test("should read claim fee from base implementation when called on clone", async () => {
+      expect.assertions(2);
+      const baseValidator = await loadFixture(freshBaseValidator(fixtures));
+      const cloneValidator = await loadFixture(freshCloneValidator(fixtures));
+      const claimFee = parseEther("0.02");
+
+      await baseValidator.setClaimFee(claimFee);
+
+      const baseFee = await baseValidator.getClaimFee();
+      const cloneFee = await cloneValidator.getClaimFee();
+
+      expect(baseFee).toBe(claimFee);
+      expect(cloneFee).toBe(claimFee);
+    });
+
+    test("should update fee globally when base is updated", async () => {
+      expect.assertions(4);
+      const baseValidator = await loadFixture(freshBaseValidator(fixtures));
+      const cloneValidator = await loadFixture(freshCloneValidator(fixtures));
+      const initialFee = parseEther("0.01");
+      const newFee = parseEther("0.03");
+
+      // Set initial fee
+      await baseValidator.setClaimFee(initialFee);
+      expect(await baseValidator.getClaimFee()).toBe(initialFee);
+      expect(await cloneValidator.getClaimFee()).toBe(initialFee);
+
+      // Update fee on base
+      await baseValidator.setClaimFee(newFee);
+      expect(await baseValidator.getClaimFee()).toBe(newFee);
+      expect(await cloneValidator.getClaimFee()).toBe(newFee);
+    });
+
+    test("should prevent clones from setting fee", async () => {
+      expect.assertions(1);
+      const cloneValidator = await loadFixture(freshCloneValidator(fixtures));
+      const newFee = parseEther("0.05");
+
+      await expect(() => cloneValidator.setClaimFee(newFee)).rejects.toThrow();
+    });
+
+    test("should allow setting fee to zero", async () => {
+      expect.assertions(1);
+      const baseValidator = await loadFixture(freshBaseValidator(fixtures));
+
+      await baseValidator.setClaimFee(0n);
+      const retrievedFee = await baseValidator.getClaimFee();
+
+      expect(retrievedFee).toBe(0n);
+    });
+  });
+
+  describe("Inherited Functionality", () => {
+    test("should inherit signer management from LimitedSignerValidator", async () => {
+      expect.assertions(3);
+      const validator = await loadFixture(freshBaseValidator(fixtures));
+      const newSigner = accounts[3].account;
+
+      // Initially not authorized
+      expect(await validator.signers(newSigner)).toBe(false);
+
+      // Authorize the signer
+      await validator.setAuthorized([newSigner], [true]);
+      expect(await validator.signers(newSigner)).toBe(true);
+
+      // Deauthorize the signer
+      await validator.setAuthorized([newSigner], [false]);
+      expect(await validator.signers(newSigner)).toBe(false);
+    });
+
+    test("should inherit validator caller management", async () => {
+      expect.assertions(1);
+      const validator = await loadFixture(freshBaseValidator(fixtures));
+      const newCaller = accounts[4].account;
+
+      await validator.setValidatorCaller(newCaller);
+      expect(true).toBe(true);
+    });
+  });
+});