@boostxyz/sdk 0.0.0-alpha.9 → 1.1.0-alpha.23

package/src/BoostCore.test.ts

@@ -1,122 +1,113 @@
-import { loadFixture } from '@nomicfoundation/hardhat-toolbox-viem/network-helpers';
-import { parseEther, zeroAddress } from 'viem';
-import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { accounts } from "@boostxyz/test/accounts";
 import {
   type BudgetFixtures,
   type Fixtures,
   defaultOptions,
   deployFixtures,
+  freshBoost,
   fundBudget,
   makeMockEventActionPayload,
-} from '../test/helpers';
-import { ContractAction } from './Actions/ContractAction';
-import { BoostCore } from './BoostCore';
-import type { ERC20Incentive } from './Incentives/ERC20Incentive';
-import { ERC1155StrategyType } from './Incentives/ERC1155Incentive';
-import { StrategyType } from './claiming';
-import { IncentiveNotCloneableError } from './errors';
-import { bytes4 } from './utils';
+} from "@boostxyz/test/helpers";
+import { loadFixture } from "@nomicfoundation/hardhat-toolbox-viem/network-helpers";
+import { pad, parseEther, zeroAddress } from "viem";
+import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+import { ContractAction } from "./Actions/ContractAction";
+import { BOOST_CORE_CLAIM_FEE } from "./BoostCore";
+import type { ERC20Incentive } from "./Incentives/ERC20Incentive";
+import { StrategyType } from "./claiming";
+import { BoostNotFoundError, IncentiveNotCloneableError } from "./errors";
+import { bytes4 } from "./utils";
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
 
-describe('BoostCore', () => {
+describe("BoostCore", () => {
   beforeAll(async () => {
-    fixtures = await loadFixture(deployFixtures);
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
   });
   beforeEach(async () => {
     budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
   });
 
-  test('can get the total number of boosts', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
+  test("can get the total number of boosts", async () => {
+    const { core } = fixtures;
 
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
     const { budget, erc20 } = budgets;
-    await client.createBoost({
-      protocolFee: 1n,
-      referralFee: 2n,
-      maxParticipants: 100n,
+    await core.createBoost({
+      protocolFee: 0n,
+      maxParticipants: 5n,
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
-          limit: 100n,
+          reward: parseEther("1"),
+          limit: 5n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    expect(await client.getBoostCount()).toBe(1n);
+    expect(await core.getBoostCount()).toBe(1n);
   });
 
-  test('can successfully create a boost using all base contract implementations', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
+  test("throws a typed error if no boost exists", async () => {
+    const { core } = fixtures;
+    try {
+      await core.getBoost(1000n);
+    } catch (e) {
+      expect(e instanceof BoostNotFoundError).toBe(true);
+      expect(e.id).toBe("1000");
+    }
+  });
 
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("can successfully create a boost using all base contract implementations", async () => {
+    const { core } = fixtures;
     const { budget, erc20 } = budgets;
-    const boost = await client.createBoost({
+    const boost = await core.createBoost({
       protocolFee: 1n,
-      referralFee: 2n,
       maxParticipants: 100n,
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const onChainBoost = await client.readBoost(boost.id);
+    const onChainBoost = await core.readBoost(boost.id);
 
     expect(boost.owner).toBe(onChainBoost.owner);
     expect(boost.protocolFee).toBe(onChainBoost.protocolFee);
-    expect(boost.referralFee).toBe(onChainBoost.referralFee);
     expect(boost.maxParticipants).toBe(onChainBoost.maxParticipants);
 
     expect(boost.action.address).toBe(onChainBoost.action);
@@ -126,7 +117,7 @@ describe('BoostCore', () => {
     expect((await boost.action.target()).toLowerCase()).toBe(
       core.assertValidAddress().toLowerCase(),
     );
-    expect(await boost.action.selector()).toBe('0xdeadbeef');
+    expect(await boost.action.selector()).toBe("0xdeadbeef");
     expect(await boost.action.value()).toBe(0n);
 
     expect(boost.validator.address?.toLowerCase()).toBe(
@@ -159,55 +150,44 @@ describe('BoostCore', () => {
     expect((await incentive.asset()).toLowerCase()).toBe(
       erc20.address?.toLowerCase(),
     );
-    expect(await incentive.currentReward()).toBe(parseEther('1'));
+    expect(await incentive.currentReward()).toBe(parseEther("1"));
     expect(await incentive.limit()).toBe(100n);
     expect(await incentive.claims()).toBe(0n);
   });
 
-  test('can read the raw on chain representation of a boost', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("can read the raw on chain representation of a boost", async () => {
+    const { core } = fixtures;
     const { budget, erc20 } = budgets;
-    const _boost = await client.createBoost({
+    const _boost = await core.createBoost({
       protocolFee: 1n,
-      referralFee: 2n,
       maxParticipants: 100n,
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const boost = await client.readBoost(_boost.id);
+    const boost = await core.readBoost(_boost.id);
     expect(boost.protocolFee).toBe(1001n);
-    expect(boost.referralFee).toBe(1002n);
     expect(boost.maxParticipants).toBe(100n);
     expect(boost.budget).toBe(_boost.budget.assertValidAddress());
     expect(boost.action).toBe(_boost.action.assertValidAddress());
@@ -218,302 +198,321 @@ describe('BoostCore', () => {
     );
   });
 
-  test('can reuse an existing action', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
+  test("can optionally supply a validator", async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+    const _boost = await core.createBoost({
+      protocolFee: 1n,
+      maxParticipants: 100n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther("1"),
+          limit: 100n,
+          strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
+        }),
+      ],
     });
+    const boost = await core.readBoost(_boost.id);
+    expect(boost.validator).toBe(_boost.validator.assertValidAddress());
+  });
 
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("can simulate a boost creation", async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+    const simulated = await core.simulateCreateBoost({
+      protocolFee: 1n,
+      maxParticipants: 100n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther("1"),
+          limit: 100n,
+          strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
+        }),
+      ],
+    });
+    expect(simulated.request.__mode).toBe("prepared");
+  });
+
+  test("can reuse an existing action", async () => {
+    const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
     // allocate more funds to the budget
-    await erc20.mint(defaultOptions.account.address, parseEther('100'));
-    await erc20.approve(budget.assertValidAddress(), parseEther('100'));
+    await erc20.mint(defaultOptions.account.address, parseEther("110"));
+    await erc20.approve(budget.assertValidAddress(), parseEther("110"));
     await budget.allocate({
-      amount: parseEther('100'),
+      amount: parseEther("110"),
       asset: erc20.assertValidAddress(),
       target: defaultOptions.account.address,
     });
 
-    const _boost = await client.createBoost({
+    const _boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const boost = await client.createBoost({
+    const boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
-        _boost.action.assertValidAddress(),
-        false,
-      ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      action: core.EventAction(_boost.action.assertValidAddress(), false),
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const onChainBoost = await client.readBoost(boost.id);
+    const onChainBoost = await core.readBoost(boost.id);
     expect(onChainBoost.action).toBe(_boost.action.assertValidAddress());
   });
 
-  test('can reuse an existing validator', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("can reuse an existing validator", async () => {
+    const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
     // allocate more erc20 funds to the budget from the owning accound
-    await erc20.mint(defaultOptions.account.address, parseEther('100'));
-    await erc20.approve(budget.assertValidAddress(), parseEther('100'));
+    await erc20.mint(defaultOptions.account.address, parseEther("110"));
+    await erc20.approve(budget.assertValidAddress(), parseEther("110"));
     await budget.allocate({
-      amount: parseEther('100'),
+      amount: parseEther("110"),
       asset: erc20.assertValidAddress(),
       target: defaultOptions.account.address,
     });
 
-    const _boost = await client.createBoost({
+    const _boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const boost = await client.createBoost({
+    const boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(
-        defaultOptions,
+      validator: core.SignerValidator(
         _boost.validator.assertValidAddress(),
         false,
       ),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const onChainBoost = await client.readBoost(boost.id);
+    const onChainBoost = await core.readBoost(boost.id);
     expect(onChainBoost.validator).toBe(_boost.validator.assertValidAddress());
   });
 
-  test('can reuse an existing allowlist', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("can reuse an existing allowlist", async () => {
+    const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
     // allocate more erc20 funds to the budget from the owning accound
-    await erc20.mint(defaultOptions.account.address, parseEther('100'));
-    await erc20.approve(budget.assertValidAddress(), parseEther('100'));
+    await erc20.mint(defaultOptions.account.address, parseEther("110"));
+    await erc20.approve(budget.assertValidAddress(), parseEther("110"));
     await budget.allocate({
-      amount: parseEther('100'),
+      amount: parseEther("110"),
       asset: erc20.assertValidAddress(),
       target: defaultOptions.account.address,
     });
 
-    const _boost = await client.createBoost({
+    const _boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const boost = await client.createBoost({
+    const boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(
-        defaultOptions,
+      allowList: core.SimpleAllowList(
         _boost.allowList.assertValidAddress(),
         false,
       ),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
-    const onChainBoost = await client.readBoost(boost.id);
+    const onChainBoost = await core.readBoost(boost.id);
     expect(onChainBoost.allowList).toBe(_boost.allowList.assertValidAddress());
   });
 
-  test('cannot reuse an existing incentive', async () => {
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("cannot reuse an existing incentive", async () => {
+    const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
     // allocate more erc20 funds to the budget from the owning accound
-    await erc20.mint(defaultOptions.account.address, parseEther('100'));
-    await erc20.approve(budget.assertValidAddress(), parseEther('100'));
+    await erc20.mint(defaultOptions.account.address, parseEther("110"));
+    await erc20.approve(budget.assertValidAddress(), parseEther("110"));
     await budget.allocate({
-      amount: parseEther('100'),
+      amount: parseEther("110"),
       asset: erc20.assertValidAddress(),
       target: defaultOptions.account.address,
     });
 
-    const incentive = new bases.ERC20Incentive(defaultOptions, {
+    const incentive = core.ERC20Incentive({
       asset: erc20.assertValidAddress(),
-      reward: parseEther('1'),
+      reward: parseEther("1"),
       limit: 100n,
       strategy: StrategyType.POOL,
+      manager: budget.assertValidAddress(),
     });
-    const _boost = await client.createBoost({
+    const _boost = await core.createBoost({
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [incentive],
     });
     try {
-      await client.createBoost({
+      await core.createBoost({
         budget: budget,
-        action: new bases.EventAction(
-          defaultOptions,
+        action: core.EventAction(
           makeMockEventActionPayload(
             core.assertValidAddress(),
             erc20.assertValidAddress(),
           ),
         ),
-        validator: new bases.SignerValidator(defaultOptions, {
+        validator: core.SignerValidator({
           signers: [defaultOptions.account.address],
           validatorCaller: defaultOptions.account.address,
         }),
-        allowList: new bases.SimpleAllowList(defaultOptions, {
+        allowList: core.SimpleAllowList({
           owner: defaultOptions.account.address,
           allowed: [defaultOptions.account.address],
         }),
@@ -524,80 +523,67 @@ describe('BoostCore', () => {
     }
   });
 
-  test('can offer multiple incentives', async () => {
-    const { registry, core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+  test("can offer multiple incentives", async () => {
+    const { registry, core } = fixtures;
     const { budget, erc20, points, erc1155 } = budgets;
-    const allowList = await registry.clone(
-      'SharedAllowList',
-      new bases.SimpleAllowList(defaultOptions, {
+    const allowList = await registry.initialize(
+      "SharedAllowList",
+      core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
     );
 
-    const erc20Incentive = new bases.ERC20Incentive(defaultOptions, {
+    const erc20Incentive = core.ERC20Incentive({
       asset: erc20.assertValidAddress(),
       reward: 1n,
       limit: 10n,
       strategy: StrategyType.POOL,
+      manager: budget.assertValidAddress(),
     });
-    const erc1155Incentive = new bases.ERC1155Incentive(defaultOptions, {
-      asset: erc1155.assertValidAddress(),
-      strategy: ERC1155StrategyType.POOL,
-      limit: 1n,
-      tokenId: 1n,
-      extraData: '0x',
-    });
-    const cgdaIncentive = new bases.CGDAIncentive(defaultOptions, {
+    // const erc1155Incentive = core.ERC1155Incentive({
+    //   asset: erc1155.assertValidAddress(),
+    //   strategy: ERC1155StrategyType.POOL,
+    //   limit: 1n,
+    //   tokenId: 1n,
+    //   extraData: '0x',
+    // });
+    const cgdaIncentive = core.CGDAIncentive({
       asset: erc20.assertValidAddress(),
       initialReward: 1n,
       totalBudget: 10n,
       rewardBoost: 1n,
       rewardDecay: 1n,
+      manager: budget.assertValidAddress(),
     });
-    const allowListIncentive = new bases.AllowListIncentive(defaultOptions, {
+    const allowListIncentive = core.AllowListIncentive({
       allowList: allowList.assertValidAddress(),
       limit: 5n,
     });
-    const pointsIncentive = new bases.PointsIncentive(defaultOptions, {
+    const pointsIncentive = core.PointsIncentive({
       venue: points.assertValidAddress(),
-      selector: bytes4('issue(address,uint256)'),
+      selector: bytes4("issue(address,uint256)"),
       reward: 1n,
       limit: 10n,
     });
 
-    await client.createBoost({
+    await core.createBoost({
       protocolFee: 1n,
-      referralFee: 2n,
       maxParticipants: 100n,
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(
-        defaultOptions,
-        allowList.assertValidAddress(),
-        false,
-      ),
+      allowList: core.SimpleAllowList(allowList.assertValidAddress()),
       incentives: [
-        erc1155Incentive,
+        // erc1155Incentive,
         erc20Incentive,
         cgdaIncentive,
         allowListIncentive,
@@ -611,72 +597,38 @@ describe('BoostCore', () => {
     );
     expect(await cgdaIncentive.currentReward()).toEqual(1n);
     expect(
-      await (await allowListIncentive.allowList()).isAllowed(
-        defaultOptions.account.address,
-      ),
+      await (
+        await allowListIncentive.allowList()
+      ).isAllowed(defaultOptions.account.address),
     ).toEqual(true);
     expect(await pointsIncentive.reward()).toEqual(1n);
     expect(await pointsIncentive.currentReward()).toEqual(1n);
     expect(await pointsIncentive.limit()).toEqual(10n);
   });
 
-  test('can get  the protocol fee', async () => {
+  test("can get  the protocol fee", async () => {
     const { core } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
 
-    expect(await client.protocolFee()).toBe(1000n);
+    expect(await core.protocolFee()).toBe(1000n);
   });
 
-  test('can get the protocol fee receiver', async () => {
+  test("can get the protocol fee receiver", async () => {
     const { core } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
 
-    expect(await client.protocolFeeReceiver()).toBe(
+    expect(await core.protocolFeeReceiver()).toBe(
       defaultOptions.account.address,
     );
   });
 
-  test('can set the protocol fee receiver', async () => {
+  test("can set the protocol fee receiver", async () => {
     const { core } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    await client.setProcolFeeReceiver(zeroAddress);
 
-    expect(await client.protocolFeeReceiver()).toBe(zeroAddress);
-  });
-
-  test('can get the claim fee', async () => {
-    const { core } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
+    await core.setProcolFeeReceiver(zeroAddress);
 
-    expect(await client.claimFee()).toBe(75000000000000n);
+    expect(await core.protocolFeeReceiver()).toBe(zeroAddress);
   });
 
-  test('can set the claim fee', async () => {
-    const { core } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-
-    await client.setClaimFee(100n);
-
-    expect(await client.claimFee()).toBe(100n);
-  });
-
-  test('binds all actions, budgets, allowlists, incentives, and validators to reuse core options and account', () => {
+  test("binds all actions, budgets, allowlists, incentives, and validators to reuse core options and account", () => {
     const { core } = fixtures;
 
     // const contractAction = core.ContractAction(zeroAddress);
@@ -724,6 +676,7 @@ describe('BoostCore', () => {
       rewardDecay: 0n,
       rewardBoost: 0n,
       totalBudget: 0n,
+      manager: zeroAddress,
     });
     expect(cgdaIncentive._config).toEqual(defaultOptions.config);
     expect(cgdaIncentive._account).toEqual(defaultOptions.account);
@@ -757,7 +710,7 @@ describe('BoostCore', () => {
 
     const pointsIncentive = core.PointsIncentive({
       venue: zeroAddress,
-      selector: '0x',
+      selector: "0x",
       reward: 0n,
       limit: 0n,
     });
@@ -769,47 +722,37 @@ describe('BoostCore', () => {
     expect(signerValidator._account).toEqual(defaultOptions.account);
   });
 
-  test('can subscribe to contract events', async () => {
+  test("can subscribe to contract events", async () => {
     const subscription = vi.fn();
 
-    const { core, bases } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
-    client.subscribe(subscription, { pollingInterval: 100 });
-
-    // to whom it may concern, this syntax is only used because we need to use test classes
-    // that are preconfigured with the dynamic base addresses generated at test time.
-    // normally you would use the follow api for brevity
-    // budget: client.SimpleBudget({} | '0xaddress')
+    const { core } = fixtures;
+    core.subscribe(subscription, { pollingInterval: 100 });
     const { budget, erc20 } = budgets;
-    await client.createBoost({
+    await core.createBoost({
       protocolFee: 1n,
-      referralFee: 2n,
       maxParticipants: 100n,
       budget: budget,
-      action: new bases.EventAction(
-        defaultOptions,
+      action: core.EventAction(
         makeMockEventActionPayload(
           core.assertValidAddress(),
           erc20.assertValidAddress(),
         ),
       ),
-      validator: new bases.SignerValidator(defaultOptions, {
+      validator: core.SignerValidator({
         signers: [defaultOptions.account.address],
         validatorCaller: defaultOptions.account.address,
       }),
-      allowList: new bases.SimpleAllowList(defaultOptions, {
+      allowList: core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
       incentives: [
-        new bases.ERC20Incentive(defaultOptions, {
+        core.ERC20Incentive({
           asset: erc20.assertValidAddress(),
-          reward: parseEther('1'),
+          reward: parseEther("1"),
           limit: 100n,
           strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
         }),
       ],
     });
@@ -821,19 +764,131 @@ describe('BoostCore', () => {
     expect(subscription).toHaveBeenCalledTimes(1);
   });
 
-  test('can set a passthrough auth scheme', async () => {
+  test("can set a passthrough auth scheme", async () => {
     const { core } = fixtures;
-    const client = new BoostCore({
-      ...defaultOptions,
-      address: core.assertValidAddress(),
-    });
 
-    const auth = client.PassthroughAuth();
+    const auth = core.PassthroughAuth();
     await auth.deploy();
-    await client.setCreateBoostAuth(auth);
-    expect((await client.createBoostAuth()).toLowerCase()).toBe(
+    await core.setCreateBoostAuth(auth);
+    expect((await core.createBoostAuth()).toLowerCase()).toBe(
       auth.assertValidAddress(),
     );
-    expect(await client.isAuthorized(zeroAddress)).toBe(true);
+    expect(await core.isAuthorized(zeroAddress)).toBe(true);
+  });
+
+  test("uses the provided validator when one is specified", async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+    const customValidator = core.SignerValidator({
+      signers: [budget.assertValidAddress()],
+      validatorCaller: core.assertValidAddress(),
+    });
+    const boost = await core.createBoost({
+      maxParticipants: 100n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      validator: customValidator,
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther("1"),
+          limit: 100n,
+          strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
+        }),
+      ],
+    });
+
+    expect(boost.validator).toBe(customValidator);
+    const signers = await boost.validator.signers(budget.assertValidAddress());
+    expect(signers).toBe(true);
+  });
+
+  test("creates a boost with a default validator when none is provided", async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+    const boost = await core.createBoost({
+      maxParticipants: 100n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      allowList: core.OpenAllowList(),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther("1"),
+          limit: 100n,
+          strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
+        }),
+      ],
+    });
+
+    const validator = boost.validator;
+
+    // expect boostCore to be a validatorCaller
+    expect(validator.payload?.validatorCaller).toBe(core.assertValidAddress());
+
+    // expect current account to be a signer
+    const signer = await validator.signers(defaultOptions.account.address);
+    expect(signer).toBeDefined();
+    expect(signer).toBe(true);
+  });
+
+  test("can retrieve the BoostClaimed event from a transaction hash", 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 erc20Incentive = fixtures.core.ERC20Incentive({
+      asset: budgets.erc20.assertValidAddress(),
+      strategy: StrategyType.POOL,
+      reward: 1n,
+      limit: 1n,
+      manager: budgets.budget.assertValidAddress(),
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
+    const incentiveQuantity = 1;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    const { hash } = await fixtures.core.claimIncentiveRaw(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: BOOST_CORE_CLAIM_FEE },
+    );
+
+    const claimInfo = await fixtures.core.getClaimFromTransaction({ hash });
+    expect(claimInfo).toBeDefined();
+    expect(claimInfo?.claimant).toBe(claimant);
+    expect(typeof claimInfo?.boostId).toBe("bigint");
+    expect(claimInfo?.referrer).toBe(referrer);
   });
 });