@boostxyz/sdk 2.1.2 → 2.2.1

package/src/Deployable/DeployableTargetWithRBAC.test.ts

@@ -8,6 +8,11 @@ import {
   freshManagedBudget,
 } from '@boostxyz/test/helpers';
 import { Roles } from './DeployableTargetWithRBAC';
+import { createTestClient, http, zeroAddress, publicActions, walletActions } from 'viem';
+import { setupConfig } from '@boostxyz/test/viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { hardhat } from 'viem/chains';
+import { ManagedBudget } from '../Budgets/ManagedBudget';
 
 let fixtures: Fixtures;
 
@@ -100,4 +105,174 @@ describe('RBAC', () => {
     expect(await budget.isAuthorized(user)).toBe(false);
     expect(await budget.rolesOf(user)).not.toContain(Roles.MANAGER);
   });
+
+  test('can transfer ownership', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const oldOwner = accounts[0].account;
+    const newOwner = accounts[9].account;
+    expect(await budget.owner()).toBe(oldOwner);
+    
+    // Transfer ownership
+    await budget.transferOwnership(newOwner);
+    
+    // Verify the new owner
+    expect(await budget.owner()).toBe(newOwner);
+  });
+
+  test('can renounce ownership', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const owner = accounts[0].account;
+    
+    // Verify initial owner
+    expect(await budget.owner()).toBe(owner);
+    
+    // Renounce ownership
+    await budget.renounceOwnership();
+    const newOwner = await budget.owner();
+    expect(newOwner).toBe(zeroAddress);
+  });
+
+  test('supports two-step ownership handover', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const currentOwner = accounts[0].account;
+    const newOwner = accounts[6];
+
+    const walletClient = createTestClient({
+      transport: http('http://127.0.0.1:8545', { retryCount: 0 }),
+      chain: hardhat,
+      mode: 'hardhat',
+      account: privateKeyToAccount(newOwner.key),
+      key: newOwner.key,
+    })
+    .extend(publicActions)
+    .extend(walletActions) as any;
+    
+    const newOwnerOptions = {
+      account: privateKeyToAccount(newOwner.key),
+      config: setupConfig(walletClient)
+    };
+
+    // Create budget instance with different signer
+    const sameBudgetDifferentSigner = new ManagedBudget(
+      { config: newOwnerOptions.config, account: newOwnerOptions.account },
+      budget.address
+    );
+    
+    await sameBudgetDifferentSigner.requestOwnershipHandover();
+
+    // Verify initial ownership
+    expect(await budget.owner()).toBe(currentOwner);
+    expect(await sameBudgetDifferentSigner.owner()).toBe(currentOwner);
+    
+    // Complete handover from current owner
+    await budget.completeOwnershipHandover(newOwner.account);
+    
+    // Verify ownership has transferred
+    expect(await budget.owner()).toBe(newOwner.account);
+    expect(await sameBudgetDifferentSigner.owner()).toBe(newOwner.account);
+  });
+
+  test('ownership handover fails if not requested', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const newOwner = accounts[7].account;
+    
+    // Try to complete handover without request
+    await expect(
+      budget.completeOwnershipHandover(newOwner)
+    ).rejects.toThrowError('NoHandoverRequest');
+  });
+
+  test('can cancel ownership handover', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const currentOwner = accounts[0].account;
+    const newOwner = accounts[6];
+    
+    // Create new options with new owner's account and wallet client
+    const walletClient = createTestClient({
+      transport: http('http://127.0.0.1:8545', { retryCount: 0 }),
+      chain: hardhat,
+      mode: 'hardhat',
+      account: privateKeyToAccount(newOwner.key),
+      key: newOwner.key,
+    })
+    .extend(publicActions)
+    .extend(walletActions) as any;
+    
+    const newOwnerOptions = {
+      account: privateKeyToAccount(newOwner.key),
+      config: setupConfig(walletClient)
+    };
+    
+    // Create budget instance with different signer
+    const sameBudgetDifferentSigner = new ManagedBudget(
+      { config: newOwnerOptions.config, account: newOwnerOptions.account },
+      budget.address
+    );
+    
+    // Request handover from new owner account
+    await sameBudgetDifferentSigner.requestOwnershipHandover();
+    
+    // Cancel the handover request
+    await sameBudgetDifferentSigner.cancelOwnershipHandover();
+    
+    // Verify handover can't be completed after cancellation
+    await expect(
+      budget.completeOwnershipHandover(newOwner.account)
+    ).rejects.toThrowError('NoHandoverRequest');
+    
+    // Verify ownership hasn't changed
+    expect(await budget.owner()).toBe(currentOwner);
+  });
+
+  test('can check ownership handover expiry', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const newOwner = accounts[6];
+    
+    const walletClient = createTestClient({
+      transport: http('http://127.0.0.1:8545', { retryCount: 0 }),
+      chain: hardhat,
+      mode: 'hardhat',
+      account: privateKeyToAccount(newOwner.key),
+      key: newOwner.key,
+    })
+    .extend(publicActions)
+    .extend(walletActions) as any;
+    
+    const newOwnerOptions = {
+      account: privateKeyToAccount(newOwner.key),
+      config: setupConfig(walletClient)
+    };
+    
+    // Create identical budget instance with different signer
+    const sameBudgetDifferentSigner = new ManagedBudget(
+      { config: newOwnerOptions.config, account: newOwnerOptions.account },
+      budget.address
+    );
+    
+    // Check expiry before request (should be 0)
+    expect(await budget.ownershipHandoverExpiresAt(newOwner.account)).toBe(0n);
+    
+    // Request handover
+    await sameBudgetDifferentSigner.requestOwnershipHandover();
+    
+    // Check expiry after request (should be > 0)
+    const expiryTime = await budget.ownershipHandoverExpiresAt(newOwner.account);
+    expect(expiryTime).toBeGreaterThan(0n);
+    
+    // Cancel request
+    await sameBudgetDifferentSigner.cancelOwnershipHandover();
+    
+    // Check expiry after cancellation (should be 0 again)
+    expect(await budget.ownershipHandoverExpiresAt(newOwner.account)).toBe(0n);
+  });
+
+  test('can renounce roles', async () => {
+    const budget = await loadFixture(freshManagedBudget(defaultOptions, fixtures));
+    const account = accounts[0];
+    const user = account.account;
+    
+    expect(await budget.hasAllRoles(user, Roles.ADMIN)).toBe(true);
+    await budget.renounceRoles(Roles.ADMIN);
+    expect(await budget.hasAllRoles(user, Roles.ADMIN)).toBe(false);
+  });
 });

package/src/Deployable/DeployableTargetWithRBAC.ts

@@ -1,14 +1,27 @@
 import {
   rbacAbi,
+  readOwnableRolesOwnershipHandoverExpiresAt,
   readRbacHasAllRoles,
   readRbacHasAnyRole,
   readRbacIsAuthorized,
   readRbacRolesOf,
+  simulateOwnableRolesCancelOwnershipHandover,
+  simulateOwnableRolesCompleteOwnershipHandover,
+  simulateOwnableRolesRenounceOwnership,
+  simulateOwnableRolesRenounceRoles,
+  simulateOwnableRolesRequestOwnershipHandover,
+  simulateOwnableRolesTransferOwnership,
   simulateRbacGrantManyRoles,
   simulateRbacGrantRoles,
   simulateRbacRevokeManyRoles,
   simulateRbacRevokeRoles,
   simulateRbacSetAuthorized,
+  writeOwnableRolesCancelOwnershipHandover,
+  writeOwnableRolesCompleteOwnershipHandover,
+  writeOwnableRolesRenounceOwnership,
+  writeOwnableRolesRenounceRoles,
+  writeOwnableRolesRequestOwnershipHandover,
+  writeOwnableRolesTransferOwnership,
   writeRbacGrantManyRoles,
   writeRbacGrantRoles,
   writeRbacRevokeManyRoles,
@@ -426,4 +439,272 @@ export class DeployableTargetWithRBAC<
       ...(params as any),
     });
   }
+
+  /**
+   * Transfer ownership of the contract to a new address
+   *
+   * @public
+   * @async
+   * @param {Address} newOwner - The address to transfer ownership to
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async transferOwnership(newOwner: Address, params?: WriteParams) {
+    return await this.awaitResult(this.transferOwnershipRaw(newOwner, params));
+  }
+
+  /**
+   * Transfer ownership of the contract to a new address
+   *
+   * @public
+   * @async
+   * @param {Address} newOwner - The address to transfer ownership to
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async transferOwnershipRaw(newOwner: Address, params?: WriteParams) {
+    const { request, result } = await simulateOwnableRolesTransferOwnership(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [newOwner],
+        ...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 writeOwnableRolesTransferOwnership(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Renounce ownership of the contract
+   *
+   * @public
+   * @async
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async renounceOwnership(params?: WriteParams) {
+    return await this.awaitResult(this.renounceOwnershipRaw(params));
+  }
+
+  /**
+   * Renounce ownership of the contract
+   *
+   * @public
+   * @async
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async renounceOwnershipRaw(params?: WriteParams) {
+    const { request, result } = await simulateOwnableRolesRenounceOwnership(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        ...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 writeOwnableRolesRenounceOwnership(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Request a two-step ownership handover to the caller
+   * The request will automatically expire in 48 hours
+   *
+   * Note: This is part of a two-step ownership transfer process:
+   * 1. New owner calls requestOwnershipHandover()
+   * 2. Current owner calls completeOwnershipHandover(newOwner)
+   *
+   * @public
+   * @async
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async requestOwnershipHandover(params?: WriteParams) {
+    return await this.awaitResult(this.requestOwnershipHandoverRaw(params));
+  }
+
+  /**
+   * Request a two-step ownership handover to the caller
+   * The request will automatically expire in 48 hours
+   *
+   * @public
+   * @async
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async requestOwnershipHandoverRaw(params?: WriteParams) {
+    const { request, result } =
+      await simulateOwnableRolesRequestOwnershipHandover(this._config, {
+        address: this.assertValidAddress(),
+        ...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 writeOwnableRolesRequestOwnershipHandover(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Complete a pending ownership handover to a new owner
+   * Must be called by the current owner after the new owner has requested the handover
+   *
+   * Note: This is part of a two-step ownership transfer process:
+   * 1. New owner calls requestOwnershipHandover()
+   * 2. Current owner calls completeOwnershipHandover(newOwner)
+   *
+   * @public
+   * @async
+   * @param {Address} pendingOwner - The address that requested the ownership handover
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async completeOwnershipHandover(
+    pendingOwner: Address,
+    params?: WriteParams,
+  ) {
+    return await this.awaitResult(
+      this.completeOwnershipHandoverRaw(pendingOwner, params),
+    );
+  }
+
+  /**
+   * Complete a pending ownership handover to a new owner
+   * Must be called by the current owner after the new owner has requested the handover
+   *
+   * @public
+   * @async
+   * @param {Address} pendingOwner - The address that requested the ownership handover
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async completeOwnershipHandoverRaw(
+    pendingOwner: Address,
+    params?: WriteParams,
+  ) {
+    const { request, result } =
+      await simulateOwnableRolesCompleteOwnershipHandover(this._config, {
+        address: this.assertValidAddress(),
+        args: [pendingOwner],
+        ...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 writeOwnableRolesCompleteOwnershipHandover(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Cancel a pending ownership handover request
+   * Must be called by the account that originally requested the handover
+   *
+   * @public
+   * @async
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async cancelOwnershipHandover(params?: WriteParams) {
+    return await this.awaitResult(this.cancelOwnershipHandoverRaw(params));
+  }
+
+  /**
+   * Cancel a pending ownership handover request
+   * Must be called by the account that originally requested the handover
+   *
+   * @public
+   * @async
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async cancelOwnershipHandoverRaw(params?: WriteParams) {
+    const { request, result } =
+      await simulateOwnableRolesCancelOwnershipHandover(this._config, {
+        address: this.assertValidAddress(),
+        ...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 writeOwnableRolesCancelOwnershipHandover(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Get the expiry timestamp for a pending ownership handover
+   * Returns 0 if there is no pending handover request for the given address
+   *
+   * @public
+   * @param {Address} pendingOwner - The address to check for pending handover requests
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - The timestamp when the handover request expires, or 0 if no request exists
+   */
+  public ownershipHandoverExpiresAt(
+    pendingOwner: Address,
+    params?: ReadParams,
+  ): Promise<bigint> {
+    return readOwnableRolesOwnershipHandoverExpiresAt(this._config, {
+      address: this.assertValidAddress(),
+      args: [pendingOwner],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Allow the caller to remove their own roles
+   * If the caller does not have a role, then it will be a no-op for that role
+   *
+   * @public
+   * @async
+   * @param {Roles} roles - Bitmap of roles to renounce
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async renounceRoles(roles: Roles, params?: WriteParams) {
+    return await this.awaitResult(this.renounceRolesRaw(roles, params));
+  }
+
+  /**
+   * Allow the caller to remove their own roles
+   * If the caller does not have a role, then it will be a no-op for that role
+   *
+   * @public
+   * @async
+   * @param {Roles} roles - Bitmap of roles to renounce
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async renounceRolesRaw(roles: Roles, params?: WriteParams) {
+    const { request, result } = await simulateOwnableRolesRenounceRoles(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [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 writeOwnableRolesRenounceRoles(this._config, request);
+    return { hash, result };
+  }
 }

package/src/Incentives/AllowListIncentive.test.ts

@@ -37,6 +37,7 @@ describe("AllowListIncentive", () => {
       reward: 1n,
       limit: 1n,
     });
+    // @ts-expect-error
     await action.deploy();
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
@@ -186,4 +187,51 @@ describe("AllowListIncentive", () => {
       expect(e).toBeInstanceOf(Error);
     }
   });
+
+  test("isClaimable returns expected values", async () => {
+    const referrer = accounts[1].account;
+    const trustedSigner = accounts[0];
+    const allowList = await loadFixture(freshAllowList(fixtures));
+    const allowListIncentive = new fixtures.bases.AllowListIncentive(
+      defaultOptions,
+      {
+        allowList: allowList.assertValidAddress(),
+        limit: 1n,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      incentives: [allowListIncentive],
+    });
+    await allowList.grantManyRoles(
+      [allowListIncentive.assertValidAddress()],
+      [Roles.MANAGER],
+    );
+
+    const claimant = trustedSigner.account;
+    const incentiveData = allowListIncentive.buildClaimData();
+
+    // Should be claimable before claiming
+    expect(await boost.incentives[0]!.isClaimable({ target: claimant })).toBe(true);
+
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    // Claim the incentive
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther("0.000075"), account: trustedSigner.privateKey },
+    );
+
+    // Should not be claimable after claiming
+    expect(await boost.incentives[0]!.isClaimable({ target: claimant })).toBe(false);
+  });
 });

package/src/Incentives/AllowListIncentive.ts

@@ -272,7 +272,7 @@ export class AllowListIncentive extends DeployableTarget<
   ) {
     return await readAllowListIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareClaimPayload(payload)],
+      args: [payload.target, '0x'],
       // 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/CGDAIncentive.test.ts

@@ -33,6 +33,7 @@ describe("CGDAIncentive", () => {
       rewardDecay: 1n,
       manager: budgets.budget.address || zeroAddress,
     });
+    // @ts-expect-error
     await action.deploy();
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
@@ -208,4 +209,53 @@ describe("CGDAIncentive", () => {
       true,
     );
   });
+
+  test("isClaimable returns expected values", async () => {
+    const referrer = accounts[1].account;
+    const trustedSigner = accounts[0];
+    const cgdaIncentive = 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,
+      incentives: [cgdaIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = cgdaIncentive.buildClaimData();
+
+    // Should be claimable before claiming
+    expect(await boost.incentives[0]!.isClaimable({
+      target: claimant,
+      data: incentiveData
+    })).toBe(true);
+
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    // Claim the incentive
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+
+    // Should not be claimable after claiming
+    expect(await boost.incentives[0]!.isClaimable({
+      target: claimant,
+      data: incentiveData
+    })).toBe(false);
+  });
 });

package/src/Incentives/CGDAIncentive.ts

@@ -375,7 +375,7 @@ export class CGDAIncentive extends DeployableTarget<
   public async isClaimable(payload: ClaimPayload, params?: ReadParams) {
     return await readCgdaIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareClaimPayload(payload)],
+      args: [payload.target, payload.data],
       // 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/ERC1155Incentive.ts

@@ -359,7 +359,7 @@ export class ERC1155Incentive extends DeployableTarget<
   public async isClaimable(payload: ClaimPayload, params?: ReadParams) {
     return await readErc1155IncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareClaimPayload(payload)],
+      args: [payload.target, payload.data],
       // 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/ERC20Incentive.test.ts

@@ -39,6 +39,7 @@ describe("ERC20Incentive", () => {
       limit: 1n,
       manager: zeroAddress,
     });
+    // @ts-expect-error
     await action.deploy();
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
@@ -205,4 +206,52 @@ describe("ERC20Incentive", () => {
       true,
     );
   });
+
+  test("isClaimable returns expected values", async () => {
+    const referrer = accounts[1].account;
+    const trustedSigner = accounts[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 = erc20Incentive.buildClaimData();
+
+    // Should be claimable before claiming
+    expect(await boost.incentives[0]!.isClaimable({
+      target: claimant,
+      data: incentiveData
+    })).toBe(true);
+
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    // Claim the incentive
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+
+    // Should not be claimable after claiming
+    expect(await boost.incentives[0]!.isClaimable({
+      target: claimant,
+      data: incentiveData
+    })).toBe(false);
+  });
 });