@boostxyz/sdk 6.1.2 → 7.0.0-canary.0

package/src/Budgets/TransparentBudget.ts

@@ -0,0 +1,334 @@
+import {
+  readTransparentBudgetDistributed,
+  readTransparentBudgetOwner,
+  readTransparentBudgetTotal,
+  simulateTransparentBudgetClawbackFromTarget,
+  simulateTransparentBudgetDisburse,
+  simulateTransparentBudgetDisburseBatch,
+  transparentBudgetAbi,
+  writeTransparentBudgetClawbackFromTarget,
+  writeTransparentBudgetDisburse,
+  writeTransparentBudgetDisburseBatch,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/budgets/TransparentBudget.sol/TransparentBudget.json';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  zeroAddress,
+  zeroHash,
+} from 'viem';
+import { TransparentBudget as TransparentBudgetBases } from '../../dist/deployments.json';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
+import type {
+  ERC1155TransferPayload,
+  FungibleTransferPayload,
+} from '../transfers';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+} from '../utils';
+import { prepareTransfer } from './ManagedBudget';
+export { transparentBudgetAbi };
+export type { ERC1155TransferPayload, FungibleTransferPayload };
+
+/**
+ * A generic `viem.Log` event with support for `TransparentBudget` event types.
+ *
+ * @export
+ * @typedef {TransparentBudgetLog}
+ * @template {ContractEventName<typeof transparentBudgetAbi>} [event=ContractEventName<
+ *     typeof transparentBudgetAbi
+ *   >]
+ */
+export type TransparentBudgetLog<
+  event extends ContractEventName<
+    typeof transparentBudgetAbi
+  > = ContractEventName<typeof transparentBudgetAbi>,
+> = GenericLog<typeof transparentBudgetAbi, event>;
+
+/**
+ * A budget implementation that transfers assets to the budget on Boost creation.
+ * Can be used with or without [Permit2](https://github.com/Uniswap/permit2) for token approval
+ *
+ * @export
+ * @class TransparentBudget
+ * @typedef {TransparentBudget}
+ * @extends {DeployableTargetWithRBAC<TransparentBudgetPayload>}
+ */
+export class TransparentBudget extends DeployableTargetWithRBAC<
+  never,
+  typeof transparentBudgetAbi
+> {
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @readonly
+   * @type {*}
+   */
+  public override readonly abi = transparentBudgetAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Record<number, Address>}
+   */
+  public static override bases: Record<number, Address> = {
+    31337: import.meta.env.VITE_TRANSPARENT_BUDGET_BASE,
+    ...(TransparentBudgetBases as Record<number, Address>),
+  };
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.BUDGET;
+
+  /**
+   * Clawbacks assets from an incentive associated with the budget via Boost Core.
+   * Only the authorized users can clawback assets from an incentive.
+   * If the asset transfer fails, the reclamation will revert.
+   *
+   * @example
+   * ```ts
+   * const [amount, address] = await budgets.budget.clawbackFromTarget(
+   *   core.assertValidAddress(),
+   *   erc20Incentive.buildClawbackData(1n),
+   *   boost.id,
+   *   incentiveId,
+   * );
+   * ```
+   * @public
+   * @async
+   * @param {Address} target - The address of a contract implementing clawback, typically `BoostCore`
+   * @param {Hex} data - The encoded data payload for the clawback, can be acquired with `incentive.buildClawbackData`
+   * @param {bigint | number} boostId - The ID of the boost
+   * @param {bigint | number} incentiveId - The ID of the incentive
+   * @param {?WriteParams} [params] - Optional write parameters
+   * @returns {Promise<[bigint, Address]>} - Returns a tuple of amount reclaimed and the address reclaimed from
+   */
+  public async clawbackFromTarget(
+    target: Address,
+    data: Hex,
+    boostId: bigint | number,
+    incentiveId: bigint | number,
+    params?: WriteParams,
+  ) {
+    return await this.awaitResult(
+      this.clawbackFromTargetRaw(target, data, boostId, incentiveId, params),
+    );
+  }
+
+  /**
+   * Clawbacks assets from an incentive associated with the budget via Boost Core.
+   * Only the authorized users can clawback assets from an incentive.
+   * If the asset transfer fails, the reclamation will revert.
+   *
+   * @example
+   * ```ts
+   * const { hash, result: [ amount, address ] } = await budgets.budget.clawbackFromTargetRaw(
+   *   core.assertValidAddress(),
+   *   erc20Incentive.buildClawbackData(1n),
+   *   boost.id,
+   *   incentiveId,
+   * );
+   * ```
+   * @public
+   * @async
+   * @param {Address} target - The address of a contract implementing clawback, typically `BoostCore`
+   * @param {Hex} data - The encoded data payload for the clawback, can be acquired with `incentive.buildClawbackData`
+   * @param {bigint | number} boostId - The ID of the boost
+   * @param {bigint | number} incentiveId - The ID of the incentive
+   * @param {?WriteParams} [params] - Optional write parameters
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - Returns transaction hash and simulated result
+   */
+  public async clawbackFromTargetRaw(
+    target: Address,
+    data: Hex,
+    boostId: bigint | number,
+    incentiveId: bigint | number,
+    params?: WriteParams,
+  ) {
+    const { request, result } =
+      await simulateTransparentBudgetClawbackFromTarget(this._config, {
+        address: this.assertValidAddress(),
+        args: [target, data, BigInt(boostId), BigInt(incentiveId)],
+        ...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 writeTransparentBudgetClawbackFromTarget(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Disburses assets from the budget to a single recipient
+   * If the asset transfer fails, the disbursement will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams} [params]
+   * @returns {Promise<boolean>} - True if the disbursement was successful
+   */
+  public async disburse(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams,
+  ) {
+    return await this.awaitResult(this.disburseRaw(transfer, params));
+  }
+
+  /**
+   * Disburses assets from the budget to a single recipient
+   * If the asset transfer fails, the disbursement will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the disbursement was successful
+   */
+  public async disburseRaw(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams,
+  ) {
+    const { request, result } = await simulateTransparentBudgetDisburse(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [prepareTransfer(transfer)],
+        ...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 writeTransparentBudgetDisburse(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Disburses assets from the budget to multiple recipients
+   *
+   * @public
+   * @async
+   * @param {Array<FungibleTransferPayload | ERC1155TransferPayload>} transfers
+   * @param {?WriteParams} [params]
+   * @returns {Promise<boolean>} - True if all disbursements were successful
+   */
+  public async disburseBatch(
+    transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
+    params?: WriteParams,
+  ) {
+    return await this.awaitResult(this.disburseBatchRaw(transfers, params));
+  }
+
+  /**
+   * Disburses assets from the budget to multiple recipients
+   *
+   * @public
+   * @async
+   * @param {Array<FungibleTransferPayload | ERC1155TransferPayload>} transfers
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if all disbursements were successful
+   */
+  public async disburseBatchRaw(
+    transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
+    params?: WriteParams,
+  ) {
+    const { request, result } = await simulateTransparentBudgetDisburseBatch(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [transfers.map(prepareTransfer)],
+        ...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 writeTransparentBudgetDisburseBatch(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Get the total amount of assets allocated to the budget, including any that have been distributed
+   * 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="0x0000000000000000000000000000000000000000"] - The address of the asset
+   * @param {?(bigint | undefined)} [tokenId] - The ID of the token
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - The total amount of assets
+   */
+  public total(
+    asset: Address = zeroAddress,
+    tokenId?: bigint | undefined,
+    params?: ReadParams,
+  ) {
+    return readTransparentBudgetTotal(this._config, {
+      address: this.assertValidAddress(),
+      args: tokenId ? [asset, tokenId] : [asset],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Get the amount of assets that have been distributed from the budget.
+   * If a tokenId is provided, get the amount of ERC1155 assets that have been distributed from the budget
+   *
+   * @public
+   * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
+   * @param {?(bigint | undefined)} [tokenId]
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - The amount of assets distributed
+   */
+  public distributed(
+    asset: Address = zeroAddress,
+    tokenId?: bigint | undefined,
+    params?: ReadParams,
+  ) {
+    return readTransparentBudgetDistributed(this._config, {
+      address: this.assertValidAddress(),
+      args: tokenId ? [asset, tokenId] : [asset],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?TransparentBudgetPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: never,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [_, options] = this.validateDeploymentConfig({}, _options);
+    return {
+      abi: transparentBudgetAbi,
+      bytecode: bytecode as Hex,
+      args: [zeroHash],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Deployable/Deployable.ts

@@ -27,7 +27,7 @@ export type GenericDeployableParams = Omit<
   Parameters<typeof deployContract>[1],
   'args' | 'account'
 > & {
-  args: [Hex, ...Array<Hex>];
+  args: [Hex, ...Array<Hex>] | [];
   account?: Account;
 };
 

package/src/Incentives/ERC20PeggedIncentive.ts

@@ -503,7 +503,7 @@ export class ERC20PeggedIncentive extends DeployableTarget<
    *
    * @public
    * @param {Hex} claimData
-   * @returns {BigInt} Returns the reward amount from a claim data payload
+   * @returns {bigint} Returns the reward amount from a claim data payload
    */
   public decodeClaimData(claimData: Hex) {
     const boostClaimData = decodeAbiParameters(

package/src/Incentives/{ERC20PeggedVariableCriteriaIncentive.test.ts → ERC20PeggedVariableCriteriaIncentiveV2.test.ts}

@@ -23,15 +23,15 @@ import {
   zeroHash,
 } from "viem";
 import { beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { SignatureType } from "../Actions/EventAction";
+import { SignatureType, ValueType } from "../Actions/EventAction";
 import type { Boost } from "../Boost";
 import {
-  type ERC20PeggedVariableCriteriaIncentive,
-} from "./ERC20PeggedVariableCriteriaIncentive";
+  type ERC20PeggedVariableCriteriaIncentiveV2,
+} from "./ERC20PeggedVariableCriteriaIncentiveV2";
 import {
   type IncentiveCriteria,
   gasRebateIncentiveCriteria,
-} from "./ERC20VariableCriteriaIncentive";
+} from "./ERC20VariableCriteriaIncentiveV2";
 import { allKnownSignatures } from "@boostxyz/test/allKnownSignatures";
 import { readMockErc20BalanceOf } from "@boostxyz/evm";
 
@@ -49,6 +49,7 @@ export function basicErc721TransferScalarCriteria(
     signature: funcSelectors["transferFrom(address,address,uint256)"] as Hex, // Function selector for mint
     fieldIndex: 2, // Field where the scalar value resides
     targetContract: erc721.assertValidAddress(),
+    valueType: ValueType.WAD,
   };
 }
 
@@ -68,13 +69,14 @@ export function basicErc721MintScalarCriteria(
     ] as Hex, // Function selector for mint
     fieldIndex: 2, // Field where the scalar value resides
     targetContract: erc721.assertValidAddress(),
+    valueType: ValueType.WAD,
   };
 }
 
 let fixtures: Fixtures,
   erc20: MockERC20,
   erc721: MockERC721,
-  erc20PeggedVariableCriteriaIncentive: ERC20PeggedVariableCriteriaIncentive,
+  erc20PeggedVariableCriteriaIncentive: ERC20PeggedVariableCriteriaIncentiveV2,
   budgets: BudgetFixtures,
   boost: Boost;
 
@@ -87,7 +89,7 @@ describe("ERC20PeggedVariableCriteriaIncentive", () => {
     budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
     erc20 = await loadFixture(fundErc20(defaultOptions));
     erc721 = await loadFixture(fundErc721(defaultOptions));
-    erc20PeggedVariableCriteriaIncentive = fixtures.core.ERC20PeggedVariableCriteriaIncentive({
+    erc20PeggedVariableCriteriaIncentive = fixtures.core.ERC20PeggedVariableCriteriaIncentiveV2({
       asset: budgets.erc20.assertValidAddress(),
       reward: parseEther("1"),
       limit: parseEther("10"),
@@ -146,7 +148,7 @@ describe("ERC20PeggedVariableCriteriaIncentive", () => {
 
   describe("getIncentiveCriteria", () => {
     test("should fetch incentive criteria successfully", async () => {
-      const incentive = boost.incentives[0] as ERC20PeggedVariableCriteriaIncentive;
+      const incentive = boost.incentives[0] as ERC20PeggedVariableCriteriaIncentiveV2;
       const criteria = await incentive.getIncentiveCriteria();
       expect(criteria).toMatchObject({
         criteriaType: SignatureType.FUNC,
@@ -224,7 +226,7 @@ describe("ERC20PeggedVariableCriteriaIncentive", () => {
       // Ensure that the gasRebateIncentiveCriteria returns the correct structure
       const gasRebateCriteria = gasRebateIncentiveCriteria();
 
-      erc20PeggedVariableCriteriaIncentive = fixtures.core.ERC20PeggedVariableCriteriaIncentive({
+      erc20PeggedVariableCriteriaIncentive = fixtures.core.ERC20PeggedVariableCriteriaIncentiveV2({
         asset: budgets.erc20.assertValidAddress(),
         reward: 1n,
         limit: 1n,
@@ -239,6 +241,7 @@ describe("ERC20PeggedVariableCriteriaIncentive", () => {
         signature: zeroHash,
         fieldIndex: 255,
         targetContract: zeroAddress,
+        valueType: ValueType.WAD,
       });
 
       boost = await freshBoost(fixtures, {
@@ -248,12 +251,13 @@ describe("ERC20PeggedVariableCriteriaIncentive", () => {
 
       // Validate that the deployed incentive has the correct criteria set up
       const deployedIncentive = (await boost
-        .incentives[0]) as ERC20PeggedVariableCriteriaIncentive;
+        .incentives[0]) as ERC20PeggedVariableCriteriaIncentiveV2;
       const deployedCriteria = await deployedIncentive.getIncentiveCriteria();
       expect(deployedCriteria.criteriaType).toBe(SignatureType.EVENT);
       expect(deployedCriteria.signature).toBe(zeroHash);
       expect(deployedCriteria.fieldIndex).toBe(255);
       expect(deployedCriteria.targetContract).toBe(zeroAddress);
+      expect(deployedCriteria.valueType).toBe(ValueType.WAD);
     });
 
     test("should throw NoMatchingLogsError for event criteria with no matching logs", async () => {
@@ -290,7 +294,7 @@ describe("ERC20PeggedVariableCriteriaIncentive", () => {
 
   test("can properly encode a uint256", () => {
     //@ts-ignore
-    const incentive = fixtures.core.ERC20VariableCriteriaIncentive();
+    const incentive = fixtures.core.ERC20VariableCriteriaIncentiveV2();
     expect(incentive.buildClawbackData(1n)).toBe(
       "0x0000000000000000000000000000000000000000000000000000000000000001",
     );