@boostxyz/sdk 0.0.0-alpha.10 → 0.0.0-alpha.12

package/src/AllowLists/SimpleDenyList.ts

@@ -74,10 +74,9 @@ export type SimpleDenyListLog<
  * @typedef {SimpleDenyList}
  * @extends {DeployableTarget<SimpleDenyListPayload>}
  */
-export class SimpleDenyList extends DeployableTarget<
-  SimpleDenyListPayload,
-  typeof simpleDenyListAbi
-> {
+export class SimpleDenyList<
+  Payload = SimpleDenyListPayload,
+> extends DeployableTarget<Payload | undefined, typeof simpleDenyListAbi> {
   public override readonly abi = simpleDenyListAbi;
   /**
    * @inheritdoc
@@ -177,13 +176,11 @@ export class SimpleDenyList extends DeployableTarget<
    * @returns {GenericDeployableParams}
    */
   public override buildParameters(
-    _payload?: SimpleDenyListPayload,
+    _payload?: Payload,
     _options?: DeployableOptions,
   ): GenericDeployableParams {
-    const [payload, options] = this.validateDeploymentConfig(
-      _payload,
-      _options,
-    );
+    const [p, options] = this.validateDeploymentConfig(_payload, _options);
+    const payload = p as SimpleDenyListPayload;
     if (!payload.owner || payload.owner === zeroAddress) {
       const owner = options.account
         ? options.account.address

package/src/BoostCore.ts

@@ -34,6 +34,7 @@ import {
 import { type Action, actionFromAddress } from './Actions/Action';
 import { EventAction, type EventActionPayload } from './Actions/EventAction';
 import { type AllowList, allowListFromAddress } from './AllowLists/AllowList';
+import { OpenAllowList } from './AllowLists/OpenAllowList';
 import {
   SimpleAllowList,
   type SimpleAllowListPayload,
@@ -1008,6 +1009,24 @@ export class BoostCore extends Deployable<
   //     isBase,
   //   );
   // }
+  /**
+   * Bound {@link OpenAllowList} constructor that reuses the same configuration as the Boost Core instance.
+   *
+   * @example
+   * ```ts
+   * const list = core.OpenAllowList('0x') // is roughly equivalent to
+   * const list = new OpenAllowList({ config: core._config, account: core._account }, '0x')
+   * ```
+   * @param {?boolean} [isBase]
+   * @returns {OpenAllowList}
+   */
+  OpenAllowList(isBase?: boolean) {
+    return new OpenAllowList(
+      { config: this._config, account: this._account },
+      undefined,
+      isBase,
+    );
+  }
   /**
    * Bound {@link SimpleAllowList} constructor that reuses the same configuration as the Boost Core instance.
    *

package/src/Budgets/ManagedBudget.test.ts

@@ -4,6 +4,7 @@ import { isAddress, parseEther, zeroAddress } from 'viem';
 import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import type { MockERC20 } from '../../test/MockERC20';
 import type { MockERC1155 } from '../../test/MockERC1155';
+import { accounts } from '../../test/accounts';
 import {
   type Fixtures,
   defaultOptions,
@@ -15,7 +16,7 @@ import {
   fundManagedBudget,
 } from '../../test/helpers';
 import { testAccount } from '../../test/viem';
-import { ManagedBudget } from './ManagedBudget';
+import { ManagedBudget, ManagedBudgetRoles } from './ManagedBudget';
 
 let fixtures: Fixtures,
   budget: ManagedBudget,
@@ -37,13 +38,73 @@ describe('ManagedBudget', () => {
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
 
+  test('can grant manager role to many users', async () => {
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
+    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(
+      true,
+    );
+    expect(await budget.hasAllRoles(two, ManagedBudgetRoles.MANAGER)).toBe(
+      true,
+    );
+  });
+
+  test('can grant roles', async () => {
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
+    const admin = accounts[1].account;
+    const manager = accounts[2].account;
+    await budget.grantRoles(
+      [admin, manager],
+      [ManagedBudgetRoles.ADMIN, ManagedBudgetRoles.MANAGER],
+    );
+    expect(await budget.hasAllRoles(admin, ManagedBudgetRoles.ADMIN)).toBe(
+      true,
+    );
+    expect(await budget.hasAllRoles(manager, ManagedBudgetRoles.MANAGER)).toBe(
+      true,
+    );
+  });
+
+  test('can revoke roles', async () => {
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
+    const admin = accounts[1].account;
+    const manager = accounts[2].account;
+    await budget.grantRoles(
+      [admin, manager],
+      [ManagedBudgetRoles.ADMIN, ManagedBudgetRoles.MANAGER],
+    );
+    await budget.revokeRoles(
+      [admin, manager],
+      [ManagedBudgetRoles.ADMIN, ManagedBudgetRoles.MANAGER],
+    );
+    expect(await budget.hasAllRoles(admin, ManagedBudgetRoles.ADMIN)).toBe(
+      false,
+    );
+    expect(await budget.hasAllRoles(manager, ManagedBudgetRoles.MANAGER)).toBe(
+      false,
+    );
+  });
+
   test('can be owned', async () => {
-    const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
     expect(await budget.owner()).toBe(defaultOptions.account.address);
   });
 
   test('can have authorized users', async () => {
-    const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
     expect(await budget.isAuthorized(defaultOptions.account.address)).toBe(
       true,
     );
@@ -51,8 +112,10 @@ describe('ManagedBudget', () => {
   });
 
   test('can have no initial balance', async () => {
-    const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
-    expect(await budget.available(zeroAddress)).toBe(0n);
+    const budget = await loadFixture(
+      freshManagedBudget(defaultOptions, fixtures),
+    );
+    expect(await budget.available()).toBe(0n);
   });
 
   describe('can allocate', () => {
@@ -73,7 +136,7 @@ describe('ManagedBudget', () => {
           value: parseEther('1.0'),
         },
       );
-      expect(await budget.available(zeroAddress)).toBe(parseEther('1.0'));
+      expect(await budget.available()).toBe(parseEther('1.0'));
     });
 
     test('erc20', async () => {
@@ -123,7 +186,7 @@ describe('ManagedBudget', () => {
         target: defaultOptions.account.address,
       });
 
-      expect(await budget.available(zeroAddress)).toBe(0n);
+      expect(await budget.available()).toBe(0n);
     });
 
     test('erc20 assets', async () => {

package/src/Budgets/ManagedBudget.ts

@@ -81,22 +81,26 @@ export interface ManagedBudgetPayload {
   /**
    * List of roles to assign to the corresponding account by index.
    *
-   * @type {bigint[]}
+   * @type {ManagedBudgetRoles[]}
    */
-  roles: bigint[];
+  roles: ManagedBudgetRoles[];
 }
 
 /**
- * Enum representing available roles for use in the `ManagedBudget`.
+ *  Enum representing available roles for use in the `ManagedBudget`.
  * `MANAGER` can disburse funds.
  * `ADMIN` can additionally manage authorized users on the budget.
  *
+ * @export
  * @type {{ readonly MANAGER: 1n; readonly ADMIN_ROLE: 2n; }}
+ * @enum {bigint}
  */
-export const ManagedBudgetRoles = {
-  MANAGER: 1n,
-  ADMIN: 2n,
-} as const;
+export enum ManagedBudgetRoles {
+  //@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 `ManagedBudget` event types.
@@ -152,9 +156,11 @@ export function prepareTransfer(
 ) {
   if (isFungibleTransfer(transfer)) {
     return prepareFungibleTransfer(transfer);
-  } else if (isERC1155TransferPayload(transfer)) {
+  }
+  if (isERC1155TransferPayload(transfer)) {
     return prepareERC1155Transfer(transfer);
-  } else throw new UnknownTransferPayloadSupplied(transfer);
+  }
+  throw new UnknownTransferPayloadSupplied(transfer);
 }
 
 /**
@@ -441,13 +447,13 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Address[]} addresses
-   * @param {bigint[]} roles
+   * @param {ManagedBudgetRoles[]} roles
    * @param {?WriteParams<typeof managedBudgetAbi, 'grantRoles'>} [params]
    * @returns {unknown}
    */
   public async grantRoles(
     addresses: Address[],
-    roles: bigint[],
+    roles: ManagedBudgetRoles[],
     params?: WriteParams<typeof managedBudgetAbi, 'grantRoles'>,
   ) {
     return await this.awaitResult(this.grantRolesRaw(addresses, roles, params));
@@ -463,13 +469,13 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Address[]} addresses
-   * @param {bigint[]} roles
+   * @param {ManagedBudgetRoles[]} roles
    * @param {?WriteParams<typeof managedBudgetAbi, 'grantRoles'>} [params]
    * @returns {unknown}
    */
   public async grantRolesRaw(
     addresses: Address[],
-    roles: bigint[],
+    roles: ManagedBudgetRoles[],
     params?: WriteParams<typeof managedBudgetAbi, 'grantRoles'>,
   ) {
     const { request, result } = await simulateManagedBudgetGrantRoles(
@@ -500,13 +506,13 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Address[]} addresses
-   * @param {bigint[]} roles
+   * @param {ManagedBudgetRoles[]} roles
    * @param {?WriteParams<typeof managedBudgetAbi, 'revokeRoles'>} [params]
    * @returns {unknown}
    */
   public async revokeRoles(
     addresses: Address[],
-    roles: bigint[],
+    roles: ManagedBudgetRoles[],
     params?: WriteParams<typeof managedBudgetAbi, 'revokeRoles'>,
   ) {
     return await this.awaitResult(
@@ -523,13 +529,13 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Address[]} addresses
-   * @param {bigint[]} roles
+   * @param {ManagedBudgetRoles[]} roles
    * @param {?WriteParams<typeof managedBudgetAbi, 'revokeRoles'>} [params]
    * @returns {unknown}
    */
   public async revokeRolesRaw(
     addresses: Address[],
-    roles: bigint[],
+    roles: ManagedBudgetRoles[],
     params?: WriteParams<typeof managedBudgetAbi, 'revokeRoles'>,
   ) {
     const { request, result } = await simulateManagedBudgetRevokeRoles(
@@ -558,7 +564,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @param {Address} account
    * @param {?ReadParams<typeof managedBudgetAbi, 'rolesOf'>} [params]
-   * @returns {Promise<Array<bigint>>}
+   * @returns {Promise<Array<ManagedBudgetRoles>>}
    */
   public async rolesOf(
     account: Address,
@@ -571,9 +577,14 @@ export class ManagedBudget extends DeployableTarget<
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
       ...(params as any),
     });
-    return [ManagedBudgetRoles.MANAGER, ManagedBudgetRoles.ADMIN].filter(
+    return (
+      [
+        ManagedBudgetRoles.MANAGER,
+        ManagedBudgetRoles.ADMIN,
+      ] as unknown as Array<bigint>
+    ).filter(
       (role) => (roles & role) === role,
-    );
+    ) as unknown as ManagedBudgetRoles[];
   }
 
   /**
@@ -584,13 +595,13 @@ export class ManagedBudget extends DeployableTarget<
    * await budget.hasAnyRole(0xfoo, ManagedBudgetRoles.ADMIN | ManagedBudgetRoles.MANAGER)
    * @public
    * @param {Address} account
-   * @param {bigint} roles
+   * @param {ManagedBudgetRoles} roles
    * @param {?ReadParams<typeof managedBudgetAbi, 'hasAnyRole'>} [params]
    * @returns {Promise<boolean>}
    */
   public hasAnyRole(
     account: Address,
-    roles: bigint,
+    roles: ManagedBudgetRoles,
     params?: ReadParams<typeof managedBudgetAbi, 'hasAnyRole'>,
   ) {
     return readManagedBudgetHasAnyRole(this._config, {
@@ -611,13 +622,13 @@ export class ManagedBudget extends DeployableTarget<
    *
    * @public
    * @param {Address} account
-   * @param {bigint} roles
+   * @param {ManagedBudgetRoles} roles
    * @param {?ReadParams<typeof managedBudgetAbi, 'hasAllRoles'>} [params]
    * @returns {*}
    */
   public hasAllRoles(
     account: Address,
-    roles: bigint,
+    roles: ManagedBudgetRoles,
     params?: ReadParams<typeof managedBudgetAbi, 'hasAllRoles'>,
   ) {
     return readManagedBudgetHasAllRoles(this._config, {
@@ -671,13 +682,13 @@ export class ManagedBudget extends DeployableTarget<
    * If a tokenId is provided, get the total amount of ERC1155 assets allocated to the budget, including any that have been distributed
    *
    * @public
-   * @param {Address} asset - The address of the asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"] - The address of the asset
    * @param {?(bigint | undefined)} [tokenId] - The ID of the token
    * @param {?ReadParams<typeof managedBudgetAbi, 'total'>} [params]
    * @returns {Promise<bigint>} - The total amount of assets
    */
   public total(
-    asset: Address,
+    asset: Address = zeroAddress,
     tokenId?: bigint | undefined,
     params?: ReadParams<typeof managedBudgetAbi, 'total'>,
   ) {
@@ -694,13 +705,13 @@ export class ManagedBudget extends DeployableTarget<
    * If a tokenId is provided, get the amount of ERC1155 assets available for distribution from the budget
    *
    * @public
-   * @param {Address} asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?(bigint | undefined)} [tokenId]
    * @param {?ReadParams<typeof managedBudgetAbi, 'available'>} [params]
    * @returns {Promise<bigint>} - The amount of assets available
    */
   public available(
-    asset: Address,
+    asset: Address = zeroAddress,
     tokenId?: bigint | undefined,
     params?: ReadParams<typeof managedBudgetAbi, 'available'>,
   ) {
@@ -717,13 +728,13 @@ export class ManagedBudget extends DeployableTarget<
    * If a tokenId is provided, get the amount of ERC1155 assets that have been distributed from the budget
    *
    * @public
-   * @param {Address} asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?(bigint | undefined)} [tokenId]
    * @param {?ReadParams<typeof managedBudgetAbi, 'distributed'>} [params]
    * @returns {Promise<bigint>} - The amount of assets distributed
    */
   public distributed(
-    asset: Address,
+    asset: Address = zeroAddress,
     tokenId?: bigint | undefined,
     params?: ReadParams<typeof managedBudgetAbi, 'distributed'>,
   ) {
@@ -791,6 +802,6 @@ export const prepareManagedBudgetPayload = ({
       'ManagedBudgetPayload payload',
       'struct ManagedBudgetPayload { address owner; address[] authorized; uint256[] roles; }',
     ]),
-    [{ owner, authorized, roles }],
+    [{ owner, authorized, roles: roles as unknown as Array<bigint> }],
   );
 };

package/src/Budgets/SimpleBudget.test.ts

@@ -50,7 +50,7 @@ describe.skip('SimpleBudget', () => {
 
   test('can have no initial balance', async () => {
     const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
-    expect(await budget.available(zeroAddress)).toBe(0n);
+    expect(await budget.available()).toBe(0n);
   });
 
   describe('can allocate', () => {
@@ -71,7 +71,7 @@ describe.skip('SimpleBudget', () => {
           value: parseEther('1.0'),
         },
       );
-      expect(await budget.available(zeroAddress)).toBe(parseEther('1.0'));
+      expect(await budget.available()).toBe(parseEther('1.0'));
     });
 
     test('erc20', async () => {
@@ -121,7 +121,7 @@ describe.skip('SimpleBudget', () => {
         target: defaultOptions.account.address,
       });
 
-      expect(await budget.available(zeroAddress)).toBe(0n);
+      expect(await budget.available()).toBe(0n);
     });
 
     test('erc20 assets', async () => {

package/src/Budgets/SimpleBudget.ts

@@ -441,13 +441,13 @@ export class SimpleBudget extends DeployableTarget<
    * If a tokenId is provided, get the total amount of ERC1155 assets allocated to the budget, including any that have been distributed
    *
    * @public
-   * @param {Address} asset - The address of the asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"] - The address of the asset
    * @param {?(bigint | undefined)} [tokenId] - The ID of the token
    * @param {?ReadParams<typeof simpleBudgetAbi, 'total'>} [params]
    * @returns {Promise<bigint>} - The total amount of assets
    */
   public total(
-    asset: Address,
+    asset: Address = zeroAddress,
     tokenId?: bigint | undefined,
     params?: ReadParams<typeof simpleBudgetAbi, 'total'>,
   ) {
@@ -464,13 +464,13 @@ export class SimpleBudget extends DeployableTarget<
    * If a tokenId is provided, get the amount of ERC1155 assets available for distribution from the budget
    *
    * @public
-   * @param {Address} asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?(bigint | undefined)} [tokenId]
    * @param {?ReadParams<typeof simpleBudgetAbi, 'available'>} [params]
    * @returns {Promise<bigint>} - The amount of assets available
    */
   public available(
-    asset: Address,
+    asset: Address = zeroAddress,
     tokenId?: bigint | undefined,
     params?: ReadParams<typeof simpleBudgetAbi, 'available'>,
   ) {
@@ -487,13 +487,13 @@ export class SimpleBudget extends DeployableTarget<
    * If a tokenId is provided, get the amount of ERC1155 assets that have been distributed from the budget
    *
    * @public
-   * @param {Address} asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?(bigint | undefined)} [tokenId]
    * @param {?ReadParams<typeof simpleBudgetAbi, 'distributed'>} [params]
    * @returns {Promise<bigint>} - The amount of assets distributed
    */
   public distributed(
-    asset: Address,
+    asset: Address = zeroAddress,
     tokenId?: bigint | undefined,
     params?: ReadParams<typeof simpleBudgetAbi, 'distributed'>,
   ) {

package/src/Budgets/VestingBudget.test.ts

@@ -53,7 +53,7 @@ describe.skip('VestingBudget', () => {
     const budget = await loadFixture(
       freshVestingBudget(defaultOptions, fixtures),
     );
-    expect(await budget.available(zeroAddress)).toBe(0n);
+    expect(await budget.available()).toBe(0n);
   });
 
   describe('can allocate', () => {
@@ -73,7 +73,7 @@ describe.skip('VestingBudget', () => {
           value: parseEther('1.0'),
         },
       );
-      expect(await budget.available(zeroAddress)).toBe(parseEther('1.0'));
+      expect(await budget.available()).toBe(parseEther('1.0'));
     });
 
     test('erc20', async () => {
@@ -105,7 +105,7 @@ describe.skip('VestingBudget', () => {
         target: defaultOptions.account.address,
       });
 
-      expect(await budget.available(zeroAddress)).toBe(0n);
+      expect(await budget.available()).toBe(0n);
     });
 
     test('erc20 assets', async () => {

package/src/Budgets/VestingBudget.ts

@@ -480,12 +480,12 @@ export class VestingBudget extends DeployableTarget<
    * This is equal to the sum of the total current balance and the total distributed amount
    *
    * @public
-   * @param {Address} asset -  The address of the asset (or the zero address for native assets)
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"] -  The address of the asset (or the zero address for native assets)
    * @param {?ReadParams<typeof vestingBudgetAbi, 'total'>} [params]
    * @returns {Promise<bigint>}
    */
   public total(
-    asset: Address,
+    asset: Address = zeroAddress,
     params?: ReadParams<typeof vestingBudgetAbi, 'total'>,
   ) {
     return readVestingBudgetTotal(this._config, {
@@ -501,12 +501,12 @@ export class VestingBudget extends DeployableTarget<
    * This is equal to the total vested amount minus any already distributed
    *
    * @public
-   * @param {Address} asset -  The address of the asset (or the zero address for native assets)
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"] -  The address of the asset (or the zero address for native assets)
    * @param {?ReadParams<typeof vestingBudgetAbi, 'available'>} [params]
    * @returns {Promise<bigint>} - The amount of assets currently available for distribution
    */
   public available(
-    asset: Address,
+    asset: Address = zeroAddress,
     params?: ReadParams<typeof vestingBudgetAbi, 'available'>,
   ) {
     return readVestingBudgetAvailable(this._config, {
@@ -521,12 +521,12 @@ export class VestingBudget extends DeployableTarget<
    * Get the amount of assets that have been distributed from the budget
    *
    * @public
-   * @param {Address} asset
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?ReadParams<typeof vestingBudgetAbi, 'distributed'>} [params]
    * @returns {Promise<bigint>} - The amount of assets distributed
    */
   public distributed(
-    asset: Address,
+    asset: Address = zeroAddress,
     params?: ReadParams<typeof vestingBudgetAbi, 'distributed'>,
   ) {
     return readVestingBudgetDistributed(this._config, {

package/src/Deployable/DeployableTarget.ts

@@ -75,7 +75,7 @@ export class DeployableTarget<
    */
   constructor(
     options: DeployableOptions,
-    payload: DeployablePayloadOrAddress<Payload>,
+    payload?: DeployablePayloadOrAddress<Payload>,
     isBase?: boolean,
   ) {
     super(options, payload);

package/src/Incentives/AllowListIncentive.test.ts

@@ -15,7 +15,7 @@ let fixtures: Fixtures;
 
 function freshAllowList(fixtures: Fixtures) {
   return function freshAllowList() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
       fixtures.core.SimpleAllowList({
         owner: defaultOptions.account.address,

package/src/Incentives/ERC20VariableIncentive.ts

@@ -56,7 +56,7 @@ export interface ERC20VariableIncentivePayload {
    */
   reward: bigint;
   /**
-   * How many times can this incentive be claimed.
+   * The total spending limit of the asset that will be distributed.
    *
    * @type {bigint}
    */
@@ -79,7 +79,7 @@ export type ERC20VariableIncentiveLog<
 > = GenericLog<typeof erc20VariableIncentiveAbi, event>;
 
 /**
- * A simple ERC20 incentive implementation that allows claiming of tokens
+ *  A modified ERC20 incentive implementation that allows claiming of variable token amounts with a spending limit
  *
  * @export
  * @class ERC20VariableIncentive
@@ -129,12 +129,12 @@ export class ERC20VariableIncentive extends DeployableTarget<
   }
 
   /**
-   * The current reward
+   * The total amount of rewards claimed
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>} [params]
-   * @returns {Promise<bigint>} - The current reward
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'totalClaimed'>} [params]
+   * @returns {Promise<bigint>}
    */
   public async totalClaimed(
     params?: ReadParams<typeof erc20VariableIncentiveAbi, 'totalClaimed'>,

package/src/Validators/SignerValidator.test.ts

@@ -16,7 +16,7 @@ function freshValidator(fixtures: Fixtures) {
   return function freshValidator() {
     // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
     const account = accounts.at(1)!.account;
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
       fixtures.core.SignerValidator({
         signers: [defaultOptions.account.address, account],