@boostxyz/sdk 0.0.0-alpha.16 → 0.0.0-alpha.18

package/src/BoostCore.test.ts

@@ -1,11 +1,12 @@
 import { loadFixture } from '@nomicfoundation/hardhat-toolbox-viem/network-helpers';
-import { parseEther, zeroAddress } from 'viem';
+import { pad, parseEther, zeroAddress } from 'viem';
 import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import {
   type BudgetFixtures,
   type Fixtures,
   defaultOptions,
   deployFixtures,
+  freshBoost,
   fundBudget,
   makeMockEventActionPayload,
 } from '@boostxyz/test/helpers';
@@ -14,6 +15,8 @@ import type { ERC20Incentive } from './Incentives/ERC20Incentive';
 import { StrategyType } from './claiming';
 import { IncentiveNotCloneableError } from './errors';
 import { bytes4 } from './utils';
+import { BOOST_CORE_CLAIM_FEE } from './BoostCore';
+import { accounts } from '@boostxyz/test/accounts';
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
 
@@ -708,4 +711,117 @@ describe('BoostCore', () => {
     );
     expect(await core.isAuthorized(zeroAddress)).toBe(true);
   });
+
+  test('uses the provided validator when one is specified', async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+    const customValidator = core.SignerValidator({
+      signers: [budget.assertValidAddress()],
+      validatorCaller: core.assertValidAddress(),
+    });
+    const boost = await core.createBoost({
+      maxParticipants: 100n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      validator: customValidator,
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther('1'),
+          limit: 100n,
+          strategy: StrategyType.POOL,
+        }),
+      ],
+    });
+
+    expect(boost.validator).toBe(customValidator);
+    const signers = await boost.validator.signers(budget.assertValidAddress());
+    expect(signers).toBe(true);
+  });
+
+  test('creates a boost with a default validator when none is provided', async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+    const boost = await core.createBoost({
+      maxParticipants: 100n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      allowList: core.OpenAllowList(),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther('1'),
+          limit: 100n,
+          strategy: StrategyType.POOL,
+        }),
+      ],
+    });
+
+    const validator = boost.validator;
+
+    // expect boostCore to be a validatorCaller
+    expect(validator.payload?.validatorCaller).toBe(core.assertValidAddress());
+
+    // expect current account to be a signer
+    const signer = await validator.signers(defaultOptions.account.address);
+    expect(signer).toBeDefined();
+    expect(signer).toBe(true);
+  });
+
+  test('can retrieve the BoostClaimed event from a transaction hash', async () => {
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const referrer = accounts.at(1)!.account!,
+      // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+      trustedSigner = accounts.at(0)!;
+    const erc20Incentive = fixtures.core.ERC20Incentive({
+      asset: budgets.erc20.assertValidAddress(),
+      strategy: StrategyType.POOL,
+      reward: 1n,
+      limit: 1n,
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+    const incentiveQuantity = 1;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    const {hash} = await fixtures.core.claimIncentiveRaw(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: BOOST_CORE_CLAIM_FEE },
+    );
+
+    const claimInfo = await fixtures.core.getClaimFromTransaction({ hash })
+    expect(claimInfo).toBeDefined()
+    expect(claimInfo?.claimant).toBe(claimant)
+    expect(typeof claimInfo?.boostId).toBe('bigint')
+    expect(claimInfo?.referrer).toBe(referrer)
+  });
 });

package/src/BoostCore.ts

@@ -20,7 +20,12 @@ import {
   writeBoostCoreSetProtocolFeeReceiver,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/BoostCore.sol/BoostCore.json';
-import { getAccount, waitForTransactionReceipt } from '@wagmi/core';
+import {
+  type GetTransactionReceiptParameters,
+  getAccount,
+  getTransactionReceipt,
+  waitForTransactionReceipt,
+} from '@wagmi/core';
 import { createWriteContract } from '@wagmi/core/codegen';
 import {
   type Address,
@@ -74,6 +79,10 @@ import {
   ERC20Incentive,
   type ERC20IncentivePayload,
 } from './Incentives/ERC20Incentive';
+import {
+  ERC20VariableCriteriaIncentive,
+  type ERC20VariableCriteriaIncentivePayload,
+} from './Incentives/ERC20VariableCriteriaIncentive';
 import type { ERC20VariableIncentivePayload } from './Incentives/ERC20VariableIncentive';
 import {
   ERC20VariableIncentive,
@@ -228,7 +237,7 @@ export type BoostCoreConfig =
 export type CreateBoostPayload = {
   budget: Budget;
   action: Action;
-  validator: Validator;
+  validator?: Validator;
   allowList: AllowList;
   incentives: Array<Incentive>;
   protocolFee?: bigint;
@@ -303,7 +312,7 @@ export class BoostCore extends Deployable<
    * @async
    * @param {CreateBoostPayload} _boostPayload
    * @param {?DeployableOptions} [_options]
-   * @returns {Boost}
+   * @returns {Promise<Boost>}
    */
   public async createBoost(
     _boostPayload: CreateBoostPayload,
@@ -347,6 +356,13 @@ export class BoostCore extends Deployable<
       }
     }
 
+    if (!validator) {
+      validator = this.SignerValidator({
+        signers: [owner],
+        validatorCaller: coreAddress,
+      });
+    }
+
     let budgetPayload: BoostPayload['budget'] = zeroAddress;
     if (budget.address) {
       budgetPayload = budget.address;
@@ -394,28 +410,12 @@ export class BoostCore extends Deployable<
         isBase: isBase,
         instance: validator.address,
         parameters: isBase
-          ? validator
-              .buildParameters(
-                {
-                  signers: [owner],
-                  validatorCaller: coreAddress,
-                },
-                options,
-              )
-              .args.at(0) || zeroHash
+          ? validator.buildParameters(undefined, options).args.at(0) || zeroHash
           : zeroHash,
       };
     } else {
       validatorPayload.parameters =
-        validator
-          .buildParameters(
-            {
-              signers: [owner],
-              validatorCaller: coreAddress,
-            },
-            options,
-          )
-          .args.at(0) || zeroHash;
+        validator.buildParameters(undefined, options).args.at(0) || zeroHash;
       validatorPayload.instance = assertValidAddressByChainId(
         options.config,
         validator.bases,
@@ -536,8 +536,8 @@ export class BoostCore extends Deployable<
    * @param {bigint} incentiveId
    * @param {Address} address
    * @param {Hex} data
-   * @param {?WriteParams<typeof boostCoreAbi, 'claimIncentive'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
    */
   public async claimIncentive(
     boostId: bigint,
@@ -560,8 +560,8 @@ export class BoostCore extends Deployable<
    * @param {bigint} incentiveId - The ID of the Incentive
    * @param {Address} referrer - The address of the referrer (if any)
    * @param {Hex} data- The data for the claim
-   * @param {?WriteParams<typeof boostCoreAbi, 'claimIncentive'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async claimIncentiveRaw(
     boostId: bigint,
@@ -598,8 +598,8 @@ export class BoostCore extends Deployable<
    * @param {Address} referrer
    * @param {Hex} data
    * @param {Address} claimant
-   * @param {?WriteParams<typeof boostCoreAbi, 'claimIncentiveFor'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
    */
   public async claimIncentiveFor(
     boostId: bigint,
@@ -631,8 +631,8 @@ export class BoostCore extends Deployable<
    * @param {Address} referrer - The address of the referrer (if any)
    * @param {Hex} data - The data for the claim
    * @param {Address} claimant - The address of the user eligible for the incentive payout
-   * @param {?WriteParams<typeof boostCoreAbi, 'claimIncentiveFor'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: Hex; result: void; }>}
    */
   public async claimIncentiveForRaw(
     boostId: bigint,
@@ -666,8 +666,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {bigint} id
-   * @param {?ReadParams<typeof boostCoreAbi, 'getBoost'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<RawBoost>}
    */
   public async readBoost(
     id: bigint,
@@ -688,8 +688,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {(string | bigint)} _id
-   * @param {?ReadParams<typeof boostCoreAbi, 'getBoost'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Boost>}
    */
   public async getBoost(
     _id: string | bigint,
@@ -741,7 +741,7 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'getBoostCount'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async getBoostCount(
@@ -766,7 +766,7 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {Address} address
-   * @param {?ReadParams<typeof boostCoreAbi, 'createBoostAuth'> &
+   * @param {?ReadParams &
    *       ReadParams<typeof iAuthAbi, 'isAuthorized'>} [params]
    * @returns {Promise<boolean>}
    */
@@ -790,8 +790,8 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'createBoostAuth'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>}
    */
   public async createBoostAuth(
     params?: ReadParams<typeof boostCoreAbi, 'createBoostAuth'>,
@@ -815,8 +815,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {Auth} auth
-   * @param {?WriteParams<typeof boostCoreAbi, 'setCreateBoostAuth'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
    */
   public async setCreateBoostAuth(
     auth: Auth,
@@ -835,8 +835,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {Address} address
-   * @param {?WriteParams<typeof boostCoreAbi, 'setCreateBoostAuth'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async setCreateBoostAuthRaw(
     address: Address,
@@ -865,7 +865,7 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'protocolFee'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {unknown}
    */
   public async protocolFee(
@@ -889,8 +889,8 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'protocolFeeReceiver'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>}
    */
   public async protocolFeeReceiver(
     params?: ReadParams<typeof boostCoreAbi, 'protocolFeeReceiver'>,
@@ -914,8 +914,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {Address} address
-   * @param {?WriteParams<typeof boostCoreAbi, 'setProtocolFeeReceiver'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
    */
   public async setProcolFeeReceiver(
     address: Address,
@@ -934,8 +934,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {Address} address
-   * @param {?WriteParams<typeof boostCoreAbi, 'setProtocolFeeReceiver'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async setProcolFeeReceiverRaw(
     address: Address,
@@ -967,8 +967,8 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'claimFee'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public async claimFee(params?: ReadParams<typeof boostCoreAbi, 'claimFee'>) {
     return await readBoostCoreClaimFee(this._config, {
@@ -990,8 +990,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {bigint} claimFee
-   * @param {?WriteParams<typeof boostCoreAbi, 'setClaimFee'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
    */
   public async setClaimFee(
     claimFee: bigint,
@@ -1006,8 +1006,8 @@ export class BoostCore extends Deployable<
    * @public
    * @async
    * @param {bigint} claimFee
-   * @param {?WriteParams<typeof boostCoreAbi, 'setClaimFee'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async setClaimFeeRaw(
     claimFee: bigint,
@@ -1031,6 +1031,41 @@ export class BoostCore extends Deployable<
     return { hash, result };
   }
 
+  /**
+   * Retrieves the claim information from a transaction receipt.
+   *
+   * @param {GetTransactionReceiptParameters} params - The parameters required to get the transaction receipt.
+   * @returns {Promise<{ boostId: bigint, incentiveId: bigint, claimer: Address, amount: bigint } | undefined>} The claim information if found, undefined otherwise.
+   *
+   * @description
+   * This method retrieves the transaction receipt using the provided parameters,
+   * then parses the logs to find the 'BoostClaimed' event.
+   * If found, it returns the arguments of the event, which include the boost ID,
+   * incentive ID, claimer address, and claimed amount.
+   *
+   * @example
+   * ```ts
+   * const claimInfo = await boostCore.getClaimFromTransaction({
+   *   hash: '0x...',
+   *   chainId: 1
+   * });
+   * if (claimInfo) {
+   *   console.log(`Boost ${claimInfo.boostId} claimed by ${claimInfo.claimer}`);
+   * }
+   * ```
+   */
+  public async getClaimFromTransaction(
+    params: GetTransactionReceiptParameters,
+  ) {
+    const receipt = await getTransactionReceipt(this._config, params);
+    const logs = parseEventLogs({
+      abi: boostCoreAbi,
+      eventName: 'BoostClaimed',
+      logs: receipt.logs,
+    });
+    return logs.at(0)?.args;
+  }
+
   /**
    * Bound {@link PassthroughAuth} constructor that reuses the same configuration as the Boost Core instance.
    *
@@ -1334,6 +1369,30 @@ export class BoostCore extends Deployable<
       isBase,
     );
   }
+
+  /**
+   * Bound {@link ERC20VariableCriteriaIncentive} constructor that reuses the same configuration as the Boost Core instance.
+   *
+   * @example
+   * ```ts
+   * const validator = core.ERC20VariableCrtieriaIncentive({ ... }) // is roughly equivalent to
+   * const validator = new ERC20VariableCrtieriaIncentive({ config: core._config, account: core._account }, { ... })
+   * ```
+   * @param {DeployablePayloadOrAddress<ERC20VariableCrtieriaIncentivePayload>} options
+   * @param {?boolean} [isBase]
+   * @returns {ERC20VariableCrtieriaIncentive}
+   * */
+  ERC20VariableCriteriaIncentive(
+    options: DeployablePayloadOrAddress<ERC20VariableCriteriaIncentivePayload>,
+    isBase?: boolean,
+  ) {
+    return new ERC20VariableCriteriaIncentive(
+      { config: this._config, account: this._account },
+      options,
+      isBase,
+    );
+  }
+
   /**
    * Bound {@link ERC20VariableIncentive} constructor that reuses the same configuration as the Boost Core instance.
    *

package/src/BoostRegistry.ts

@@ -214,8 +214,8 @@ export class BoostRegistry extends Deployable<
    * @param {RegistryType} registryType - The base type for the implementation
    * @param {string} name - A name for the implementation (must be unique within the given type)
    * @param {Address} implementation - The address of the implementation contract
-   * @param {?WriteParams<typeof boostRegistryAbi, 'register'>} [params] - Optional params to provide the underlying Viem contract call
-   * @returns {unknown}
+   * @param {?WriteParams} [params] - Optional params to provide the underlying Viem contract call
+   * @returns {Promise<void>}
    * @example
    * ```ts
    * await registry.register(ContractAction.registryType, 'ContractAction', ContractAction.base)
@@ -239,8 +239,8 @@ export class BoostRegistry extends Deployable<
    * @param {RegistryType} registryType
    * @param {string} name
    * @param {Address} implementation
-   * @param {?WriteParams<typeof boostRegistryAbi, 'register'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async registerRaw(
     registryType: RegistryType,
@@ -275,8 +275,8 @@ export class BoostRegistry extends Deployable<
    * @template {DeployableTarget} Target
    * @param {string} displayName - The display name for the clone
    * @param {Target} target - An instance of a target contract to clone and initialize
-   * @param {?WriteParams<typeof boostRegistryAbi, 'deployClone'>} [params]
-   * @returns {Target} - The provided instance, but with a new address attached.
+   * @param {?WriteParams} [params]
+   * @returns {Promise<Target>} - The provided instance, but with a new address attached.
    * biome-ignore lint/suspicious/noExplicitAny: any deployable target will suffice
    */
   public initialize<Target extends DeployableTarget<any, any>>(
@@ -295,8 +295,8 @@ export class BoostRegistry extends Deployable<
    * @template {DeployableTarget} Target
    * @param {string} displayName - The display name for the clone
    * @param {Target} target - An instance of a target contract to clone and initialize
-   * @param {?WriteParams<typeof boostRegistryAbi, 'deployClone'>} [params]
-   * @returns {Target} - The provided instance, but with a new address attached.
+   * @param {?WriteParams} [params]
+   * @returns {Promise<Target>} - The provided instance, but with a new address attached.
    * biome-ignore lint/suspicious/noExplicitAny: any deployable target will suffice
    */
   public async clone<Target extends DeployableTarget<any, any>>(
@@ -316,8 +316,8 @@ export class BoostRegistry extends Deployable<
    * @template {DeployableTarget} Target
    * @param {string} displayName
    * @param {Target} target
-   * @param {?WriteParams<typeof boostRegistryAbi, 'deployClone'>} [params]
-   * @returns {Target}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<Address>}
    * biome-ignore lint/suspicious/noExplicitAny: any deployable target will suffice
    */
   public async deployClone<Target extends DeployableTarget<any, any>>(
@@ -336,8 +336,8 @@ export class BoostRegistry extends Deployable<
    * @async
    * @param {string} displayName
    * @param {DeployableTarget} target
-   * @param {?WriteParams<typeof boostRegistryAbi, 'deployClone'>} [params]
-   * @returns {unknown} - The transaction hash
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: Hex, result: Address }>} - The transaction hash
    * biome-ignore lint/suspicious/noExplicitAny: any deployable target will suffice
    */
   public async deployCloneRaw<Target extends DeployableTarget<any, any>>(
@@ -379,8 +379,8 @@ export class BoostRegistry extends Deployable<
    * @public
    * @async
    * @param {Hex} identifier - The unique identifier for the implementation (see {getIdentifier})
-   * @param {?ReadParams<typeof boostRegistryAbi, 'getBaseImplementation'>} [params]
-   * @returns {unknown} - The address of the implementation
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>} - The address of the implementation
    */
   public async getBaseImplementation(
     identifier: Hex,
@@ -405,7 +405,7 @@ export class BoostRegistry extends Deployable<
    * @public
    * @async
    * @param {Hex} identifier - The unique identifier for the deployed clone (see {getCloneIdentifier})
-   * @param {?ReadParams<typeof boostRegistryAbi, 'getClone'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>} - The address of the deployed clone
    */
   public async getClone(
@@ -431,7 +431,7 @@ export class BoostRegistry extends Deployable<
    * @public
    * @async
    * @param {Address} deployer - The address of the deployer
-   * @param {?ReadParams<typeof boostRegistryAbi, 'getClones'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Hex[]>} - The list of deployed clones for the given deployer
    */
   public async getClones(
@@ -460,7 +460,7 @@ export class BoostRegistry extends Deployable<
    * @param {Address} base - The address of the base implementation
    * @param {Address} deployer - The address of the deployer
    * @param {string} displayName - The display name of the clone
-   * @param {?ReadParams<typeof boostRegistryAbi, 'getCloneIdentifier'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Hex>} - The unique identifier for the clone
    */
   public async getCloneIdentifier(
@@ -490,7 +490,7 @@ export class BoostRegistry extends Deployable<
    * @async
    * @param {RegistryType} registryType - The base type for the implementation
    * @param {string} displayName - The name of the implementation
-   * @param {?ReadParams<typeof boostRegistryAbi, 'getIdentifier'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Hex>} - The unique identifier for the implementation
    */
   public async getIdentifier(

package/src/Budgets/Budget.ts

@@ -7,7 +7,6 @@ import { InvalidComponentInterfaceError } from '../errors';
 import { ManagedBudget } from './ManagedBudget';
 
 export {
-  // SimpleBudget,
   // VestingBudget,
   ManagedBudget,
 };
@@ -18,7 +17,7 @@ export {
  * @export
  * @typedef {Budget}
  */
-export type Budget = ManagedBudget; // | SimpleBudget | VestingBudget
+export type Budget = ManagedBudget; // | VestingBudget
 
 /**
  * A map of Budget component interfaces to their constructors.