@boostxyz/sdk 2.1.1 → 2.2.0

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);
+  });
 });

package/src/Incentives/ERC20Incentive.ts

@@ -373,7 +373,7 @@ export class ERC20Incentive extends DeployableTarget<
   public async isClaimable(payload: ClaimPayload, params?: ReadParams) {
     return await readErc20IncentiveIsClaimable(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/ERC20VariableIncentive.test.ts

@@ -38,6 +38,7 @@ describe("ERC20VariableIncentive", () => {
       limit: 1n,
       manager: zeroAddress,
     });
+    // @ts-expect-error
     await action.deploy();
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
@@ -237,4 +238,51 @@ describe("ERC20VariableIncentive", () => {
       true,
     );
   });
+
+  test("isClaimable returns expected values", async () => {
+    const referrer = accounts[1].account;
+    const trustedSigner = accounts[0];
+    const erc20VariableIncentive = fixtures.core.ERC20VariableIncentive({
+      asset: budgets.erc20.assertValidAddress(),
+      reward: 1n,
+      limit: 1n,
+      manager: budgets.budget.assertValidAddress(),
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20VariableIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = erc20VariableIncentive.buildClaimData(parseEther("1"));
+
+    // 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/ERC20VariableIncentive.ts

@@ -346,7 +346,7 @@ export class ERC20VariableIncentive<
   public async isClaimable(payload: ClaimPayload, params?: ReadParams) {
     return await readErc20VariableIncentiveIsClaimable(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/Incentive.ts

@@ -12,6 +12,7 @@ import { readContract } from '@wagmi/core';
 import type { Address, Hex } from 'viem';
 import type { DeployableOptions } from '../Deployable/Deployable';
 import { InvalidComponentInterfaceError } from '../errors';
+import type { ReadParams } from '../utils';
 import { AllowListIncentive } from './AllowListIncentive';
 import { CGDAIncentive } from './CGDAIncentive';
 import { ERC20Incentive } from './ERC20Incentive';
@@ -73,11 +74,13 @@ export const IncentiveByComponentInterface = {
 export async function incentiveFromAddress(
   options: DeployableOptions,
   address: Address,
+  params?: ReadParams,
 ) {
   const interfaceId = (await readContract(options.config, {
     abi: aIncentiveAbi,
     functionName: 'getComponentInterface',
     address,
+    ...params,
   })) as keyof typeof IncentiveByComponentInterface;
   const Ctor = IncentiveByComponentInterface[interfaceId];
   if (!Ctor) {

package/src/Incentives/PointsIncentive.test.ts

@@ -32,6 +32,7 @@ describe("PointsIncentive", () => {
       reward: 1n,
       limit: 1n,
     });
+    // @ts-expect-error
     await action.deploy();
     expect(isAddress(action.assertValidAddress())).toBe(true);
   });
@@ -177,4 +178,54 @@ describe("PointsIncentive", () => {
       expect(e).toBeInstanceOf(Error);
     }
   });
+
+  test("isClaimable returns expected values", async () => {
+    const referrer = accounts[1].account;
+    const trustedSigner = accounts[0];
+    const pointsIncentive = fixtures.core.PointsIncentive({
+      venue: points.assertValidAddress(),
+      selector: bytes4("issue(address,uint256)"),
+      reward: 1n,
+      limit: 1n,
+    });
+    const boost = await freshBoost(fixtures, {
+      incentives: [pointsIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pointsIncentive.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,
+    });
+
+    await writePointsGrantRoles(defaultOptions.config, {
+      address: points.assertValidAddress(),
+      args: [pointsIncentive.assertValidAddress(), 2n],
+      account: defaultOptions.account,
+    });
+    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/PointsIncentive.ts

@@ -290,7 +290,7 @@ export class PointsIncentive extends DeployableTarget<
   public async isClaimable(payload: ClaimPayload, params?: ReadParams) {
     return await readPointsIncentiveIsClaimable(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),
     });