@boostxyz/sdk 1.1.0-alpha.22 → 1.1.0-alpha.23

package/src/Budgets/ManagedBudget.test.ts

@@ -9,14 +9,14 @@ import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
-  freshBudget,
   freshManagedBudget,
   fundErc20,
   fundErc1155,
   fundManagedBudget,
 } from '@boostxyz/test/helpers';
 import { testAccount } from '@boostxyz/test/viem';
-import { ManagedBudget, ManagedBudgetRoles } from './ManagedBudget';
+import { ManagedBudget } from './ManagedBudget';
+import { Roles } from '../Deployable/DeployableTargetWithRBAC';
 
 let fixtures: Fixtures,
   budget: ManagedBudget,
@@ -45,51 +45,75 @@ describe('ManagedBudget', () => {
     const one = accounts[1].account;
     const two = accounts[2].account;
     await budget.setAuthorized([one, two], [true, true]);
-    expect(await budget.hasAllRoles(one, ManagedBudgetRoles.ADMIN)).toBe(false);
-    expect(await budget.hasAllRoles(one, ManagedBudgetRoles.MANAGER)).toBe(
+    expect(await budget.hasAllRoles(one, Roles.ADMIN)).toBe(false);
+    expect(await budget.hasAllRoles(one, Roles.MANAGER)).toBe(
       true,
     );
-    expect(await budget.hasAllRoles(two, ManagedBudgetRoles.MANAGER)).toBe(
+    expect(await budget.hasAllRoles(two, Roles.MANAGER)).toBe(
       true,
     );
   });
 
-  test('can grant roles', async () => {
+  test('can grant role', async () => {
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
+    const manager = accounts[1].account;
+    await budget.grantRoles(manager, Roles.MANAGER);
+    expect(await budget.hasAllRoles(manager, Roles.ADMIN)).toBe(false);
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(true);
+  });
+
+  test('can revoke role', async () => {
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
+    const manager = accounts[1].account;
+    await budget.grantRoles(manager, Roles.MANAGER);
+    await budget.grantRoles(manager, Roles.ADMIN);
+    await budget.revokeRoles(manager, Roles.MANAGER);
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(false);
+    expect(await budget.hasAllRoles(manager, Roles.ADMIN)).toBe(true);
+    await budget.revokeRoles(manager, Roles.ADMIN);
+    expect(await budget.hasAllRoles(manager, Roles.ADMIN)).toBe(false);
+  });
+
+  test('can grant many roles', async () => {
     const budget = await loadFixture(
       freshManagedBudget(defaultOptions, fixtures),
     );
     const admin = accounts[1].account;
     const manager = accounts[2].account;
-    await budget.grantRoles(
+    await budget.grantManyRoles(
       [admin, manager],
-      [ManagedBudgetRoles.ADMIN, ManagedBudgetRoles.MANAGER],
+      [Roles.ADMIN, Roles.MANAGER],
     );
-    expect(await budget.hasAllRoles(admin, ManagedBudgetRoles.ADMIN)).toBe(
+    expect(await budget.hasAllRoles(admin, Roles.ADMIN)).toBe(
       true,
     );
-    expect(await budget.hasAllRoles(manager, ManagedBudgetRoles.MANAGER)).toBe(
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(
       true,
     );
   });
 
-  test('can revoke roles', async () => {
+  test('can revoke many roles', async () => {
     const budget = await loadFixture(
       freshManagedBudget(defaultOptions, fixtures),
     );
     const admin = accounts[1].account;
     const manager = accounts[2].account;
-    await budget.grantRoles(
+    await budget.grantManyRoles(
       [admin, manager],
-      [ManagedBudgetRoles.ADMIN, ManagedBudgetRoles.MANAGER],
+      [Roles.ADMIN, Roles.MANAGER],
     );
-    await budget.revokeRoles(
+    await budget.revokeManyRoles(
       [admin, manager],
-      [ManagedBudgetRoles.ADMIN, ManagedBudgetRoles.MANAGER],
+      [Roles.ADMIN, Roles.MANAGER],
     );
-    expect(await budget.hasAllRoles(admin, ManagedBudgetRoles.ADMIN)).toBe(
+    expect(await budget.hasAllRoles(admin, Roles.ADMIN)).toBe(
       false,
     );
-    expect(await budget.hasAllRoles(manager, ManagedBudgetRoles.MANAGER)).toBe(
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(
       false,
     );
   });

package/src/Budgets/ManagedBudget.ts

@@ -2,26 +2,16 @@ import {
   managedBudgetAbi,
   readManagedBudgetAvailable,
   readManagedBudgetDistributed,
-  readManagedBudgetHasAllRoles,
-  readManagedBudgetHasAnyRole,
-  readManagedBudgetIsAuthorized,
   readManagedBudgetOwner,
-  readManagedBudgetRolesOf,
   readManagedBudgetTotal,
   simulateManagedBudgetAllocate,
   simulateManagedBudgetClawback,
   simulateManagedBudgetDisburse,
   simulateManagedBudgetDisburseBatch,
-  simulateManagedBudgetGrantRoles,
-  simulateManagedBudgetRevokeRoles,
-  simulateManagedBudgetSetAuthorized,
   writeManagedBudgetAllocate,
   writeManagedBudgetClawback,
   writeManagedBudgetDisburse,
   writeManagedBudgetDisburseBatch,
-  writeManagedBudgetGrantRoles,
-  writeManagedBudgetRevokeRoles,
-  writeManagedBudgetSetAuthorized,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/budgets/ManagedBudget.sol/ManagedBudget.json';
 import { getAccount } from '@wagmi/core';
@@ -38,7 +28,6 @@ import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
-import { DeployableTarget } from '../Deployable/DeployableTarget';
 import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
 import {
   DeployableUnknownOwnerProvidedError,
@@ -193,6 +182,7 @@ export class ManagedBudget extends DeployableTargetWithRBAC<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_MANAGED_BUDGET_BASE,
     ...(ManagedBudgetBases as Record<number, Address>),
   };
   /**

package/src/Budgets/VestingBudget.ts

@@ -129,7 +129,9 @@ export class VestingBudget extends DeployableTargetWithRBAC<
    * @static
    * @type {Record<number, Address>}
    */
-  public static override bases: Record<number, Address> = {};
+  public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_VESTING_BUDGET_BASE,
+  };
   /**
    * @inheritdoc
    *

package/src/Deployable/DeployableTargetWithRBAC.test.ts

@@ -0,0 +1,103 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { accounts } from '@boostxyz/test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshManagedBudget,
+} from '@boostxyz/test/helpers';
+import { Roles } from './DeployableTargetWithRBAC';
+
+let fixtures: Fixtures;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
+});
+
+describe('RBAC', () => {
+  test('can grant roles', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const manager = accounts[0].account;
+    expect(await budget.rolesOf(manager)).not.toContain(Roles.MANAGER);
+    await budget.grantRoles(manager, Roles.MANAGER);
+    expect(await budget.rolesOf(manager)).toContain(Roles.MANAGER);
+  });
+
+  test('can revoke roles', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const admin = accounts[1].account;
+    await budget.grantRoles(admin, Roles.ADMIN);
+    expect(await budget.rolesOf(admin)).toContain(Roles.ADMIN);
+    await budget.revokeRoles(admin, Roles.ADMIN);
+    expect(await budget.rolesOf(admin)).not.toContain(Roles.ADMIN);
+  });
+
+  test('can grant many roles', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const admin = accounts[2].account;
+    const manager = accounts[3].account;
+    await budget.grantManyRoles(
+      [admin, manager],
+      [Roles.ADMIN, Roles.MANAGER],
+    );
+    expect(await budget.hasAllRoles(admin, Roles.ADMIN)).toBe(true);
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(true);
+  });
+
+  test('can revoke many roles', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const admin = accounts[4].account;
+    const manager = accounts[5].account;
+    await budget.grantManyRoles(
+      [admin, manager],
+      [Roles.ADMIN, Roles.MANAGER],
+    );
+    expect(await budget.hasAllRoles(admin, Roles.ADMIN)).toBe(true);
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(true);
+    await budget.revokeManyRoles(
+      [admin, manager],
+      [Roles.ADMIN, Roles.MANAGER],
+    );
+    expect(await budget.hasAllRoles(admin, Roles.ADMIN)).toBe(false);
+    expect(await budget.hasAllRoles(manager, Roles.MANAGER)).toBe(false);
+  });
+
+  test('can check for any role', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const user = accounts[6].account;
+    expect(await budget.hasAnyRole(user, Roles.MANAGER | Roles.ADMIN)).toBe(false);
+    await budget.grantRoles(user, Roles.MANAGER);
+    expect(await budget.hasAnyRole(user, Roles.MANAGER | Roles.ADMIN)).toBe(true);
+  });
+
+  test('can check for all roles', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const user = accounts[7].account;
+    await budget.grantRoles(user, Roles.MANAGER);
+    expect(await budget.hasAllRoles(user, Roles.MANAGER | Roles.ADMIN)).toBe(false);
+    await budget.grantRoles(user, Roles.ADMIN);
+    expect(await budget.hasAllRoles(user, Roles.MANAGER | Roles.ADMIN)).toBe(true);
+  });
+
+  test('can get roles of an account', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const user = accounts[8].account;
+    await budget.grantRoles(user, Roles.MANAGER | Roles.ADMIN);
+    const roles = await budget.rolesOf(user);
+    expect(roles).toContain(Roles.MANAGER);
+    expect(roles).toContain(Roles.ADMIN);
+  });
+
+  test('can set and check authorization', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const user = accounts[9].account;
+    expect(await budget.rolesOf(user)).not.toContain(Roles.MANAGER);
+    await budget.setAuthorized([user], [true]);
+    expect(await budget.isAuthorized(user)).toBe(true);
+    expect(await budget.rolesOf(user)).toContain(Roles.MANAGER);
+    await budget.setAuthorized([user], [false]);
+    expect(await budget.isAuthorized(user)).toBe(false);
+    expect(await budget.rolesOf(user)).not.toContain(Roles.MANAGER);
+  });
+});

package/src/Deployable/DeployableTargetWithRBAC.ts

@@ -4,10 +4,14 @@ import {
   readRbacHasAnyRole,
   readRbacIsAuthorized,
   readRbacRolesOf,
+  simulateRbacGrantManyRoles,
   simulateRbacGrantRoles,
+  simulateRbacRevokeManyRoles,
   simulateRbacRevokeRoles,
   simulateRbacSetAuthorized,
+  writeRbacGrantManyRoles,
   writeRbacGrantRoles,
+  writeRbacRevokeManyRoles,
   writeRbacRevokeRoles,
   writeRbacSetAuthorized,
 } from '@boostxyz/evm';
@@ -109,49 +113,49 @@ export class DeployableTargetWithRBAC<
   }
 
   /**
-   * Grant many accounts permissions on the rbac.
+   * Grant permissions for a user on the rbac.
    *
    * @example
    * ```ts
-   * await rbac.grantRoles(['0xfoo', '0xbar], [RbacRoles.MANAGER, RbacRoles.ADMIN])
+   * await rbac.grantRoles('0xfoo', Roles.MANAGER)
    * ```
    * @public
    * @async
-   * @param {Address[]} addresses
-   * @param {RbacRoles[]} roles
-   * @param {?WriteParams} [params]
+   * @param {Address} address
+   * @param {Roles} role
+   * @param {?WriteParams<typeof rbacAbi, 'grantRoles'>} [params]
    * @returns {Promise<void>}
    */
   public async grantRoles(
-    addresses: Address[],
-    roles: Roles[],
+    address: Address,
+    role: Roles,
     params?: WriteParams<typeof rbacAbi, 'grantRoles'>,
   ) {
-    return await this.awaitResult(this.grantRolesRaw(addresses, roles, params));
+    return await this.awaitResult(this.grantRolesRaw(address, role, params));
   }
 
   /**
-   * Grant many accounts permissions on the rbac.
+   * Grant permissions for a user on the rbac.
    *
    * @example
    * ```ts
-   * await rbac.grantRoles(['0xfoo', '0xbar], [Roles.MANAGER, Roles.ADMIN])
-   *
+   * await rbac.grantRoles('0xfoo', Roles.MANAGER)
+   * ```
    * @public
    * @async
-   * @param {Address[]} addresses
-   * @param {RbacRoles[]} roles
+   * @param {Address} address
+   * @param {Roles} role
    * @param {?WriteParams} [params]
    * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async grantRolesRaw(
-    addresses: Address[],
-    roles: Roles[],
+    address: Address,
+    role: Roles,
     params?: WriteParams<typeof rbacAbi, 'grantRoles'>,
   ) {
     const { request, result } = await simulateRbacGrantRoles(this._config, {
       address: this.assertValidAddress(),
-      args: [addresses, roles],
+      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),
@@ -165,55 +169,173 @@ export class DeployableTargetWithRBAC<
   }
 
   /**
-   * Revoke many accounts' permissions on the rbac.
+   * 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', '0xbar], [RbacRoles.MANAGER, RbacRoles.ADMIN])
+   * 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 {RbacRoles[]} roles
+   * @param {Roles[]} roles
    * @param {?WriteParams} [params]
    * @returns {Promise<void>}
    */
-  public async revokeRoles(
+  public async grantManyRoles(
     addresses: Address[],
     roles: Roles[],
-    params?: WriteParams<typeof rbacAbi, 'revokeRoles'>,
+    params?: WriteParams<typeof rbacAbi, 'grantManyRoles'>,
   ) {
     return await this.awaitResult(
-      this.revokeRolesRaw(addresses, roles, params),
+      this.grantManyRolesRaw(addresses, roles, params),
     );
   }
 
   /**
-   * Revoke many accounts' permissions on the rbac.
+   * Grant many accounts permissions on the rbac.
    *
    * @example
    * ```ts
-   * await rbac.revokeRoles(['0xfoo', '0xbar], [RbacRoles.MANAGER, RbacRoles.ADMIN])
+   * await rbac.grantManyRoles(['0xfoo', '0xbar], [Roles.MANAGER, Roles.ADMIN])
+   * ```
    * @public
    * @async
    * @param {Address[]} addresses
-   * @param {RbacRoles[]} roles
+   * @param {Roles[]} roles
    * @param {?WriteParams} [params]
    * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
-  public async revokeRolesRaw(
+  public async grantManyRolesRaw(
     addresses: Address[],
     roles: Roles[],
-    params?: WriteParams<typeof rbacAbi, 'revokeRoles'>,
+    params?: WriteParams<typeof rbacAbi, 'grantManyRoles'>,
   ) {
-    const { request, result } = await simulateRbacRevokeRoles(this._config, {
+    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 writeRbacRevokeRoles(
+    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,
@@ -225,11 +347,12 @@ export class DeployableTargetWithRBAC<
    * Return an array of the roles assigned to the given account.
    * @example
    * ```ts
-   * (await rbac.rolesOf(0xfoo)).includes(RbacRoles.ADMIN)
+   * (await rbac.rolesOf(0xfoo)).includes(Roles.ADMIN)
+   * ```
    * @public
    * @param {Address} account
    * @param {?ReadParams} [params]
-   * @returns {Promise<Array<RbacRoles>>}
+   * @returns {Promise<Array<Roles>>}
    */
   public async rolesOf(
     account: Address,
@@ -252,10 +375,11 @@ export class DeployableTargetWithRBAC<
    *
    * @example
    * ```ts
-   * await rbac.hasAnyRole(0xfoo, RbacRoles.ADMIN | RbacRoles.MANAGER)
+   * await rbac.hasAnyRole(0xfoo, Roles.ADMIN | Roles.MANAGER)
+   * ```
    * @public
    * @param {Address} account
-   * @param {RbacRoles} roles
+   * @param {Roles} roles
    * @param {?ReadParams} [params]
    * @returns {Promise<boolean>}
    */
@@ -278,11 +402,11 @@ export class DeployableTargetWithRBAC<
    *
    * @example
    * ```ts
-   * await rbac.hasAllRoles(0xfoo, RbacRoles.ADMIN & RbacRoles.MANAGER)
-   *
+   * await rbac.hasAllRoles(0xfoo, Roles.ADMIN | Roles.MANAGER)
+   * ```
    * @public
    * @param {Address} account
-   * @param {RbacRoles} roles
+   * @param {Roles} roles
    * @param {?ReadParams} [params]
    * @returns {Promise<boolean>}
    */

package/src/Incentives/AllowListIncentive.test.ts

@@ -8,8 +8,8 @@ import {
   deployFixtures,
   freshBoost,
 } from '@boostxyz/test/helpers';
-import { LIST_MANAGER_ROLE } from '../AllowLists/SimpleAllowList';
 import { PointsIncentive } from './PointsIncentive';
+import { Roles } from '../Deployable/DeployableTargetWithRBAC';
 
 let fixtures: Fixtures;
 
@@ -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

@@ -97,6 +97,7 @@ export class AllowListIncentive extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_ALLOWLIST_INCENTIVE_BASE,
     ...(AllowListIncentiveBases as Record<number, Address>),
   };
   /**

package/src/Incentives/CGDAIncentive.ts

@@ -155,6 +155,7 @@ export class CGDAIncentive extends DeployableTarget<
    * @type {Record<number, Address>}
    */
   public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_CGDA_INCENTIVE_BASE,
     ...(CGDAIncentiveBases as Record<number, Address>),
   };
   /**

package/src/Incentives/ERC1155Incentive.ts

@@ -129,7 +129,9 @@ export class ERC1155Incentive extends DeployableTarget<
    * @static
    * @type {Record<number, Address>}
    */
-  public static override bases: Record<number, Address> = {};
+  public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_ERC1155_INCENTIVE_BASE,
+  };
   /**
    * @inheritdoc
    *