@boostxyz/sdk 0.0.0-alpha.20 → 0.0.0-alpha.21

package/src/BoostCore.ts

@@ -1,7 +1,6 @@
 import {
   boostCoreAbi,
   type iAuthAbi,
-  readBoostCoreClaimFee,
   readBoostCoreCreateBoostAuth,
   readBoostCoreGetBoost,
   readBoostCoreGetBoostCount,
@@ -10,12 +9,11 @@ import {
   readIAuthIsAuthorized,
   simulateBoostCoreClaimIncentive,
   simulateBoostCoreClaimIncentiveFor,
-  simulateBoostCoreSetClaimFee,
+  simulateBoostCoreCreateBoost,
   simulateBoostCoreSetCreateBoostAuth,
   simulateBoostCoreSetProtocolFeeReceiver,
   writeBoostCoreClaimIncentive,
   writeBoostCoreClaimIncentiveFor,
-  writeBoostCoreSetClaimFee,
   writeBoostCoreSetCreateBoostAuth,
   writeBoostCoreSetProtocolFeeReceiver,
 } from '@boostxyz/evm';
@@ -26,6 +24,7 @@ import {
   getTransactionReceipt,
   waitForTransactionReceipt,
 } from '@wagmi/core';
+import type { SimulateContractReturnType } from '@wagmi/core/actions';
 import { createWriteContract } from '@wagmi/core/codegen';
 import {
   type Address,
@@ -53,6 +52,7 @@ import { type Auth, PassthroughAuth } from './Auth/Auth';
 import {
   Boost,
   type BoostPayload,
+  type RawBoost,
   type Target,
   prepareBoostPayload,
 } from './Boost';
@@ -100,6 +100,7 @@ import {
 import { type Validator, validatorFromAddress } from './Validators/Validator';
 import {
   BoostCoreNoIdentifierEmitted,
+  BoostNotFoundError,
   BudgetMustAuthorizeBoostCore,
   DeployableUnknownOwnerProvidedError,
   IncentiveNotCloneableError,
@@ -246,7 +247,6 @@ export type CreateBoostPayload = {
   allowList: AllowList;
   incentives: Array<Incentive>;
   protocolFee?: bigint;
-  referralFee?: bigint;
   maxParticipants?: bigint;
   owner?: Address;
 };
@@ -310,13 +310,14 @@ export class BoostCore extends Deployable<
     //@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]
+   * @param {?DeployableOptions} [_params]
    * @returns {Promise<Boost>}
    */
   public async createBoost(
@@ -333,45 +334,122 @@ export class BoostCore extends Deployable<
       desiredChainId,
     );
 
-    let {
-      budget,
-      action,
-      validator,
-      allowList,
-      incentives,
-      protocolFee = 0n,
-      referralFee = 0n,
-      maxParticipants = 0n,
-      owner,
-    } = payload;
-
     const boostFactory = createWriteContract({
       abi: boostCoreAbi,
       functionName: 'createBoost',
       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();
       }
     }
 
-    if (!validator) {
-      validator = this.SignerValidator({
-        signers: [owner],
+    if (!payload.validator) {
+      payload.validator = this.SignerValidator({
+        signers: [payload.owner],
         validatorCaller: coreAddress,
       });
     }
 
     let budgetPayload: BoostPayload['budget'] = zeroAddress;
-    if (budget.address) {
-      budgetPayload = budget.address;
-      if (!(await budget.isAuthorized(coreAddress))) {
+    if (payload.budget.address) {
+      budgetPayload = payload.budget.address;
+      if (!(await payload.budget.isAuthorized(coreAddress))) {
         throw new BudgetMustAuthorizeBoostCore(coreAddress);
       }
     } else {
@@ -385,21 +463,23 @@ export class BoostCore extends Deployable<
       isBase: true,
       parameters: zeroHash,
     };
-    if (action.address) {
-      const isBase = 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;
+        payload.action.buildParameters(undefined, options).args.at(0) ||
+        zeroHash;
       actionPayload.instance = assertValidAddressByChainId(
         options.config,
-        action.bases,
+        payload.action.bases,
         chainId,
       ).address;
     }
@@ -409,21 +489,23 @@ export class BoostCore extends Deployable<
       isBase: true,
       parameters: zeroHash,
     };
-    if (validator.address) {
-      const isBase = 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(undefined, options).args.at(0) || zeroHash
+          ? payload.validator.buildParameters(undefined, options).args.at(0) ||
+            zeroHash
           : zeroHash,
       };
     } else {
       validatorPayload.parameters =
-        validator.buildParameters(undefined, options).args.at(0) || zeroHash;
+        payload.validator.buildParameters(undefined, options).args.at(0) ||
+        zeroHash;
       validatorPayload.instance = assertValidAddressByChainId(
         options.config,
-        validator.bases,
+        payload.validator.bases,
         chainId,
       ).address;
     }
@@ -433,33 +515,34 @@ export class BoostCore extends Deployable<
       isBase: true,
       parameters: zeroHash,
     };
-    if (allowList.address) {
-      const isBase = 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;
+        payload.allowList.buildParameters(undefined, options).args.at(0) ||
+        zeroHash;
       allowListPayload.instance = assertValidAddressByChainId(
         options.config,
-        allowList.bases,
+        payload.allowList.bases,
         chainId,
       ).address;
     }
 
-    const 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.isBase;
         if (!isBase) throw new IncentiveNotCloneableError(incentive);
@@ -490,46 +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, {
-      ...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.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) =>
-        // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
-        incentive.at(boost.incentives.at(i)!),
-      ),
-      protocolFee: boost.protocolFee,
-      referralFee: boost.referralFee,
-      maxParticipants: boost.maxParticipants,
-      owner: boost.owner,
-    });
+    return onChainPayload;
   }
 
   /**
@@ -670,21 +719,37 @@ export class BoostCore extends Deployable<
    *
    * @public
    * @async
-   * @param {bigint} id
+   * @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 await 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;
+    }
   }
 
   /**
@@ -695,6 +760,7 @@ export class BoostCore extends Deployable<
    * @param {(string | bigint)} _id
    * @param {?ReadParams} [params]
    * @returns {Promise<Boost>}
+   * @throws {@link BoostNotFoundError}
    */
   public async getBoost(
     _id: string | bigint,
@@ -704,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,
@@ -735,7 +796,6 @@ export class BoostCore extends Deployable<
       allowList,
       incentives,
       protocolFee,
-      referralFee,
       maxParticipants,
       owner,
     });
@@ -967,75 +1027,6 @@ export class BoostCore extends Deployable<
     return { hash, result };
   }
 
-  /**
-   * Get the claim fee.
-   *
-   * @public
-   * @async
-   * @param {?ReadParams} [params]
-   * @returns {Promise<bigint>}
-   */
-  public async claimFee(params?: ReadParams<typeof boostCoreAbi, 'claimFee'>) {
-    return await readBoostCoreClaimFee(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
-      ...(params as any),
-    });
-  }
-
-  /**
-   * Sets the claim fee.
-   *
-   * @public
-   * @async
-   * @param {bigint} claimFee
-   * @param {?WriteParams} [params]
-   * @returns {Promise<void>}
-   */
-  public async setClaimFee(
-    claimFee: bigint,
-    params?: WriteParams<typeof boostCoreAbi, 'setClaimFee'>,
-  ) {
-    return await this.awaitResult(this.setClaimFeeRaw(claimFee, params));
-  }
-
-  /**
-   * Sets the claim fee.
-   *
-   * @public
-   * @async
-   * @param {bigint} claimFee
-   * @param {?WriteParams} [params]
-   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
-   */
-  public async setClaimFeeRaw(
-    claimFee: bigint,
-    params?: WriteParams<typeof boostCoreAbi, 'setClaimFee'>,
-  ) {
-    const { request, result } = await simulateBoostCoreSetClaimFee(
-      this._config,
-      {
-        ...assertValidAddressByChainId(
-          this._config,
-          this.addresses,
-          params?.chainId,
-        ),
-        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 };
-  }
-
   /**
    * Retrieves the claim information from a transaction receipt.
    *

package/src/BoostRegistry.test.ts

@@ -0,0 +1,53 @@
+import { loadFixture } from '@nomicfoundation/hardhat-toolbox-viem/network-helpers';
+import { pad, parseEther, zeroAddress, isAddress } 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';
+import { ContractAction } from './Actions/ContractAction';
+import type { ERC20Incentive } from './Incentives/ERC20Incentive';
+import { StrategyType } from './claiming';
+import { BoostNotFoundError, IncentiveNotCloneableError } from './errors';
+import { bytes4, RegistryType } from './utils';
+import { BOOST_CORE_CLAIM_FEE } from './BoostCore';
+import { accounts } from '@boostxyz/test/accounts';
+import { SimpleAllowList } from './AllowLists/SimpleAllowList';
+
+let fixtures: Fixtures, budgets: BudgetFixtures;
+
+describe('BoostRegistry', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+  });
+
+  test('can initialize a new component', async () => {
+    const { registry, core } = fixtures;
+    const allowlist = await registry.initialize('NewAllowList', core.SimpleAllowList({
+      owner: zeroAddress,
+      allowed: []
+    }))
+    expect(isAddress(allowlist.assertValidAddress())).toBe(true)
+  });
+
+  test('can use a clones identifier to get the clone', async () => {
+    const { registry, bases } = fixtures;
+    const id = await registry.getCloneIdentifier(
+      RegistryType.ALLOW_LIST,
+      bases.SimpleAllowList.bases[31337]!,
+      defaultOptions.account.address,
+      'NewAllowList'
+    )
+    expect(await registry.getClone(id)).toMatchObject({
+      baseType: RegistryType.ALLOW_LIST,
+      instance: expect.any(String),
+      deployer: defaultOptions.account.address,
+      name: 'NewAllowList'
+    })
+  });
+});

package/src/BoostRegistry.ts

@@ -1,6 +1,7 @@
 import {
   boostRegistryAbi,
   readBoostRegistryGetBaseImplementation,
+  readBoostRegistryGetClone,
   readBoostRegistryGetCloneIdentifier,
   readBoostRegistryGetClones,
   simulateBoostRegistryDeployClone,
@@ -10,6 +11,7 @@ import {
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/BoostRegistry.sol/BoostRegistry.json';
 import {
+  type Abi,
   type Address,
   type ContractEventName,
   type Hex,
@@ -74,6 +76,24 @@ export type BoostRegistryLog<
   >,
 > = GenericLog<typeof boostRegistryAbi, event>;
 
+/**
+ * An interface representing an on-chain Clone
+ *
+ * @export
+ * @interface Clone
+ * @typedef {Clone}
+ */
+export interface Clone {
+  // The clone's component type'
+  baseType: RegistryType;
+  // The address of the initialized clone.
+  instance: Address;
+  // The deployer of the clone.
+  deployer: Address;
+  // The display name of the clone
+  name: string;
+}
+
 /**
  * Instantiation options for a previously deployed Boost Registry
  *
@@ -295,6 +315,31 @@ export class BoostRegistry extends Deployable<
     return this.clone(displayName, target, params);
   }
 
+  /**
+   * Initialize a new instance of a registered base implementation, returning a transaction hash, resulting address from simulated transaction, and the given target bound to the resulting address.
+   * This method is the same as `deployCloneRaw`, but serves to make its function more obvious as to why you'd need to use it.
+   *
+   * @public
+   * @async
+   * @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} [params]
+   * @returns {Promise<HashAndSimulatedResult<Address> & { target: Target } >} - The transaction hash, simulated return address, and given target bound to simulated return address
+   */
+  public async initializeRaw<Target extends DeployableTarget<unknown, Abi>>(
+    displayName: string,
+    target: Target,
+    params?: WriteParams<typeof boostRegistryAbi, 'deployClone'>,
+  ): Promise<HashAndSimulatedResult<Address> & { target: Target }> {
+    const { hash, result } = await this.deployCloneRaw(
+      displayName,
+      target,
+      params,
+    );
+    return { hash, result, target: target.at(result) };
+  }
+
   /**
    * Deploy a new instance of a registered base implementation, returning the provided target with a new address set on it.
    *
@@ -414,13 +459,13 @@ export class BoostRegistry extends Deployable<
    * @async
    * @param {Hex} identifier - The unique identifier for the deployed clone (see {getCloneIdentifier})
    * @param {?ReadParams} [params]
-   * @returns {Promise<Address>} - The address of the deployed clone
+   * @returns {Promise<Clone>} - The on-chain representation of the clone
    */
   public async getClone(
     identifier: Hex,
     params?: ReadParams<typeof boostRegistryAbi, 'getClone'>,
-  ) {
-    return await readBoostRegistryGetBaseImplementation(this._config, {
+  ): Promise<Clone> {
+    return await readBoostRegistryGetClone(this._config, {
       ...assertValidAddressByChainId(
         this._config,
         this.addresses,