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

package/src/Actions/EventAction.ts

@@ -8,6 +8,7 @@ import {
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/actions/EventAction.sol/EventAction.json';
 import events from '@boostxyz/signatures/events';
 import functions from '@boostxyz/signatures/functions';
+import { match } from 'ts-pattern';
 import {
   type Abi,
   type AbiEvent,
@@ -20,14 +21,13 @@ import {
   type Hex,
   type Log,
   type PublicClient,
+  type Transaction,
+  decodeEventLog,
   decodeFunctionData,
   encodeAbiParameters,
   fromHex,
   isAddressEqual,
-  pad,
-  trim,
 } from 'viem';
-import { getLogs } from 'viem/actions';
 import { EventAction as EventActionBases } from '../../dist/deployments.json';
 import type {
   DeployableOptions,
@@ -44,6 +44,8 @@ import {
   TooManyEventActionStepsProvidedError,
   UnparseableAbiParamError,
   UnrecognizedFilterTypeError,
+  ValidationAbiMissingError,
+  ValidationLogsMissingError,
 } from '../errors';
 import {
   type GetLogsParams,
@@ -215,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.
@@ -348,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
  *
@@ -466,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(
@@ -482,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,
@@ -506,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))) {
@@ -527,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;
   }
@@ -553,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 (!('logs' in params)) {
+      throw new ValidationLogsMissingError();
     }
-
-    if (!event) {
-      throw new Error(`No known ABI for given event signature: ${signature}`);
-    }
-
-    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({
@@ -665,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(
@@ -678,13 +677,35 @@ export class EventAction extends DeployableTarget<
     // Type narrow based on criteria.filterType
     switch (criteria.filterType) {
       case FilterType.EQUAL:
-        if (criteria.fieldType === PrimitiveType.ADDRESS) {
-          return isAddressEqual(criteria.filterData, fieldValue as Address);
-        }
-        return fieldValue === criteria.filterData;
+        return match(criteria.fieldType)
+          .with(PrimitiveType.ADDRESS, () =>
+            isAddressEqual(criteria.filterData, fieldValue as Address),
+          )
+          .with(
+            PrimitiveType.UINT,
+            () => BigInt(fieldValue) === BigInt(criteria.filterData),
+          )
+          .with(
+            PrimitiveType.STRING,
+            () => fieldValue === fromHex(criteria.filterData, 'string'),
+          )
+          .otherwise(() => fieldValue === criteria.filterData);
 
       case FilterType.NOT_EQUAL:
-        return fieldValue !== criteria.filterData;
+        return match(criteria.fieldType)
+          .with(
+            PrimitiveType.ADDRESS,
+            () => !isAddressEqual(criteria.filterData, fieldValue as Address),
+          )
+          .with(
+            PrimitiveType.UINT,
+            () => BigInt(fieldValue) !== BigInt(criteria.filterData),
+          )
+          .with(
+            PrimitiveType.STRING,
+            () => fieldValue !== fromHex(criteria.filterData, 'string'),
+          )
+          .otherwise(() => fieldValue !== criteria.filterData);
 
       case FilterType.GREATER_THAN:
         if (criteria.fieldType === PrimitiveType.UINT) {

package/src/AllowLists/SimpleAllowList.ts

@@ -2,9 +2,7 @@ import {
   readSimpleAllowListIsAllowed,
   readSimpleAllowListOwner,
   simpleAllowListAbi,
-  simulateSimpleAllowListGrantRoles,
   simulateSimpleAllowListSetAllowed,
-  writeSimpleAllowListGrantRoles,
   writeSimpleAllowListSetAllowed,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleAllowList.sol/SimpleAllowList.json';
@@ -22,7 +20,10 @@ import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
-import { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  DeployableTargetWithRBAC,
+  Roles,
+} from '../Deployable/DeployableTargetWithRBAC';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
 import {
   type GenericLog,
@@ -73,18 +74,19 @@ export type SimpleAllowListLog<
 /**
  * A constant representing the list manager's role
  *
- * @type {2n}
+ * @deprecated use {@link Roles} instead
+ * @type {1n}
  */
-export const LIST_MANAGER_ROLE = 2n;
+export const LIST_MANAGER_ROLE = Roles.MANAGER;
 /**
  * A simple implementation of an AllowList that checks if a user is authorized based on a list of allowed addresses
  *
  * @export
  * @class SimpleAllowList
  * @typedef {SimpleAllowList}
- * @extends {DeployableTarget<SimpleAllowListPayload>}
+ * @extends {DeployableTargetWithRBAC<SimpleAllowListPayload>}
  */
-export class SimpleAllowList extends DeployableTarget<
+export class SimpleAllowList extends DeployableTargetWithRBAC<
   SimpleAllowListPayload,
   typeof simpleAllowListAbi
 > {
@@ -113,7 +115,7 @@ export class SimpleAllowList extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'owner'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>} - The address of the owner
    */
   public async owner(
@@ -134,7 +136,7 @@ export class SimpleAllowList extends DeployableTarget<
    * @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(
@@ -158,7 +160,7 @@ export class SimpleAllowList extends DeployableTarget<
    * @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(
@@ -179,8 +181,8 @@ export class SimpleAllowList extends DeployableTarget<
    * @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[],
@@ -201,53 +203,6 @@ export class SimpleAllowList extends DeployableTarget<
     return { hash, result };
   }
 
-  /**
-   * Allows the owner to grant `user` `roles`.
-   *
-   * @public
-   * @async
-   * @param {Address} address
-   * @param {bigint} role
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'grantRoles'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async grantRoles(
-    address: Address,
-    role: bigint,
-    params?: WriteParams<typeof simpleAllowListAbi, 'grantRoles'>,
-  ) {
-    return await this.awaitResult(this.grantRolesRaw(address, role, params));
-  }
-
-  /**
-   * Allows the owner to grant `user` `roles`.
-   *
-   * @public
-   * @async
-   * @param {Address} address
-   * @param {bigint} role
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'grantRoles'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async grantRolesRaw(
-    address: Address,
-    role: bigint,
-    params?: ReadParams<typeof simpleAllowListAbi, 'grantRoles'>,
-  ) {
-    const { request, result } = await simulateSimpleAllowListGrantRoles(
-      this._config,
-      {
-        address: this.assertValidAddress(),
-        args: [address, role],
-        ...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 writeSimpleAllowListGrantRoles(this._config, request);
-    return { hash, result };
-  }
-
   /**
    * @inheritdoc
    *

package/src/AllowLists/SimpleDenyList.ts

@@ -20,7 +20,7 @@ import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
-import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
 import {
   type GenericLog,
@@ -74,11 +74,14 @@ export type SimpleDenyListLog<
  * @export
  * @class SimpleDenyList
  * @typedef {SimpleDenyList}
- * @extends {DeployableTarget<SimpleDenyListPayload>}
+ * @extends {DeployableTargetWithRBAC<SimpleDenyListPayload>}
  */
 export class SimpleDenyList<
   Payload = SimpleDenyListPayload,
-> extends DeployableTarget<Payload | undefined, typeof simpleDenyListAbi> {
+> extends DeployableTargetWithRBAC<
+  Payload | undefined,
+  typeof simpleDenyListAbi
+> {
   public override readonly abi = simpleDenyListAbi;
   /**
    * @inheritdoc
@@ -104,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(
@@ -125,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(
@@ -148,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[],
@@ -168,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.
  *