@boostxyz/sdk 0.0.0-alpha.8 → 1.1.0-alpha.22

package/src/BoostCore.ts

@@ -1,7 +1,6 @@
 import {
   boostCoreAbi,
   type iAuthAbi,
-  readBoostCoreClaimFee,
   readBoostCoreCreateBoostAuth,
   readBoostCoreGetBoost,
   readBoostCoreGetBoostCount,
@@ -10,29 +9,37 @@ import {
   readIAuthIsAuthorized,
   simulateBoostCoreClaimIncentive,
   simulateBoostCoreClaimIncentiveFor,
-  simulateBoostCoreSetClaimFee,
+  simulateBoostCoreCreateBoost,
   simulateBoostCoreSetCreateBoostAuth,
   simulateBoostCoreSetProtocolFeeReceiver,
   writeBoostCoreClaimIncentive,
   writeBoostCoreClaimIncentiveFor,
-  writeBoostCoreSetClaimFee,
   writeBoostCoreSetCreateBoostAuth,
   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 type { SimulateContractReturnType } from '@wagmi/core/actions';
 import { createWriteContract } from '@wagmi/core/codegen';
 import {
   type Address,
   type ContractEventName,
   type Hex,
+  parseEther,
   parseEventLogs,
   zeroAddress,
   zeroHash,
 } from 'viem';
+import { BoostCore as BoostCoreBases } from '../dist/deployments.json';
 import { type Action, actionFromAddress } from './Actions/Action';
-import { EventAction } from './Actions/EventAction';
+import { EventAction, type EventActionPayload } from './Actions/EventAction';
 import { type AllowList, allowListFromAddress } from './AllowLists/AllowList';
+import { OpenAllowList } from './AllowLists/OpenAllowList';
 import {
   SimpleAllowList,
   type SimpleAllowListPayload,
@@ -42,7 +49,13 @@ import {
   type SimpleDenyListPayload,
 } from './AllowLists/SimpleDenyList';
 import { type Auth, PassthroughAuth } from './Auth/Auth';
-import { Boost } from './Boost';
+import {
+  Boost,
+  type BoostPayload,
+  type RawBoost,
+  type Target,
+  prepareBoostPayload,
+} from './Boost';
 import { type Budget, budgetFromAddress } from './Budgets/Budget';
 import {
   ManagedBudget,
@@ -66,6 +79,11 @@ import {
   ERC20Incentive,
   type ERC20IncentivePayload,
 } from './Incentives/ERC20Incentive';
+import {
+  ERC20VariableCriteriaIncentive,
+  type ERC20VariableCriteriaIncentivePayload,
+} from './Incentives/ERC20VariableCriteriaIncentive';
+import type { ERC20VariableIncentivePayload } from './Incentives/ERC20VariableIncentive';
 import {
   ERC20VariableIncentive,
   type Incentive,
@@ -82,33 +100,52 @@ import {
 import { type Validator, validatorFromAddress } from './Validators/Validator';
 import {
   BoostCoreNoIdentifierEmitted,
+  BoostNotFoundError,
   BudgetMustAuthorizeBoostCore,
   DeployableUnknownOwnerProvidedError,
   IncentiveNotCloneableError,
   MustInitializeBudgetError,
-  NoContractAddressUponReceiptError,
 } from './errors';
 import {
-  type ERC20VariableIncentivePayload,
-  type EventActionPayload,
   type GenericLog,
-  type BoostPayload as OnChainBoostPayload,
   type ReadParams,
-  type Target,
   type WriteParams,
-  prepareBoostPayload,
+  assertValidAddressByChainId,
 } from './utils';
 
+/**
+ * The ABI of the BoostCore contract, if needed for low level operations
+ *
+ * @type {typeof boostCoreAbi}
+ */
 export { boostCoreAbi };
 
 /**
- * The fixed address for the deployed Boost Core.
- * By default, `new BoostCore` will use this address if not otherwise provided.
+ * The fee (in wei) required to claim each incentive, must be provided for the `claimIncentive` transaction
+ *
+ * @type {bigint}
+ */
+export const BOOST_CORE_CLAIM_FEE = parseEther('0.000075');
+
+/**
+ * The address of the deployed BoostCore instance. In prerelease mode, this will be its sepolia address
  *
  * @type {Address}
  */
-export const BOOST_CORE_ADDRESS: Address = import.meta.env
-  .VITE_BOOST_CORE_ADDRESS;
+export const BOOST_CORE_ADDRESS =
+  (BoostCoreBases as Record<string, Address>)[__DEFAULT_CHAIN_ID__] ||
+  zeroAddress;
+
+/**
+ * The fixed addresses for the deployed Boost Core.
+ * By default, `new BoostCore` will use the address deployed to the currently connected chain, or `BOOST_CORE_ADDRESS` if not provided.
+ *
+ * @type {Record<number, Address>}
+ */
+export const BOOST_CORE_ADDRESSES: Record<number, Address> = {
+  ...(BoostCoreBases as Record<number, Address>),
+  31337: import.meta.env.VITE_BOOST_CORE_ADDRESS,
+};
 
 /**
  * A generic `viem.Log` event with support for `BoostCore` event types.
@@ -206,11 +243,10 @@ export type BoostCoreConfig =
 export type CreateBoostPayload = {
   budget: Budget;
   action: Action;
-  validator: Validator;
+  validator?: Validator;
   allowList: AllowList;
   incentives: Array<Incentive>;
   protocolFee?: bigint;
-  referralFee?: bigint;
   maxParticipants?: bigint;
   owner?: Address;
 };
@@ -227,6 +263,26 @@ export class BoostCore extends Deployable<
   [Address, Address],
   typeof boostCoreAbi
 > {
+  /**
+   * A static property representing a map of stringified chain ID's to the address of the deployed implementation on chain
+   *
+   * @static
+   * @readonly
+   * @type {Record<string, Address>}
+   */
+  static readonly addresses: Record<number, Address> = BOOST_CORE_ADDRESSES;
+
+  /**
+   * A getter that will return Boost core's static addresses by numerical chain ID
+   *
+   * @public
+   * @readonly
+   * @type {Record<number, Address>}
+   */
+  public get addresses(): Record<number, Address> {
+    return (this.constructor as typeof BoostCore).addresses;
+  }
+
   /**
    * Creates an instance of BoostCore.
    *
@@ -245,63 +301,155 @@ export class BoostCore extends Deployable<
         options.protocolFeeReceiver,
       ]);
     } else {
-      super({ account, config }, BOOST_CORE_ADDRESS);
+      const { address } = assertValidAddressByChainId(
+        config,
+        BOOST_CORE_ADDRESSES,
+      );
+      super({ account, config }, address);
     }
     //@ts-expect-error I can't set this property on the class because for some reason it takes super out of constructor scope?
     this.abi = boostCoreAbi;
   }
+
   /**
    * Create a new Boost.
    *
    * @public
    * @async
    * @param {CreateBoostPayload} _boostPayload
-   * @param {?DeployableOptions} [_options]
-   * @returns {Boost}
+   * @param {?DeployableOptions} [_params]
+   * @returns {Promise<Boost>}
    */
   public async createBoost(
     _boostPayload: CreateBoostPayload,
-    _options?: DeployableOptions,
+    _params?: DeployableOptions &
+      WriteParams<typeof boostCoreAbi, 'createBoost'>,
   ) {
-    const coreAddress = this.assertValidAddress();
     const [payload, options] =
-      this.validateDeploymentConfig<CreateBoostPayload>(
-        _boostPayload,
-        _options,
-      );
-
-    let {
-      budget,
-      action,
-      validator,
-      allowList,
-      incentives,
-      protocolFee = 0n,
-      referralFee = 0n,
-      maxParticipants = 0n,
-      owner,
-    } = payload;
+      this.validateDeploymentConfig<CreateBoostPayload>(_boostPayload, _params);
+    const desiredChainId = _params?.chain?.id || _params?.chainId;
+    const { chainId, address: coreAddress } = assertValidAddressByChainId(
+      options.config,
+      this.addresses,
+      desiredChainId,
+    );
 
     const boostFactory = createWriteContract({
       abi: boostCoreAbi,
       functionName: 'createBoost',
-      address: this.address,
+      address: coreAddress,
     });
 
-    if (!owner) {
-      owner =
+    const onChainPayload = await this.prepareCreateBoostPayload(
+      coreAddress,
+      chainId,
+      payload,
+      options,
+    );
+
+    const boostHash = await boostFactory(options.config, {
+      ...this.optionallyAttachAccount(options.account),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(_params as any),
+      chainId,
+      args: [prepareBoostPayload(onChainPayload)],
+    });
+    const receipt = await waitForTransactionReceipt(options.config, {
+      hash: boostHash,
+    });
+    const boostCreatedLog = parseEventLogs({
+      abi: boostCoreAbi,
+      eventName: 'BoostCreated',
+      logs: receipt.logs,
+    }).at(0);
+    let boostId = 0n;
+    if (!boostCreatedLog) throw new BoostCoreNoIdentifierEmitted();
+    boostId = boostCreatedLog?.args.boostId;
+    const boost = await this.readBoost(boostId);
+    return new Boost({
+      id: boostId,
+      budget: payload.budget.at(boost.budget),
+      action: payload.action.at(boost.action),
+      validator: payload.validator!.at(boost.validator),
+      allowList: payload.allowList.at(boost.allowList),
+      incentives: payload.incentives.map((incentive, i) =>
+        // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+        incentive.at(boost.incentives.at(i)!),
+      ),
+      protocolFee: boost.protocolFee,
+      maxParticipants: boost.maxParticipants,
+      owner: boost.owner,
+    });
+  }
+
+  /**
+   * Returns a simulated Boost creation.
+   *
+   * @public
+   * @async
+   * @param {CreateBoostPayload} _boostPayload
+   * @param {?DeployableOptions} [_params]
+   * @returns {Promise<SimulateContractReturnType>}
+   */
+  public async simulateCreateBoost(
+    _boostPayload: CreateBoostPayload,
+    _params?: DeployableOptions &
+      WriteParams<typeof boostCoreAbi, 'createBoost'>,
+  ) {
+    const [payload, options] =
+      this.validateDeploymentConfig<CreateBoostPayload>(_boostPayload, _params);
+    const desiredChainId = _params?.chain?.id || _params?.chainId;
+    const { chainId, address: coreAddress } = assertValidAddressByChainId(
+      options.config,
+      this.addresses,
+      desiredChainId,
+    );
+
+    const onChainPayload = await this.prepareCreateBoostPayload(
+      coreAddress,
+      chainId,
+      payload,
+      options,
+    );
+
+    return await simulateBoostCoreCreateBoost(this._config, {
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(_params as any),
+      address: coreAddress,
+      chainId,
+      args: [prepareBoostPayload(onChainPayload)],
+    });
+  }
+
+  // This function mutates payload, which isn't awesome but it's fine
+  private async prepareCreateBoostPayload(
+    coreAddress: Address,
+    chainId: number,
+    payload: CreateBoostPayload,
+    options: DeployableOptions,
+  ): Promise<BoostPayload> {
+    if (!payload.owner) {
+      payload.owner =
         this._account?.address ||
         getAccount(options.config).address ||
         zeroAddress;
-      if (owner === zeroAddress) {
+      if (payload.owner === zeroAddress) {
         throw new DeployableUnknownOwnerProvidedError();
       }
     }
 
-    let budgetPayload: OnChainBoostPayload['budget'] = zeroAddress;
-    if (budget.address) {
-      budgetPayload = budget.address;
-      if (!(await budget.isAuthorized(coreAddress))) {
+    if (!payload.validator) {
+      payload.validator = this.SignerValidator({
+        signers: [payload.owner],
+        validatorCaller: coreAddress,
+      });
+    }
+
+    let budgetPayload: BoostPayload['budget'] = zeroAddress;
+    if (payload.budget.address) {
+      budgetPayload = payload.budget.address;
+      if (!(await payload.budget.isAuthorized(coreAddress))) {
         throw new BudgetMustAuthorizeBoostCore(coreAddress);
       }
     } else {
@@ -310,92 +458,93 @@ export class BoostCore extends Deployable<
 
     // if we're supplying an address, it could be a pre-initialized target
     // if base is explicitly set to false, then it will not be initialized, and it will be referenced as is if it implements interface correctly
-    let actionPayload: OnChainBoostPayload['action'] = {
+    let actionPayload: BoostPayload['action'] = {
       instance: zeroAddress,
       isBase: true,
       parameters: zeroHash,
     };
-    if (action.address) {
-      const isBase = action.address === action.base || action.isBase;
+    if (payload.action.address) {
+      const isBase = payload.action.isBase;
       actionPayload = {
         isBase: isBase,
-        instance: action.address,
+        instance: payload.action.address,
         parameters: isBase
-          ? action.buildParameters(undefined, options).args.at(0) || zeroHash
+          ? payload.action.buildParameters(undefined, options).args.at(0) ||
+            zeroHash
           : zeroHash,
       };
     } else {
       actionPayload.parameters =
-        action.buildParameters(undefined, options).args.at(0) || zeroHash;
-      actionPayload.instance = action.base;
+        payload.action.buildParameters(undefined, options).args.at(0) ||
+        zeroHash;
+      actionPayload.instance = assertValidAddressByChainId(
+        options.config,
+        payload.action.bases,
+        chainId,
+      ).address;
     }
 
-    let validatorPayload: OnChainBoostPayload['validator'] = {
+    let validatorPayload: BoostPayload['validator'] = {
       instance: zeroAddress,
       isBase: true,
       parameters: zeroHash,
     };
-    if (validator.address) {
-      const isBase = validator.address === validator.base || validator.isBase;
+    if (payload.validator.address) {
+      const isBase = payload.validator.isBase;
       validatorPayload = {
         isBase: isBase,
-        instance: validator.address,
+        instance: payload.validator.address,
         parameters: isBase
-          ? validator
-              .buildParameters(
-                {
-                  signers: [owner],
-                  validatorCaller: coreAddress,
-                },
-                options,
-              )
-              .args.at(0) || zeroHash
+          ? payload.validator.buildParameters(undefined, options).args.at(0) ||
+            zeroHash
           : zeroHash,
       };
     } else {
       validatorPayload.parameters =
-        validator
-          .buildParameters(
-            {
-              signers: [owner],
-              validatorCaller: coreAddress,
-            },
-            options,
-          )
-          .args.at(0) || zeroHash;
-      validatorPayload.instance = validator.base;
+        payload.validator.buildParameters(undefined, options).args.at(0) ||
+        zeroHash;
+      validatorPayload.instance = assertValidAddressByChainId(
+        options.config,
+        payload.validator.bases,
+        chainId,
+      ).address;
     }
 
-    let allowListPayload: OnChainBoostPayload['allowList'] = {
+    let allowListPayload: BoostPayload['allowList'] = {
       instance: zeroAddress,
       isBase: true,
       parameters: zeroHash,
     };
-    if (allowList.address) {
-      const isBase = allowList.address === allowList.base || allowList.isBase;
+    if (payload.allowList.address) {
+      const isBase = payload.allowList.isBase;
       allowListPayload = {
         isBase: isBase,
-        instance: allowList.address,
+        instance: payload.allowList.address,
         parameters: isBase
           ? zeroHash // allowList.buildParameters(undefined, options).args.at(0) || zeroHash
           : zeroHash,
       };
     } else {
       allowListPayload.parameters =
-        allowList.buildParameters(undefined, options).args.at(0) || zeroHash;
-      allowListPayload.instance = allowList.base;
+        payload.allowList.buildParameters(undefined, options).args.at(0) ||
+        zeroHash;
+      allowListPayload.instance = assertValidAddressByChainId(
+        options.config,
+        payload.allowList.bases,
+        chainId,
+      ).address;
     }
 
-    let incentivesPayloads: Array<Target> = incentives.map(() => ({
+    const incentivesPayloads: Array<Target> = payload.incentives.map(() => ({
       instance: zeroAddress,
       isBase: true,
       parameters: zeroHash,
     }));
-    for (let i = 0; i < incentives.length; i++) {
+    for (let i = 0; i < payload.incentives.length; i++) {
       // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
-      const incentive = incentives.at(i)!;
+      const incentive = payload.incentives.at(i)!;
       if (incentive.address) {
-        const isBase = incentive.address === incentive.base || incentive.isBase;
+        const isBase = incentive.isBase;
         if (!isBase) throw new IncentiveNotCloneableError(incentive);
         incentivesPayloads[i] = {
           isBase: isBase,
@@ -406,9 +555,15 @@ export class BoostCore extends Deployable<
             : zeroHash,
         };
       } else {
+        // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
         incentivesPayloads[i]!.parameters =
           incentive.buildParameters(undefined, options).args.at(0) || zeroHash;
-        incentivesPayloads[i]!.instance = incentive.base;
+        // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+        incentivesPayloads[i]!.instance = assertValidAddressByChainId(
+          options.config,
+          incentive.bases,
+          chainId,
+        ).address;
       }
     }
 
@@ -418,42 +573,12 @@ export class BoostCore extends Deployable<
       validator: validatorPayload,
       allowList: allowListPayload,
       incentives: incentivesPayloads,
-      protocolFee,
-      referralFee,
-      maxParticipants,
-      owner,
+      protocolFee: payload.protocolFee || 0n,
+      maxParticipants: payload.maxParticipants || 0n,
+      owner: payload.owner,
     };
 
-    const boostHash = await boostFactory(options.config, {
-      args: [prepareBoostPayload(onChainPayload)],
-      ...this.optionallyAttachAccount(options.account),
-    });
-    const receipt = await waitForTransactionReceipt(options.config, {
-      hash: boostHash,
-    });
-    const boostCreatedLog = parseEventLogs({
-      abi: boostCoreAbi,
-      eventName: 'BoostCreated',
-      logs: receipt.logs,
-    }).at(0);
-    let boostId = 0n;
-    if (!boostCreatedLog) throw new BoostCoreNoIdentifierEmitted();
-    boostId = boostCreatedLog?.args.boostIndex;
-    const boost = await this.readBoost(boostId);
-    return new Boost({
-      id: boostId,
-      budget: budget.at(boost.budget),
-      action: action.at(boost.action),
-      validator: validator.at(boost.validator),
-      allowList: allowList.at(boost.allowList),
-      incentives: incentives.map((incentive, i) =>
-        incentive.at(boost.incentives.at(i)!),
-      ),
-      protocolFee: boost.protocolFee,
-      referralFee: boost.referralFee,
-      maxParticipants: boost.maxParticipants,
-      owner: boost.owner,
-    });
+    return onChainPayload;
   }
 
   /**
@@ -465,8 +590,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,
@@ -475,7 +600,7 @@ export class BoostCore extends Deployable<
     data: Hex,
     params?: WriteParams<typeof boostCoreAbi, 'claimIncentive'>,
   ) {
-    return this.awaitResult(
+    return await this.awaitResult(
       this.claimIncentiveRaw(boostId, incentiveId, address, data, params),
     );
   }
@@ -487,23 +612,27 @@ export class BoostCore extends Deployable<
    * @async
    * @param {bigint} boostId - The ID of the Boost
    * @param {bigint} incentiveId - The ID of the Incentive
-   * @param {Address} address - The address of the referrer (if any)
+   * @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,
     incentiveId: bigint,
-    address: Address,
+    referrer: Address,
     data: Hex,
     params?: WriteParams<typeof boostCoreAbi, 'claimIncentive'>,
   ) {
     const { request, result } = await simulateBoostCoreClaimIncentive(
       this._config,
       {
-        address: this.assertValidAddress(),
-        args: [boostId, incentiveId, address, data],
+        ...assertValidAddressByChainId(
+          this._config,
+          this.addresses,
+          params?.chain?.id || params?.chainId,
+        ),
+        args: [boostId, incentiveId, referrer, data],
         ...this.optionallyAttachAccount(),
         // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
         ...(params as any),
@@ -523,8 +652,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,
@@ -534,7 +663,7 @@ export class BoostCore extends Deployable<
     claimant: Address,
     params?: WriteParams<typeof boostCoreAbi, 'claimIncentiveFor'>,
   ) {
-    return this.awaitResult(
+    return await this.awaitResult(
       this.claimIncentiveForRaw(
         boostId,
         incentiveId,
@@ -556,8 +685,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,
@@ -570,7 +699,11 @@ export class BoostCore extends Deployable<
     const { request, result } = await simulateBoostCoreClaimIncentiveFor(
       this._config,
       {
-        address: this.assertValidAddress(),
+        ...assertValidAddressByChainId(
+          this._config,
+          this.addresses,
+          params?.chain?.id || params?.chainId,
+        ),
         args: [boostId, incentiveId, referrer, data, claimant],
         ...this.optionallyAttachAccount(),
         // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -586,21 +719,37 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {bigint} id
-   * @param {?ReadParams<typeof boostCoreAbi, 'getBoost'>} [params]
-   * @returns {unknown}
+   * @param {bigint | string} id
+   * @param {?ReadParams} [params]
+   * @returns {Promise<RawBoost>}
+   * @throws {@link BoostNotFoundError}
    */
   public async readBoost(
-    id: bigint,
+    _id: string | bigint,
     params?: ReadParams<typeof boostCoreAbi, 'getBoost'>,
-  ) {
-    return readBoostCoreGetBoost(this._config, {
-      address: this.assertValidAddress(),
-      args: [id],
-      ...this.optionallyAttachAccount(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
+  ): Promise<RawBoost> {
+    try {
+      let id: bigint;
+      if (typeof _id === 'string') {
+        id = BigInt(_id);
+      } else id = _id;
+      return await readBoostCoreGetBoost(this._config, {
+        ...assertValidAddressByChainId(
+          this._config,
+          this.addresses,
+          params?.chainId,
+        ),
+        args: [id],
+        ...this.optionallyAttachAccount(),
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      });
+      // biome-ignore lint/suspicious/noExplicitAny: unknown error
+    } catch (e: any) {
+      if (e?.message?.includes('bounds'))
+        throw new BoostNotFoundError(String(_id));
+      throw e;
+    }
   }
 
   /**
@@ -609,8 +758,9 @@ 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>}
+   * @throws {@link BoostNotFoundError}
    */
   public async getBoost(
     _id: string | bigint,
@@ -620,13 +770,8 @@ export class BoostCore extends Deployable<
     if (typeof _id === 'string') {
       id = BigInt(_id);
     } else id = _id;
-    const {
-      protocolFee,
-      referralFee,
-      maxParticipants,
-      owner,
-      ...boostPayload
-    } = await this.readBoost(id, params);
+    const { protocolFee, maxParticipants, owner, ...boostPayload } =
+      await this.readBoost(id, params);
     const options: DeployableOptions = {
       config: this._config,
       account: this._account,
@@ -651,7 +796,6 @@ export class BoostCore extends Deployable<
       allowList,
       incentives,
       protocolFee,
-      referralFee,
       maxParticipants,
       owner,
     });
@@ -662,14 +806,18 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'getBoostCount'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async getBoostCount(
     params?: ReadParams<typeof boostCoreAbi, 'getBoostCount'>,
   ) {
-    return readBoostCoreGetBoostCount(this._config, {
-      address: this.assertValidAddress(),
+    return await readBoostCoreGetBoostCount(this._config, {
+      ...assertValidAddressByChainId(
+        this._config,
+        this.addresses,
+        params?.chainId,
+      ),
       args: [],
       ...this.optionallyAttachAccount(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -683,7 +831,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>}
    */
@@ -692,7 +840,7 @@ export class BoostCore extends Deployable<
     params?: ReadParams<typeof boostCoreAbi, 'createBoostAuth'> &
       ReadParams<typeof iAuthAbi, 'isAuthorized'>,
   ) {
-    const auth = await this.createBoostAuth();
+    const auth = await this.createBoostAuth(params);
     return readIAuthIsAuthorized(this._config, {
       address: auth,
       args: [address],
@@ -707,14 +855,18 @@ 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'>,
   ) {
-    return readBoostCoreCreateBoostAuth(this._config, {
-      address: this.assertValidAddress(),
+    return await readBoostCoreCreateBoostAuth(this._config, {
+      ...assertValidAddressByChainId(
+        this._config,
+        this.addresses,
+        params?.chainId,
+      ),
       args: [],
       ...this.optionallyAttachAccount(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -728,14 +880,14 @@ 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,
     params?: WriteParams<typeof boostCoreAbi, 'setCreateBoostAuth'>,
   ) {
-    return this.awaitResult(
+    return await this.awaitResult(
       this.setCreateBoostAuthRaw(auth.assertValidAddress(), {
         ...params,
       }),
@@ -748,8 +900,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,
@@ -758,7 +910,11 @@ export class BoostCore extends Deployable<
     const { request, result } = await simulateBoostCoreSetCreateBoostAuth(
       this._config,
       {
-        address: this.assertValidAddress(),
+        ...assertValidAddressByChainId(
+          this._config,
+          this.addresses,
+          params?.chainId,
+        ),
         args: [address],
         ...this.optionallyAttachAccount(),
         // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -774,14 +930,18 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'protocolFee'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {unknown}
    */
   public async protocolFee(
     params?: ReadParams<typeof boostCoreAbi, 'protocolFee'>,
   ) {
-    return readBoostCoreProtocolFee(this._config, {
-      address: this.assertValidAddress(),
+    return await readBoostCoreProtocolFee(this._config, {
+      ...assertValidAddressByChainId(
+        this._config,
+        this.addresses,
+        params?.chainId,
+      ),
       args: [],
       ...this.optionallyAttachAccount(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -794,14 +954,18 @@ 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'>,
   ) {
-    return readBoostCoreProtocolFeeReceiver(this._config, {
-      address: this.assertValidAddress(),
+    return await readBoostCoreProtocolFeeReceiver(this._config, {
+      ...assertValidAddressByChainId(
+        this._config,
+        this.addresses,
+        params?.chainId,
+      ),
       args: [],
       ...this.optionallyAttachAccount(),
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -815,14 +979,14 @@ 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,
     params?: WriteParams<typeof boostCoreAbi, 'setProtocolFeeReceiver'>,
   ) {
-    return this.awaitResult(
+    return await this.awaitResult(
       this.setProcolFeeReceiverRaw(address, {
         ...params,
       }),
@@ -835,8 +999,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,
@@ -845,7 +1009,11 @@ export class BoostCore extends Deployable<
     const { request, result } = await simulateBoostCoreSetProtocolFeeReceiver(
       this._config,
       {
-        address: this.assertValidAddress(),
+        ...assertValidAddressByChainId(
+          this._config,
+          this.addresses,
+          params?.chainId,
+        ),
         args: [address],
         ...this.optionallyAttachAccount(),
         // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
@@ -860,64 +1028,38 @@ export class BoostCore extends Deployable<
   }
 
   /**
-   * Get the claim fee.
+   * Retrieves the claim information from a transaction receipt.
    *
-   * @public
-   * @async
-   * @param {?ReadParams<typeof boostCoreAbi, 'claimFee'>} [params]
-   * @returns {unknown}
-   */
-  public async claimFee(params?: ReadParams<typeof boostCoreAbi, 'claimFee'>) {
-    return readBoostCoreClaimFee(this._config, {
-      address: this.assertValidAddress(),
-      args: [],
-      ...this.optionallyAttachAccount(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
-  }
-
-  /**
-   * Sets the claim fee.
+   * @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.
    *
-   * @public
-   * @async
-   * @param {bigint} claimFee
-   * @param {?WriteParams<typeof boostCoreAbi, 'setClaimFee'>} [params]
-   * @returns {unknown}
-   */
-  public async setClaimFee(
-    claimFee: bigint,
-    params?: WriteParams<typeof boostCoreAbi, 'setClaimFee'>,
-  ) {
-    return this.awaitResult(this.setClaimFeeRaw(claimFee, params));
-  }
-
-  /**
-   * Sets the claim fee.
+   * @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.
    *
-   * @public
-   * @async
-   * @param {bigint} claimFee
-   * @param {?WriteParams<typeof boostCoreAbi, 'setClaimFee'>} [params]
-   * @returns {unknown}
+   * @example
+   * ```ts
+   * const claimInfo = await boostCore.getClaimFromTransaction({
+   *   hash: '0x...',
+   *   chainId: 1
+   * });
+   * if (claimInfo) {
+   *   console.log(`Boost ${claimInfo.boostId} claimed by ${claimInfo.claimer}`);
+   * }
+   * ```
    */
-  public async setClaimFeeRaw(
-    claimFee: bigint,
-    params?: WriteParams<typeof boostCoreAbi, 'setClaimFee'>,
+  public async getClaimFromTransaction(
+    params: GetTransactionReceiptParameters,
   ) {
-    const { request, result } = await simulateBoostCoreSetClaimFee(
-      this._config,
-      {
-        address: this.assertValidAddress(),
-        args: [claimFee],
-        ...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 writeBoostCoreSetClaimFee(this._config, request);
-    return { hash, result };
+    const receipt = await getTransactionReceipt(this._config, params);
+    const logs = parseEventLogs({
+      abi: boostCoreAbi,
+      eventName: 'BoostClaimed',
+      logs: receipt.logs,
+    });
+    return logs.at(0)?.args;
   }
 
   /**
@@ -928,8 +1070,7 @@ export class BoostCore extends Deployable<
    * const auth = core.PassthroughAuth('0x') // is roughly equivalent to
    * const auth = new PassthroughAuth({ config: core._config, account: core._account }, '0x')
    * ```
-   * @param {DeployablePayloadOrAddress<{}>} options
-   * @param {?boolean} [isBase]
+   * @param {Address} address
    * @returns {PassthroughAuth}
    */
   PassthroughAuth(address?: Address) {
@@ -1002,6 +1143,24 @@ export class BoostCore extends Deployable<
   //     isBase,
   //   );
   // }
+  /**
+   * Bound {@link OpenAllowList} constructor that reuses the same configuration as the Boost Core instance.
+   *
+   * @example
+   * ```ts
+   * const list = core.OpenAllowList('0x') // is roughly equivalent to
+   * const list = new OpenAllowList({ config: core._config, account: core._account }, '0x')
+   * ```
+   * @param {?boolean} [isBase]
+   * @returns {OpenAllowList}
+   */
+  OpenAllowList(isBase?: boolean) {
+    return new OpenAllowList(
+      { config: this._config, account: this._account },
+      undefined,
+      isBase,
+    );
+  }
   /**
    * Bound {@link SimpleAllowList} constructor that reuses the same configuration as the Boost Core instance.
    *
@@ -1206,6 +1365,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.
    *