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

package/src/Deployable/DeployableTargetWithRBAC.ts

@@ -0,0 +1,447 @@
+import {
+  rbacAbi,
+  readRbacHasAllRoles,
+  readRbacHasAnyRole,
+  readRbacIsAuthorized,
+  readRbacRolesOf,
+  simulateRbacGrantManyRoles,
+  simulateRbacGrantRoles,
+  simulateRbacRevokeManyRoles,
+  simulateRbacRevokeRoles,
+  simulateRbacSetAuthorized,
+  writeRbacGrantManyRoles,
+  writeRbacGrantRoles,
+  writeRbacRevokeManyRoles,
+  writeRbacRevokeRoles,
+  writeRbacSetAuthorized,
+} from '@boostxyz/evm';
+import type { Abi, Address, ContractEventName } from 'viem';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import type { GenericLog, ReadParams, WriteParams } from '../utils';
+export { rbacAbi };
+
+/**
+ *  Enum representing available roles for use with the `RBAC` authorization scheme.
+ * `MANAGER` has lowest level of write permissions, for specific implementations, see Budgets and ALlowLists
+ * `ADMIN` can additionally manage authorized users on the contract.
+ *
+ * @export
+ * @type {{ readonly MANAGER: 1n; readonly ADMIN_ROLE: 2n; }}
+ * @enum {bigint}
+ */
+export enum Roles {
+  //@ts-expect-error ts doesn't like bigint enum values
+  MANAGER = 1n,
+  //@ts-expect-error ts doesn't like bigint enum values
+  ADMIN = 2n,
+}
+
+/**
+ * A generic `viem.Log` event with support for `Rbac` event types.
+ *
+ * @export
+ * @typedef {RBACLog}
+ * @template {ContractEventName<typeof rbacAbi>} [event=ContractEventName<
+ *     typeof rbacAbi
+ *   >]
+ */
+export type RBACLog<
+  event extends ContractEventName<typeof rbacAbi> = ContractEventName<
+    typeof rbacAbi
+  >,
+> = GenericLog<typeof rbacAbi, event>;
+
+/**
+ * A minimal RBAC implementation that offers MANAGER and ADMIN roles, and
+ * Budgets and allowlists support this auth scheme
+ *
+ * @export
+ * @class DeployableTargetWithRBAC
+ * @typedef {DeployableTargetWithRBAC}
+ * @extends {DeployableTarget<RbacPayload>}
+ */
+export class DeployableTargetWithRBAC<
+  Payload,
+  ABI extends Abi,
+> extends DeployableTarget<Payload, ABI> {
+  /**
+   * Set the authorized status of the given accounts
+   * The mechanism for managing authorization is left to the implementing contract
+   *
+   * @public
+   * @async
+   * @param {Address[]} addresses - The accounts to authorize or deauthorize
+   * @param {boolean[]} allowed - The authorization status for the given accounts
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async setAuthorized(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof rbacAbi, 'setAuthorized'>,
+  ) {
+    return await this.awaitResult(
+      this.setAuthorizedRaw(addresses, allowed, params),
+    );
+  }
+
+  /**
+   * Set the authorized status of the given accounts
+   * The mechanism for managing authorization is left to the implementing contract
+   *
+   * @public
+   * @async
+   * @param {Address[]} addresses - The accounts to authorize or deauthorize
+   * @param {boolean[]} allowed - The authorization status for the given accounts
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async setAuthorizedRaw(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof rbacAbi, 'setAuthorized'>,
+  ) {
+    const { request, result } = await simulateRbacSetAuthorized(this._config, {
+      address: this.assertValidAddress(),
+      args: [addresses, allowed],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+    const hash = await writeRbacSetAuthorized(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Grant permissions for a user on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.grantRoles('0xfoo', Roles.MANAGER)
+   * ```
+   * @public
+   * @async
+   * @param {Address} address
+   * @param {Roles} role
+   * @param {?WriteParams<typeof rbacAbi, 'grantRoles'>} [params]
+   * @returns {Promise<void>}
+   */
+  public async grantRoles(
+    address: Address,
+    role: Roles,
+    params?: WriteParams<typeof rbacAbi, 'grantRoles'>,
+  ) {
+    return await this.awaitResult(this.grantRolesRaw(address, role, params));
+  }
+
+  /**
+   * Grant permissions for a user on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.grantRoles('0xfoo', Roles.MANAGER)
+   * ```
+   * @public
+   * @async
+   * @param {Address} address
+   * @param {Roles} role
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async grantRolesRaw(
+    address: Address,
+    role: Roles,
+    params?: WriteParams<typeof rbacAbi, 'grantRoles'>,
+  ) {
+    const { request, result } = await simulateRbacGrantRoles(this._config, {
+      address: this.assertValidAddress(),
+      args: [address, role],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+    const hash = await writeRbacGrantRoles(
+      this._config,
+      // biome-ignore lint/suspicious/noExplicitAny: negligible low level lack of type intersection
+      request as any,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Revoke permissions for a user on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.revokeRoles('0xfoo', Roles.MANAGER)
+   * ```
+   * @public
+   * @async
+   * @param {Address} address
+   * @param {Roles} role
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async revokeRoles(
+    address: Address,
+    role: Roles,
+    params?: WriteParams<typeof rbacAbi, 'revokeRoles'>,
+  ) {
+    return await this.awaitResult(this.revokeRolesRaw(address, role, params));
+  }
+
+  /**
+   * Revoke permissions for a user on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.revokeRoles('0xfoo', Roles.MANAGER)
+   * ```
+   * @public
+   * @async
+   * @param {Address} address
+   * @param {Roles} role
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async revokeRolesRaw(
+    address: Address,
+    role: Roles,
+    params?: WriteParams<typeof rbacAbi, 'revokeRoles'>,
+  ) {
+    const { request, result } = await simulateRbacRevokeRoles(this._config, {
+      address: this.assertValidAddress(),
+      args: [address, role],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+    const hash = await writeRbacRevokeRoles(
+      this._config,
+      // biome-ignore lint/suspicious/noExplicitAny: negligible low level lack of type intersection
+      request as any,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Grant many accounts permissions on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.grantManyRoles(['0xfoo', '0xbar], [Roles.MANAGER, Roles.ADMIN])
+   * ```
+   * @public
+   * @async
+   * @param {Address[]} addresses
+   * @param {Roles[]} roles
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async grantManyRoles(
+    addresses: Address[],
+    roles: Roles[],
+    params?: WriteParams<typeof rbacAbi, 'grantManyRoles'>,
+  ) {
+    return await this.awaitResult(
+      this.grantManyRolesRaw(addresses, roles, params),
+    );
+  }
+
+  /**
+   * Grant many accounts permissions on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.grantManyRoles(['0xfoo', '0xbar], [Roles.MANAGER, Roles.ADMIN])
+   * ```
+   * @public
+   * @async
+   * @param {Address[]} addresses
+   * @param {Roles[]} roles
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async grantManyRolesRaw(
+    addresses: Address[],
+    roles: Roles[],
+    params?: WriteParams<typeof rbacAbi, 'grantManyRoles'>,
+  ) {
+    const { request, result } = await simulateRbacGrantManyRoles(this._config, {
+      address: this.assertValidAddress(),
+      args: [addresses, roles],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+    const hash = await writeRbacGrantManyRoles(
+      this._config,
+      // biome-ignore lint/suspicious/noExplicitAny: negligible low level lack of type intersection
+      request as any,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Revoke many accounts' permissions on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.revokeManyRoles(['0xfoo', '0xbar], [Roles.MANAGER, Roles.ADMIN])
+   * ```
+   * @public
+   * @async
+   * @param {Address[]} addresses
+   * @param {Roles[]} roles
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async revokeManyRoles(
+    addresses: Address[],
+    roles: Roles[],
+    params?: WriteParams<typeof rbacAbi, 'revokeManyRoles'>,
+  ) {
+    return await this.awaitResult(
+      this.revokeManyRolesRaw(addresses, roles, params),
+    );
+  }
+
+  /**
+   * Revoke many accounts' permissions on the rbac.
+   *
+   * @example
+   * ```ts
+   * await rbac.revokeManyRoles(['0xfoo', '0xbar], [Roles.MANAGER, Roles.ADMIN])
+   * ```
+   * @public
+   * @async
+   * @param {Address[]} addresses
+   * @param {Roles[]} roles
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async revokeManyRolesRaw(
+    addresses: Address[],
+    roles: Roles[],
+    params?: WriteParams<typeof rbacAbi, 'revokeManyRoles'>,
+  ) {
+    const { request, result } = await simulateRbacRevokeManyRoles(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [addresses, roles],
+        ...this.optionallyAttachAccount(),
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
+    const hash = await writeRbacRevokeManyRoles(
+      this._config,
+      // biome-ignore lint/suspicious/noExplicitAny: negligible low level lack of type intersection
+      request as any,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Return an array of the roles assigned to the given account.
+   * @example
+   * ```ts
+   * (await rbac.rolesOf(0xfoo)).includes(Roles.ADMIN)
+   * ```
+   * @public
+   * @param {Address} account
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Array<Roles>>}
+   */
+  public async rolesOf(
+    account: Address,
+    params?: ReadParams<typeof rbacAbi, 'rolesOf'>,
+  ) {
+    const roles = await readRbacRolesOf(this._config, {
+      address: this.assertValidAddress(),
+      args: [account],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+    return ([Roles.MANAGER, Roles.ADMIN] as unknown as Array<bigint>).filter(
+      (role) => (roles & role) === role,
+    ) as unknown as Roles[];
+  }
+
+  /**
+   * Returns whether given account has any of the provided roles bitmap.
+   *
+   * @example
+   * ```ts
+   * await rbac.hasAnyRole(0xfoo, Roles.ADMIN | Roles.MANAGER)
+   * ```
+   * @public
+   * @param {Address} account
+   * @param {Roles} roles
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>}
+   */
+  public hasAnyRole(
+    account: Address,
+    roles: Roles,
+    params?: ReadParams<typeof rbacAbi, 'hasAnyRole'>,
+  ) {
+    return readRbacHasAnyRole(this._config, {
+      address: this.assertValidAddress(),
+      args: [account, roles],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Returns whether given account has all of the provided roles bitmap.
+   *
+   * @example
+   * ```ts
+   * await rbac.hasAllRoles(0xfoo, Roles.ADMIN | Roles.MANAGER)
+   * ```
+   * @public
+   * @param {Address} account
+   * @param {Roles} roles
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>}
+   */
+  public hasAllRoles(
+    account: Address,
+    roles: Roles,
+    params?: ReadParams<typeof rbacAbi, 'hasAllRoles'>,
+  ) {
+    return readRbacHasAllRoles(this._config, {
+      address: this.assertValidAddress(),
+      args: [account, roles],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Check if the given account is authorized to use the rbac
+   *
+   * @public
+   * @param {Address} account
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if the account is authorized
+   */
+  public isAuthorized(
+    account: Address,
+    params?: ReadParams<typeof rbacAbi, 'isAuthorized'>,
+  ) {
+    return readRbacIsAuthorized(this._config, {
+      address: this.assertValidAddress(),
+      args: [account],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+}

package/src/Incentives/AllowListIncentive.test.ts

@@ -1,23 +1,23 @@
 import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
 import { isAddress, pad, parseEther, zeroAddress } from 'viem';
 import { beforeAll, describe, expect, test } from 'vitest';
-import { accounts } from '../../test/accounts';
+import { accounts } from '@boostxyz/test/accounts';
 import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
   freshBoost,
-} from '../../test/helpers';
-import { LIST_MANAGER_ROLE } from '../AllowLists/SimpleAllowList';
+} from '@boostxyz/test/helpers';
 import { PointsIncentive } from './PointsIncentive';
+import { Roles } from '../Deployable/DeployableTargetWithRBAC';
 
 let fixtures: Fixtures;
 
 function freshAllowList(fixtures: Fixtures) {
   return function freshAllowList() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
-      new fixtures.bases.SimpleAllowList(defaultOptions, {
+      fixtures.core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [],
       }),
@@ -27,7 +27,7 @@ function freshAllowList(fixtures: Fixtures) {
 
 describe('AllowListIncentive', () => {
   beforeAll(async () => {
-    fixtures = await loadFixture(deployFixtures);
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
   });
 
   test('can successfully be deployed', async () => {
@@ -57,9 +57,9 @@ describe('AllowListIncentive', () => {
     const boost = await freshBoost(fixtures, {
       incentives: [allowListIncentive],
     });
-    await allowList.grantRoles(
-      allowListIncentive.assertValidAddress(),
-      LIST_MANAGER_ROLE,
+    await allowList.grantManyRoles(
+      [allowListIncentive.assertValidAddress()],
+      [Roles.MANAGER],
     );
 
     const claimant = trustedSigner.account;
@@ -103,9 +103,9 @@ describe('AllowListIncentive', () => {
     const boost = await freshBoost(fixtures, {
       incentives: [allowListIncentive],
     });
-    await allowList.grantRoles(
-      allowListIncentive.assertValidAddress(),
-      LIST_MANAGER_ROLE,
+    await allowList.grantManyRoles(
+      [allowListIncentive.assertValidAddress()],
+      [Roles.MANAGER],
     );
     const incentiveQuantity = 1;
     const claimant = trustedSigner.account;

package/src/Incentives/AllowListIncentive.ts

@@ -16,7 +16,9 @@ import {
   type ContractEventName,
   type Hex,
   encodeAbiParameters,
+  zeroHash,
 } from 'viem';
+import { AllowListIncentive as AllowListIncentiveBases } from '../../dist/deployments.json';
 import { SimpleAllowList } from '../AllowLists/AllowList';
 import type {
   DeployableOptions,
@@ -92,10 +94,12 @@ export class AllowListIncentive extends DeployableTarget<
    *
    * @public
    * @static
-   * @type {Address}
+   * @type {Record<number, Address>}
    */
-  public static override base: Address = import.meta.env
-    .VITE_ALLOWLIST_INCENTIVE_BASE;
+  public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_ALLOWLIST_INCENTIVE_BASE,
+    ...(AllowListIncentiveBases as Record<number, Address>),
+  };
   /**
    * @inheritdoc
    *
@@ -110,8 +114,8 @@ export class AllowListIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'owner'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>}
    */
   public async owner(
     params?: ReadParams<typeof allowListIncentiveAbi, 'owner'>,
@@ -129,7 +133,7 @@ export class AllowListIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'claims'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async claims(
@@ -148,7 +152,7 @@ export class AllowListIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'reward'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async reward(
@@ -168,7 +172,7 @@ export class AllowListIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {Address} address
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'claimed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>}
    */
   public async claimed(
@@ -188,7 +192,7 @@ export class AllowListIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'allowList'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<SimpleAllowList>}
    */
   public async allowList(
@@ -210,8 +214,8 @@ export class AllowListIncentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'limit'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public async limit(
     params?: ReadParams<typeof allowListIncentiveAbi, 'limit'>,
@@ -229,7 +233,7 @@ export class AllowListIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {Pick<ClaimPayload, 'target'>} payload
-   * @param {?WriteParams<typeof allowListIncentiveAbi, 'claim'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<true>} - return true if successful, otherwise revert
    */
   protected async claim(
@@ -245,8 +249,8 @@ export class AllowListIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {Pick<ClaimPayload, 'target'>} payload
-   * @param {?WriteParams<typeof allowListIncentiveAbi, 'claim'>} [params]
-   * @returns {Promise<true>} - return true if successful, otherwise revert
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - return true if successful, otherwise revert
    */
   protected async claimRaw(
     payload: Pick<ClaimPayload, 'target'>,
@@ -272,7 +276,7 @@ export class AllowListIncentive extends DeployableTarget<
    * @public
    * @async
    * @param {Pick<ClaimPayload, 'target'>} payload
-   * @param {?ReadParams<typeof allowListIncentiveAbi, 'isClaimable'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>} - True if the incentive is claimable based on the data payload
    */
   public async isClaimable(
@@ -310,6 +314,17 @@ export class AllowListIncentive extends DeployableTarget<
       ...this.optionallyAttachAccount(options.account),
     };
   }
+
+  /**
+   * Builds the claim data for the AllowListIncentive.
+   *
+   * @public
+   * @returns {Hash} A `zeroHash`, as AllowListIncentive doesn't require specific claim data.
+   * @description This function returns `zeroHash` because AllowListIncentive doesn't use any specific claim data.
+   */
+  public buildClaimData() {
+    return zeroHash;
+  }
 }
 
 /**

package/src/Incentives/CGDAIncentive.test.ts

@@ -1,8 +1,8 @@
 import { readMockErc20BalanceOf } from '@boostxyz/evm';
 import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
-import { isAddress, pad, parseEther } from 'viem';
+import { isAddress, pad, parseEther, zeroAddress } from 'viem';
 import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { accounts } from '../../test/accounts';
+import { accounts } from '@boostxyz/test/accounts';
 import {
   type BudgetFixtures,
   type Fixtures,
@@ -10,14 +10,14 @@ import {
   deployFixtures,
   freshBoost,
   fundBudget,
-} from '../../test/helpers';
+} from '@boostxyz/test/helpers';
 import { CGDAIncentive } from './CGDAIncentive';
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
 
 describe('CGDAIncentive', () => {
   beforeAll(async () => {
-    fixtures = await loadFixture(deployFixtures);
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
   });
 
   beforeEach(async () => {
@@ -31,6 +31,7 @@ describe('CGDAIncentive', () => {
       totalBudget: 10n,
       rewardBoost: 1n,
       rewardDecay: 1n,
+      manager: budgets.budget.address || zeroAddress 
     });
     await action.deploy();
     expect(isAddress(action.assertValidAddress())).toBe(true);
@@ -41,12 +42,13 @@ describe('CGDAIncentive', () => {
     const referrer = accounts.at(1)!.account!;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const trustedSigner = accounts.at(0)!;
-    const erc20Incentive = new fixtures.bases.CGDAIncentive(defaultOptions, {
+    const erc20Incentive = fixtures.core.CGDAIncentive({
       asset: budgets.erc20.assertValidAddress(),
       initialReward: 1n,
       totalBudget: 10n,
       rewardBoost: 1n,
       rewardDecay: 1n,
+      manager: budgets.budget.assertValidAddress(),
     });
     const boost = await freshBoost(fixtures, {
       budget: budgets.budget,
@@ -86,12 +88,13 @@ describe('CGDAIncentive', () => {
     const referrer = accounts.at(1)!.account!;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const trustedSigner = accounts.at(0)!;
-    const erc20Incentive = new fixtures.bases.CGDAIncentive(defaultOptions, {
+    const erc20Incentive = fixtures.core.CGDAIncentive({
       asset: budgets.erc20.assertValidAddress(),
       initialReward: 1n,
       totalBudget: 10n,
       rewardBoost: 1n,
       rewardDecay: 1n,
+      manager: budgets.budget.address || zeroAddress 
     });
     const boost = await freshBoost(fixtures, {
       budget: budgets.budget,