@boostxyz/sdk 0.0.0-alpha.17 → 0.0.0-alpha.19

package/src/Actions/EventAction.ts

@@ -21,12 +21,13 @@ import {
   type Hex,
   type Log,
   type PublicClient,
+  type Transaction,
+  decodeEventLog,
   decodeFunctionData,
   encodeAbiParameters,
   fromHex,
   isAddressEqual,
 } from 'viem';
-import { getLogs } from 'viem/actions';
 import { EventAction as EventActionBases } from '../../dist/deployments.json';
 import type {
   DeployableOptions,
@@ -43,6 +44,8 @@ import {
   TooManyEventActionStepsProvidedError,
   UnparseableAbiParamError,
   UnrecognizedFilterTypeError,
+  ValidationAbiMissingError,
+  ValidationLogsMissingError,
 } from '../errors';
 import {
   type GetLogsParams,
@@ -214,38 +217,19 @@ export interface ActionStep {
 }
 
 /**
- * Parameters for validating an event step.
+ * Parameters for validating an action step.
  *
- * This type omits the 'address' field from GetLogsParams and adds optional fields
- * for logs and known events.
- *
- * @typedef {Object} ValidateEventStepParams
- * @property {Log[]} [logs]
- * @property {Record<Hex, AbiEvent>} [knownEvents]
- * @property {number} [fromBlock]
- * @property {number} [toBlock]
- * @property {Hex} [blockHash]
- * @property {Abi} abi
- * @property {ContractEventName<Abi>} eventName
- */
-export type ValidateEventStepParams = Omit<
-  GetLogsParams<Abi, ContractEventName<Abi>> & {
-    logs?: Log[];
-    knownEvents?: Record<Hex, AbiEvent>;
-  },
-  'address'
->;
-
-/**
- * Parameters for validating a function step.
- *
- * This type includes all parameters required to get a transaction.
- *
- * @typedef {Object} ValidateFunctionStepParams
- * @property {Hex} hash
- * @property {number} [chainId]
+ * @typedef {Object} ValidateActionStepParams
+ * @property {Record<Hex, AbiEvent>} [knownEvents] - Optional record of known events, keyed by their hex signature.
+ * @property {AbiEvent} [event] - Optional ABI event definition.
+ * @property {EventLogs} [logs] - Event logs to validate against. Required if 'hash' is not provided.
+ * @property {Hex} [hash] - Transaction hash to validate against. Required if 'logs' is not provided.
+ * @property {number} [chainId] - Chain ID for the transaction. Required if 'hash' is provided.
  */
-export type ValidateFunctionStepParams = GetTransactionParameters;
+export type ValidateActionStepParams = {
+  knownEvents?: Record<Hex, AbiEvent>;
+  event?: AbiEvent;
+} & ({ logs: EventLogs } | { hash: Hex; chainId: number });
 
 /**
  * You can either supply a simplified version of the payload, or one that explicitly declares action steps.
@@ -347,8 +331,6 @@ export type ReadEventActionParams<
   fnName extends ContractFunctionName<typeof eventActionAbi, 'pure' | 'view'>,
 > = ReadParams<typeof eventActionAbi, fnName>;
 
-type TxParams = ValidateEventStepParams | ValidateFunctionStepParams;
-
 /**
  * A generic event action
  *
@@ -465,7 +447,7 @@ export class EventAction extends DeployableTarget<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof eventActionAbi, 'execute'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<readonly [boolean, `0x${string}`]>}
    */
   public async execute(
@@ -481,8 +463,8 @@ export class EventAction extends DeployableTarget<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof eventActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: readonly [boolean, `0x${string}`]; }>}
    */
   public async executeRaw(
     data: Hex,
@@ -505,10 +487,10 @@ export class EventAction extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?TxParams} [params]
+   * @param ValidateActionStepParams params
    * @returns {Promise<boolean>}
    */
-  public async validateActionSteps(params?: TxParams) {
+  public async validateActionSteps(params: ValidateActionStepParams) {
     const actionSteps = await this.getActionSteps();
     for (const actionStep of actionSteps) {
       if (!(await this.isActionStepValid(actionStep, params))) {
@@ -526,21 +508,75 @@ export class EventAction extends DeployableTarget<
    * @public
    * @async
    * @param {ActionStep} actionStep - The action step to validate. Can be a function of event step.
-   * @param {?TxParams & { chainId?: number }} [params] - Additional parameters for validation, including known events, logs, and chain ID.
+   * @param {ValidateActionStepParams} params - Additional parameters for validation, including hash, known events, logs, and chain ID.
    * @returns {Promise<boolean>}
    */
   public async isActionStepValid(
     actionStep: ActionStep,
-    params?: TxParams & { chainId?: number },
+    params: ValidateActionStepParams,
   ) {
     if (actionStep.signatureType === SignatureType.EVENT) {
-      return await this.isActionEventValid(actionStep, params);
+      const signature = actionStep.signature;
+      let event: AbiEvent;
+      // Lookup ABI based on event signature
+      if (params.knownEvents) {
+        event = params.knownEvents?.[signature] as AbiEvent;
+      } else {
+        event = (events.abi as Record<Hex, AbiEvent>)[signature] as AbiEvent;
+      }
+
+      if (!event) {
+        throw new ValidationAbiMissingError(signature);
+      }
+
+      if (this.isArraylikeIndexed(actionStep, event)) {
+        // If the field is indexed, we can't filter on it
+        throw new UnparseableAbiParamError(
+          actionStep.actionParameter.fieldIndex,
+          event,
+        );
+      }
+
+      params.event = event;
+
+      // Use the provided logs, no need to fetch receipt
+      if ('logs' in params) {
+        return this.isActionEventValid(actionStep, {
+          ...params,
+        });
+      }
+
+      const client = this._config.getClient({
+        chainId: params.chainId,
+      }) as PublicClient;
+      const receipt = await client.getTransactionReceipt({
+        hash: params.hash,
+      });
+      const decodedLogs = receipt.logs.map((log) => {
+        const { eventName, args } = decodeEventLog({
+          abi: [event],
+          data: log.data,
+          topics: log.topics,
+        });
+
+        return { ...log, eventName, args };
+      });
+
+      return this.isActionEventValid(actionStep, {
+        logs: decodedLogs,
+        ...params,
+      });
     }
     if (actionStep.signatureType === SignatureType.FUNC) {
-      return await this.isActionFunctionValid(
-        actionStep,
-        params as ValidateFunctionStepParams,
-      );
+      if ('hash' in params && 'chainId' in params) {
+        const client = this._config.getClient({
+          chainId: params.chainId,
+        }) as PublicClient;
+        const transaction = await client.getTransaction({
+          hash: params.hash,
+        });
+        return this.isActionFunctionValid(actionStep, transaction);
+      }
     }
     return false;
   }
@@ -552,88 +588,49 @@ export class EventAction extends DeployableTarget<
    * @public
    * @async
    * @param {ActionStep} actionStep - The action step containing the event to validate.
-   * @param {?ValidateEventStepParams & { chainId?: number }} [params] - Additional parameters for validation, including known events, logs, and chain ID.
+   * @param {ValidateActionStepParams} params - Additional parameters for validation, including known events and logs
    * @returns {Promise<boolean>} Resolves to true if the action event is valid, throws if input is invalid, otherwise false.
    */
-  public async isActionEventValid(
+  public isActionEventValid(
     actionStep: ActionStep,
-    params?: ValidateEventStepParams & { chainId?: number },
+    params: ValidateActionStepParams,
   ) {
-    const criteria = actionStep.actionParameter;
-    const signature = actionStep.signature;
-    let event: AbiEvent;
-    // Lookup ABI based on event signature
-    if (params?.knownEvents) {
-      event = params.knownEvents[signature] as AbiEvent;
-    } else {
-      event = (events.abi as Record<Hex, AbiEvent>)[signature] as AbiEvent;
-    }
-
-    if (!event) {
-      throw new Error(`No known ABI for given event signature: ${signature}`);
+    if (!('logs' in params)) {
+      throw new ValidationLogsMissingError();
     }
-
-    if (this.isArraylikeIndexed(actionStep, event)) {
-      // If the field is indexed, we can't filter on it
-      throw new UnparseableAbiParamError(
-        actionStep.actionParameter.fieldIndex,
-        event,
-      );
-    }
-    const targetContract = actionStep.targetContract;
-    // Get all logs matching the event signature from the target contract
-    const logs =
-      params?.logs ||
-      (await getLogs(this._config.getClient({ chainId: params?.chainId }), {
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-        ...(params as any),
-        address: targetContract,
-        event,
-      }));
+    const criteria = actionStep.actionParameter;
+    const logs = params.logs;
     if (!logs.length) return false;
     for (let log of logs) {
-      if (!this.validateLogAgainstCriteria(criteria, log as EventLogs[0])) {
-        return false;
+      if (this.validateLogAgainstCriteria(criteria, log)) {
+        return true;
       }
     }
-    return true;
+    return false;
   }
   /**
    * Validates a single action function with a given criteria against the transaction input.
-   * If a transaction hash is provided in the optional `params` argument, then the transaction
-   * will be fetched and decoded using the configured client.
    *
    * @public
    * @async
    * @param {ActionStep} actionStep - The action step containing the function to validate.
-   * @param {?ValidateFunctionStepParams & { chainId?: number }} [params] - Additional parameters for validation, including known events, transaction hash, and chain ID.
+   * @param {Transaction} transaction - The transaction that will be validated against.
    * @returns {Promise<boolean>} Resolves to true if the action function is valid, throws if the inputs are invalid, otherwise false.
    */
-  public async isActionFunctionValid(
+  public isActionFunctionValid(
     actionStep: ActionStep,
-    params?: ValidateFunctionStepParams & { chainId?: number },
+    transaction: Transaction,
   ) {
     const criteria = actionStep.actionParameter;
     let signature = actionStep.signature;
 
-    if (!params || !params?.hash) {
-      // Should we return false in this case?
-      throw new Error('Hash is required for function validation');
-    }
-    const client = this._config.getClient({
-      chainId: params?.chainId,
-    }) as PublicClient;
-    // Fetch the transaction receipt and decode the function input using `viem` utilities
-    const transaction = await client.getTransaction({ hash: params.hash });
     const func = (functions.abi as Record<Hex, AbiFunction>)[
       signature
     ] as AbiFunction;
-
     if (!func) {
-      throw new Error(
-        `No known ABI for given function signature: ${signature}`,
-      );
+      throw new ValidationAbiMissingError(signature);
     }
+
     let decodedData;
     try {
       decodedData = decodeFunctionData({
@@ -664,7 +661,10 @@ export class EventAction extends DeployableTarget<
    * Validates a field against a given criteria.
    *
    * @param {Criteria} criteria - The criteria to validate against.
-   * @param {string | bigint} fieldValue - The field value to validate.
+   * @param {string | bigint | Hex} fieldValue - The field value to validate.
+   * @param {Object} input - Additional context for validation.
+   * @param {EventLogs[0]} [input.log] - The event log, if validating an event.
+   * @param {readonly (string | bigint)[]} [input.decodedArgs] - The decoded function arguments, if validating a function call.
    * @returns {Promise<boolean>} - Returns true if the field passes the criteria, false otherwise.
    */
   public validateFieldAgainstCriteria(

package/src/AllowLists/SimpleAllowList.ts

@@ -115,7 +115,7 @@ export class SimpleAllowList extends DeployableTargetWithRBAC<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'owner'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>} - The address of the owner
    */
   public async owner(
@@ -136,7 +136,7 @@ export class SimpleAllowList extends DeployableTargetWithRBAC<
    * @public
    * @async
    * @param {Address} address - The address of the user
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'setAllowed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>} - True if the user is authorized
    */
   public async isAllowed(
@@ -160,7 +160,7 @@ export class SimpleAllowList extends DeployableTargetWithRBAC<
    * @async
    * @param {Address[]} addresses - The list of users to update
    * @param {boolean[]} allowed - The allowed status of each user
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'setAllowed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<void>}
    */
   public async setAllowed(
@@ -181,8 +181,8 @@ export class SimpleAllowList extends DeployableTargetWithRBAC<
    * @async
    * @param {Address[]} addresses - The list of users to update
    * @param {boolean[]} allowed - The allowed status of each user
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'setAllowed'>} [params]
-   * @returns {Promise<void>}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async setAllowedRaw(
     addresses: Address[],

package/src/AllowLists/SimpleDenyList.ts

@@ -107,7 +107,7 @@ export class SimpleDenyList<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof simpleDenyListAbi, 'owner'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>} - The address of the owner
    */
   public async owner(
@@ -128,7 +128,7 @@ export class SimpleDenyList<
    * @public
    * @async
    * @param {Address} address - The address of the user
-   * @param {?ReadParams<typeof simpleDenyListAbi, 'isAllowed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>} - True if the user is authorized
    */
   public async isAllowed(
@@ -151,8 +151,8 @@ export class SimpleDenyList<
    * @async
    * @param {Address[]} addresses - The list of users to update
    * @param {boolean[]} allowed - The denied status of each user
-   * @param {?WriteParams<typeof simpleDenyListAbi, 'setDenied'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
    */
   public async setDenied(
     addresses: Address[],
@@ -171,8 +171,8 @@ export class SimpleDenyList<
    * @async
    * @param {Address[]} addresses - The list of users to update
    * @param {boolean[]} allowed - The denied status of each user
-   * @param {?WriteParams<typeof simpleDenyListAbi, 'setDenied'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async setDeniedRaw(
     addresses: Address[],

package/src/Boost.ts

@@ -12,6 +12,25 @@ import type { Budget } from './Budgets/Budget';
 import type { Incentive } from './Incentives/Incentive';
 import type { Validator } from './Validators/Validator';
 
+/**
+ * Interface representing a `BoostLib.Boost` on-chain struct
+ *
+ * @export
+ * @interface BoostPayload
+ * @typedef {BoostPayload}
+ */
+export interface RawBoost {
+  action: Address;
+  validator: Address;
+  allowList: Address;
+  budget: Address;
+  incentives: readonly Address[];
+  protocolFee: bigint;
+  referralFee: bigint;
+  maxParticipants: bigint;
+  owner: Address;
+}
+
 /**
  * Configuration used to instantiate a `Boost` instance.
  *

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)
+  });
 });