@boostxyz/sdk 5.5.0 → 6.0.1

package/src/BoostCore.test.ts

@@ -765,8 +765,8 @@ describe("BoostCore", () => {
     await new Promise((resolve) => {
       setTimeout(resolve, 500);
     });
-
-    expect(subscription).toHaveBeenCalledTimes(1);
+    // This should be called once for each event
+    expect(subscription).toHaveBeenCalledTimes(2);
   });
 
   test("can set a passthrough auth scheme", async () => {
@@ -953,3 +953,125 @@ describe("BoostCore", () => {
     expect(feesInfo.asset.toLowerCase()).toBe(erc20.assertValidAddress());
   });
 });
+
+describe("Top-Up Incentives", () => {
+  let incentive: ReturnType<typeof fixtures.core.ERC20Incentive>;
+  let boostId: bigint;
+
+  beforeAll(async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+
+    incentive = core.ERC20Incentive({
+      asset: erc20.assertValidAddress(),
+      strategy: StrategyType.POOL,
+      reward: parseEther("1"),
+      limit: 5n,
+      manager: budget.assertValidAddress(),
+    });
+    await erc20.mint(defaultOptions.account.address, parseEther("110"));
+    await erc20.approve(budget.assertValidAddress(), parseEther("110"));
+    await budget.allocate({
+      amount: parseEther("110"),
+      asset: erc20.assertValidAddress(),
+      target: defaultOptions.account.address,
+    });
+    
+
+    const createdBoost = await core.createBoost({
+      protocolFee: 0n,
+      maxParticipants: 5n,
+      budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      validator: core.SignerValidator({
+        signers: [defaultOptions.account.address],
+        validatorCaller: defaultOptions.account.address,
+      }),
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [incentive],
+    });
+    boostId = createdBoost.id;
+  });
+
+  test("can top up from a budget (pre-fee)", async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+
+    console.log("budget", budget.assertValidAddress());
+
+    const netTopup = parseEther("5");
+
+    await core.topupIncentiveFromBudgetPreFee(boostId, 0n, netTopup, budget.assertValidAddress());
+    console.log("topup done");
+
+    expect(await incentive.limit()).toBe(5n + 5n); // original limit 5 + topup 5
+  });
+
+  test("can top up from a budget (post-fee)", async () => {
+    const { core } = fixtures;
+    const { budget } = budgets;
+
+    const total = parseEther("5.5");
+    await core.topupIncentiveFromBudgetPostFee(boostId, 0n, total, budget.assertValidAddress());
+
+    expect(await incentive.limit()).toBe(10n + 5n);
+  });
+
+  test("pre-fee and post-fee top-ups lead to the same net top-up", async () => {
+    const { core } = fixtures;
+    const { budget } = budgets;
+
+    const net = parseEther("2");
+    const netPlusFee = parseEther("2.2");
+
+    await core.topupIncentiveFromBudgetPreFee(boostId, 0n, net, budget.assertValidAddress());
+
+    await core.topupIncentiveFromBudgetPostFee(boostId, 0n, netPlusFee, budget.assertValidAddress());
+
+    expect(await incentive.limit()).toBe(15n + 4n);
+  });
+
+  test("can top up from sender (pre-fee)", async () => {
+    const { core } = fixtures;
+    const { erc20 } = budgets;
+
+    const netTopup = parseEther("10");
+    const netPlusFee = parseEther("11");
+    await erc20.mint(defaultOptions.account.address, netPlusFee);
+    await erc20.approve(core.assertValidAddress(), netPlusFee);
+
+    await core.topupIncentiveFromSenderPreFee(boostId, 0n, netTopup);
+
+    expect(await incentive.limit()).toBe(19n + 10n);
+  });
+
+  test("can top up from sender (post-fee)", async () => {
+    const { core } = fixtures;
+    const { erc20 } = budgets;
+
+    const totalWithFee = parseEther("5.5");
+    await erc20.mint(defaultOptions.account.address, totalWithFee);
+    await erc20.approve(core.assertValidAddress(), totalWithFee);
+
+    await core.topupIncentiveFromSenderPostFee(boostId, 0n, totalWithFee);
+
+    expect(await incentive.limit()).toBe(29n + 5n);
+  });
+
+  test("throws if net top-up is zero", async () => {
+    const { core } = fixtures;
+    const { budget } = budgets;
+
+    await expect(async () => {
+      await core.topupIncentiveFromBudgetPreFee(boostId, 0n, 0n, budget.assertValidAddress());
+    }).rejects.toThrowError();
+  });
+});

package/src/BoostCore.ts

@@ -12,11 +12,15 @@ import {
   simulateBoostCoreCreateBoost,
   simulateBoostCoreSetCreateBoostAuth,
   simulateBoostCoreSetProtocolFeeReceiver,
+  simulateBoostCoreTopupIncentiveFromBudget,
+  simulateBoostCoreTopupIncentiveFromSender,
   writeBoostCoreClaimIncentive,
   writeBoostCoreClaimIncentiveFor,
   writeBoostCoreCreateBoost,
   writeBoostCoreSetCreateBoostAuth,
   writeBoostCoreSetProtocolFeeReceiver,
+  writeBoostCoreTopupIncentiveFromBudget,
+  writeBoostCoreTopupIncentiveFromSender,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/BoostCore.sol/BoostCore.json';
 import {
@@ -24,6 +28,7 @@ import {
   getAccount,
   getChains,
   getTransactionReceipt,
+  readContract,
   waitForTransactionReceipt,
 } from '@wagmi/core';
 import { createWriteContract } from '@wagmi/core/codegen';
@@ -31,6 +36,8 @@ import {
   type Address,
   type ContractEventName,
   type Hex,
+  decodeAbiParameters,
+  encodeAbiParameters,
   encodePacked,
   keccak256,
   parseEventLogs,
@@ -67,6 +74,10 @@ import {
   ManagedBudgetWithFees,
   type ManagedBudgetWithFeesPayload,
 } from './Budgets/ManagedBudgetWithFees';
+import {
+  ManagedBudgetWithFeesV2,
+  type ManagedBudgetWithFeesV2Payload,
+} from './Budgets/ManagedBudgetWithFeesV2';
 import {
   Deployable,
   type DeployableOptions,
@@ -1394,6 +1405,34 @@ export class BoostCore extends Deployable<
       options,
     );
   }
+  /**
+   * Bound {@link ManagedBudgetWithFeesV2} constructor that reuses the same configuration as the Boost Core instance.
+   * Prepends the BoostCore address to the authorized list because it's structurally critical to calculating payouts.
+   *
+   * @example
+   * ```ts
+   * const budget = core.ManagedBudgetWithFeesV2('0x') // is roughly equivalent to
+   * const budget = new ManagedBudgetWithFeesV2({ config: core._config, account: core._account }, '0x')
+   * ```
+   * @param {DeployablePayloadOrAddress<ManagedBudgetWithFeesV2Payload>} options
+   * @returns {ManagedBudgetWithFeesV2}
+   */
+  ManagedBudgetWithFeesV2(
+    options: DeployablePayloadOrAddress<ManagedBudgetWithFeesV2Payload>,
+  ) {
+    if (
+      typeof options !== 'string' &&
+      !options.authorized.includes(this.assertValidAddress())
+    ) {
+      options.authorized = [this.assertValidAddress(), ...options.authorized];
+      options.roles = [Roles.MANAGER, ...options.roles];
+    }
+
+    return new ManagedBudgetWithFeesV2(
+      { config: this._config, account: this._account },
+      options,
+    );
+  }
   // /**
   //  * Bound {@link VestingBudget} constructor that reuses the same configuration as the Boost Core instance.
   //  *
@@ -1654,4 +1693,224 @@ export class BoostCore extends Deployable<
       ...this.optionallyAttachAccount(options.account),
     };
   }
+  /**
+   * Prepares and executes a top-up from a Budget, specifying the net top-up amount
+   * that should land in the incentive (the protocol fee is added automatically).
+   *
+   * @public
+   * @async
+   * @param {bigint} boostId The ID of the Boost
+   * @param {bigint} incentiveId The ID of the incentive within that Boost
+   * @param {any} topupPayload A typed struct for the incentive’s top-up parameters
+   * @param {Address} [budget] Optional override budget address (otherwise uses the Boost’s budget)
+   * @param {?WriteParams} [params] Additional transaction overrides
+   * @returns {Promise<{ hash: Hex; result: void }>} The transaction hash and simulation result
+   */
+  public async topupIncentiveFromBudgetPreFee(
+    boostId: bigint,
+    incentiveId: bigint,
+    topupAmount: bigint,
+    budget?: Address,
+    params?: WriteParams,
+  ) {
+    const boost = await this.getBoost(boostId, params as ReadParams);
+    if (incentiveId >= boost.incentives.length) {
+      throw new Error(`Incentive ID ${incentiveId} out of range`);
+    }
+    const incentive = boost.incentives[Number(incentiveId)];
+    if (!incentive) {
+      throw new Error(`Incentive with ID ${incentiveId} not found`);
+    }
+
+    const incentiveData = await incentive.getTopupPayload(topupAmount);
+
+    if (!(topupAmount > 0)) {
+      throw new Error('Top-up amount must be greater than zero');
+    }
+
+    return await this.topupIncentiveFromBudgetRaw(
+      boostId,
+      incentiveId,
+      incentiveData,
+      budget,
+      params,
+    );
+  }
+
+  /**
+   * Prepares and executes a top-up from a Budget, specifying the entire total tokens
+   * (incentive + fee) you want to disburse. We'll back-calculate how many tokens land
+   * in the incentive.
+   *
+   * @public
+   * @async
+   * @param {bigint} boostId The ID of the Boost
+   * @param {bigint} incentiveId The ID of the incentive within that Boost
+   * @param {any} topupPayload A typed struct for the incentive’s top-up parameters
+   * @param {bigint} totalAmount The total tokens to disburse
+   * @param {Address} [budget] Optional override budget address
+   * @param {?WriteParams} [params] Additional transaction overrides
+   * @returns {Promise<{ hash: Hex; result: void }>}
+   */
+  public async topupIncentiveFromBudgetPostFee(
+    boostId: bigint,
+    incentiveId: bigint,
+    totalAmount: bigint,
+    budget?: Address,
+    params?: WriteParams,
+  ) {
+    const feeBps = await this.protocolFee(params as ReadParams);
+    const topupAmount =
+      (totalAmount * FEE_DENOMINATOR) / (FEE_DENOMINATOR + feeBps);
+    return this.topupIncentiveFromBudgetPreFee(
+      boostId,
+      incentiveId,
+      topupAmount,
+      budget,
+      params,
+    );
+  }
+
+  /**
+   * Prepares and executes a top-up from the caller (msg.sender), specifying the net top-up
+   * to land in the incentive. We'll add the protocol fee on top automatically.
+   *
+   * @public
+   * @async
+   * @param {bigint} boostId The ID of the Boost
+   * @param {bigint} incentiveId The ID of the incentive within that Boost
+   * @param {any} topupPayload A typed struct for the incentive’s top-up parameters
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: Hex; result: void }>}
+   */
+  public async topupIncentiveFromSenderPreFee(
+    boostId: bigint,
+    incentiveId: bigint,
+    topupAmount: bigint,
+    params?: WriteParams,
+  ) {
+    const boost = await this.getBoost(boostId, params as ReadParams);
+    if (incentiveId >= boost.incentives.length) {
+      throw new Error(`Incentive ID ${incentiveId} out of range`);
+    }
+    const incentive = boost.incentives[Number(incentiveId)];
+    if (!incentive) {
+      throw new Error(`Incentive with ID ${incentiveId} not found`);
+    }
+
+    if (!(topupAmount > 0)) {
+      throw new Error('Top-up amount must be greater than zero');
+    }
+
+    const incentiveData = await incentive.getTopupPayload(topupAmount);
+
+    return await this.topupIncentiveFromSenderRaw(
+      boostId,
+      incentiveId,
+      incentiveData,
+      params,
+    );
+  }
+
+  /**
+   * Prepares and executes a top-up from the caller (msg.sender), specifying the total
+   * tokens you’re willing to provide (including fee). We'll back-calculate the net
+   * top-up for the incentive.
+   *
+   * @public
+   * @async
+   * @param {bigint} boostId The ID of the Boost
+   * @param {bigint} incentiveId The ID of the incentive within that Boost
+   * @param {any} topupPayload A typed struct for the incentive’s top-up parameters
+   * @param {bigint} totalAmount The entire tokens (top-up + fee)
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: Hex; result: void }>}
+   */
+  public async topupIncentiveFromSenderPostFee(
+    boostId: bigint,
+    incentiveId: bigint,
+    totalAmount: bigint,
+    params?: WriteParams,
+  ) {
+    const feeBps = await this.protocolFee(params as ReadParams);
+    const topupAmount =
+      (totalAmount * FEE_DENOMINATOR) / (FEE_DENOMINATOR + feeBps);
+
+    return this.topupIncentiveFromSenderPreFee(
+      boostId,
+      incentiveId,
+      topupAmount,
+      params,
+    );
+  }
+
+  /**
+   * A lower-level function that actually calls `topupIncentiveFromSender` on-chain,
+   * passing the final total. The contract modifies its internal logic to split net top-up vs. fee.
+   *
+   * @private
+   * @param {bigint} boostId
+   * @param {bigint} incentiveId
+   * @param {Hex} preflightData The raw ABudget.Transfer data from preflight
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: Hex; result: void }>}
+   */
+  private async topupIncentiveFromSenderRaw(
+    boostId: bigint,
+    incentiveId: bigint,
+    preflightData: Hex,
+    params?: WriteParams,
+  ) {
+    const { request, result } = await simulateBoostCoreTopupIncentiveFromSender(
+      this._config,
+      {
+        ...this.optionallyAttachAccount(),
+        ...(params as object),
+        address: this.assertValidAddress(),
+        args: [boostId, incentiveId, preflightData],
+      },
+    );
+    const hash = await writeBoostCoreTopupIncentiveFromSender(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * A lower-level function that actually calls `topupIncentiveFromBudget` on-chain,
+   * passing the preflight data plus the final total. The contract itself modifies
+   * the amount to (topup + fee).
+   *
+   * @private
+   * @param {bigint} boostId
+   * @param {bigint} incentiveId
+   * @param {Hex} preflightData The raw ABudget.Transfer (encoded) from preflight
+   * @param {Address} [budget] Optional override for the budget
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: Hex; result: void }>}
+   */
+  private async topupIncentiveFromBudgetRaw(
+    boostId: bigint,
+    incentiveId: bigint,
+    preflightData: Hex,
+    budget?: Address,
+    params?: WriteParams,
+  ) {
+    // e.g. run "simulate + write" pattern
+    const { request, result } = await simulateBoostCoreTopupIncentiveFromBudget(
+      this._config,
+      {
+        ...this.optionallyAttachAccount(),
+        ...(params as object),
+        address: this.assertValidAddress(),
+        args: [boostId, incentiveId, preflightData, budget ?? zeroAddress],
+      },
+    );
+    const hash = await writeBoostCoreTopupIncentiveFromBudget(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
 }

package/src/Budgets/Budget.ts

@@ -2,6 +2,7 @@ import { aBudgetAbi } from '@boostxyz/evm';
 import {
   AManagedBudget,
   AManagedBudgetWithFees,
+  AManagedBudgetWithFeesV2,
 } from '@boostxyz/evm/deploys/componentInterfaces.json';
 import { readContract } from '@wagmi/core';
 import type { Address, Hex } from 'viem';
@@ -10,6 +11,7 @@ import { InvalidComponentInterfaceError } from '../errors';
 import type { ReadParams } from '../utils';
 import { ManagedBudget } from './ManagedBudget';
 import { ManagedBudgetWithFees } from './ManagedBudgetWithFees';
+import { ManagedBudgetWithFeesV2 } from './ManagedBudgetWithFeesV2';
 
 export {
   // VestingBudget,
@@ -22,7 +24,10 @@ export {
  * @export
  * @typedef {Budget}
  */
-export type Budget = ManagedBudget | ManagedBudgetWithFees; // | VestingBudget
+export type Budget =
+  | ManagedBudget
+  | ManagedBudgetWithFees
+  | ManagedBudgetWithFeesV2; // | VestingBudget
 
 /**
  * A map of Budget component interfaces to their constructors.
@@ -34,6 +39,7 @@ export const BudgetByComponentInterface = {
   // ['0x2929d19c']: SimpleBudget,
   [AManagedBudget as Hex]: ManagedBudget,
   [AManagedBudgetWithFees as Hex]: ManagedBudgetWithFees,
+  [AManagedBudgetWithFeesV2 as Hex]: ManagedBudgetWithFeesV2,
 };
 
 /**
@@ -43,7 +49,7 @@ export const BudgetByComponentInterface = {
  * @async
  * @param {DeployableOptions} options
  * @param {Address} address
- * @returns {Promise<ManagedBudget | ManagedBudgetWithFees>}
+ * @returns {Promise<ManagedBudget | ManagedBudgetWithFees | ManagedBudgetWithFeesV2>}
  * @throws {@link InvalidComponentInterfaceError}
  */
 export async function budgetFromAddress(

package/src/Budgets/ManagedBudgetWithFees.test.ts

@@ -12,7 +12,6 @@ import {
   freshManagedBudgetWithFees,
   fundErc20,
   fundErc1155,
-  fundManagedBudget,
   freshBoost,
   fundManagedBudgetWithFees,
 } from "@boostxyz/test/helpers";