@boostxyz/sdk 7.2.0 → 7.3.0

package/src/Actions/EventAction.ts

@@ -576,18 +576,25 @@ export class EventAction extends DeployableTarget<
         throw new ValidationAbiMissingError(signature);
       }
 
-      let address: Address | undefined;
       if ('logs' in params) {
-        for (let log of params.logs) {
+        const signatureMatchingLogs = params.logs
+          .filter((log) => log.topics[0] === signature)
+          .map((log) => decodeAndReorderLogArgs(event, log));
+
+        for (const log of signatureMatchingLogs) {
           if (!isAddressEqual(log.address, claimant.targetContract)) continue;
-          let addressCandidate = this.validateClaimantAgainstArgs(
+          const addressCandidate = this.validateClaimantAgainstArgs(
             claimant,
             log,
           );
           if (addressCandidate) return addressCandidate;
         }
-        return address;
       }
+
+      if (!('hash' in params)) {
+        return undefined;
+      }
+
       const receipt = await getTransactionReceipt(this._config, {
         ...params,
         chainId: claimant.chainid,
@@ -613,7 +620,6 @@ export class EventAction extends DeployableTarget<
         let addressCandidate = this.validateClaimantAgainstArgs(claimant, log);
         if (addressCandidate) return addressCandidate;
       }
-      return address;
     }
     if (claimant.signatureType === SignatureType.FUNC && 'hash' in params) {
       const transaction = await getTransaction(this._config, {
@@ -1252,6 +1258,139 @@ export class EventAction extends DeployableTarget<
     }
     return false;
   }
+
+  /**
+   * Retrieves logs that match the criteria for event-based action steps.
+   *
+   * @public
+   * @async
+   * @param {ValidateActionStepParams} params - Parameters for fetching and filtering logs.
+   * @returns {Promise<EventLog[]>} - A promise that resolves to an array of matching event logs.
+   */
+  public async getLogsForActionSteps(
+    params: ValidateActionStepParams,
+  ): Promise<EventLog[]> {
+    const actionSteps = await this.getActionSteps();
+    const actionStepLogs: EventLog[] = [];
+
+    for (const actionStep of actionSteps) {
+      if (actionStep.signatureType === SignatureType.EVENT) {
+        const logs = await this.getLogsForActionStep(actionStep, params);
+        actionStepLogs.push(...logs);
+      }
+    }
+    return actionStepLogs;
+  }
+
+  /**
+   * Finds logs that match the criteria for a specific action step.
+   *
+   * @public
+   * @async
+   * @param {ActionStep} actionStep - The action step to find logs for
+   * @param {ValidateActionStepParams} params - Parameters for validation
+   * @returns {Promise<EventLog[]>}
+   */
+  public async getLogsForActionStep(
+    actionStep: ActionStep,
+    params: ValidateActionStepParams,
+  ): Promise<EventLog[]> {
+    if (actionStep.signatureType !== SignatureType.EVENT) {
+      return [];
+    }
+
+    const signature = actionStep.signature;
+    let event: AbiEvent;
+    if (params.abiItem) event = params.abiItem as AbiEvent;
+    else {
+      const sigPool = params.knownSignatures as Record<Hex, AbiEvent>;
+      event = sigPool[signature] as AbiEvent;
+    }
+
+    if (!event) {
+      throw new ValidationAbiMissingError(signature);
+    }
+
+    if ('logs' in params) {
+      return this.filterLogsByActionStepCriteria(
+        actionStep,
+        params.logs,
+        event,
+      );
+    }
+
+    const receipt = await getTransactionReceipt(this._config, {
+      ...params,
+      chainId: actionStep.chainid,
+    });
+
+    if (
+      params.notBeforeBlockNumber &&
+      receipt.blockNumber < params.notBeforeBlockNumber
+    ) {
+      return [];
+    }
+
+    // Special handling for Transfer events
+    if (actionStep.signature === TRANSFER_SIGNATURE) {
+      const { decodedLogs, event } = await this.decodeTransferLogs(receipt);
+      return this.filterLogsByActionStepCriteria(
+        actionStep,
+        decodedLogs,
+        event,
+      );
+    }
+
+    const decodedLogs = receipt.logs
+      .filter((log) => log.topics[0] === toEventSelector(event))
+      .map((log) => decodeAndReorderLogArgs(event, log));
+
+    return this.filterLogsByActionStepCriteria(actionStep, decodedLogs, event);
+  }
+
+  /**
+   * Filters logs that meet the given action step criteria
+   *
+   * @private
+   * @param {ActionStep} actionStep
+   * @param {EventLogs} logs
+   * @param {AbiEvent} eventAbi
+   * @returns {EventLog[]}
+   */
+  private filterLogsByActionStepCriteria(
+    actionStep: ActionStep,
+    logs: EventLogs,
+    eventAbi: AbiEvent,
+  ): EventLog[] {
+    const criteria = actionStep.actionParameter;
+    const filteredLogs: EventLog[] = [];
+
+    if (!logs.length) return filteredLogs;
+
+    for (let log of logs) {
+      if (!isAddressEqual(log.address, actionStep.targetContract)) continue;
+
+      try {
+        if (!Array.isArray(log.args)) {
+          continue;
+        }
+        const { value, type } = this.parseFieldFromAbi(
+          log.args,
+          criteria.fieldIndex,
+          eventAbi.inputs || [],
+          criteria.fieldType,
+        );
+        criteria.fieldType = type;
+        if (this.validateFieldAgainstCriteria(criteria, value, { log })) {
+          filteredLogs.push(log as EventLog);
+        }
+      } catch {
+        // If there's an error on this log, keep trying with the next one
+      }
+    }
+
+    return filteredLogs;
+  }
 }
 
 /**

package/src/Incentives/ERC20PeggedVariableCriteriaIncentiveV2.ts

@@ -37,6 +37,7 @@ import {
 import { ERC20PeggedVariableCriteriaIncentiveV2 as ERC20PeggedVariableCriteriaIncentiveV2Bases } from '../../dist/deployments.json';
 import {
   SignatureType,
+  decodeAndReorderLogArgs,
   getScalarValueFromTuple,
   isCriteriaFieldIndexTuple,
 } from '../Actions/EventAction';
@@ -235,25 +236,63 @@ export class ERC20PeggedVariableCriteriaIncentiveV2 extends DeployableTarget<
    * @throws {InvalidCriteriaTypeError | NoMatchingLogsError | DecodedArgsError}
    */
   public async getIncentiveScalar(
-    { chainId, hash, knownSignatures }: GetIncentiveScalarV2Params,
+    { chainId, hash, knownSignatures, logs }: GetIncentiveScalarV2Params,
     params?: ReadParams,
   ): Promise<bigint> {
     const criteria = await this.getIncentiveCriteria(params);
     if (criteria.criteriaType === SignatureType.EVENT) {
-      const transactionReceipt = await getTransactionReceipt(this._config, {
-        chainId,
-        hash,
-      });
+      const eventAbi = knownSignatures[criteria.signature] as AbiEvent;
+
       if (criteria.fieldIndex === CheatCodes.GAS_REBATE_INCENTIVE) {
+        const transactionReceipt = await getTransactionReceipt(this._config, {
+          chainId,
+          hash,
+        });
         const totalCost =
           transactionReceipt.gasUsed * transactionReceipt.effectiveGasPrice + // Normal gas cost
           (transactionReceipt.blobGasUsed ?? 0n) *
             (transactionReceipt.blobGasPrice ?? 0n); // Blob gas cost - account for potential undefined values
         return totalCost;
       }
-      const logs = transactionReceipt.logs;
 
-      if (logs.length === 0) {
+      // if logs are provided, use them to extract the scalar
+      if (logs && logs.length > 0) {
+        try {
+          // only check logs that match the criteria signature
+          const signatureMatchingLogs = logs
+            .filter((log) => log.topics && log.topics[0] === criteria.signature)
+            .map((log) => decodeAndReorderLogArgs(eventAbi, log));
+
+          if (signatureMatchingLogs.length > 0) {
+            for (const log of signatureMatchingLogs) {
+              if (isCriteriaFieldIndexTuple(criteria.fieldIndex)) {
+                return getScalarValueFromTuple(
+                  log.args as unknown[],
+                  criteria.fieldIndex,
+                );
+              }
+              const scalarValue = log.args
+                ? (log.args as string[])[criteria.fieldIndex]
+                : undefined;
+              if (scalarValue !== undefined) {
+                return BigInt(scalarValue);
+              }
+            }
+          }
+        } catch (e) {
+          throw new DecodedArgsError(
+            `An error occurred while extracting scalar from logs: ${(e as Error).message}`,
+          );
+        }
+      }
+
+      const transactionReceipt = await getTransactionReceipt(this._config, {
+        chainId,
+        hash,
+      });
+      const receiptLogs = transactionReceipt.logs;
+
+      if (receiptLogs.length === 0) {
         throw new NoMatchingLogsError(
           `No logs found for event signature ${criteria.signature}`,
         );
@@ -264,7 +303,7 @@ export class ERC20PeggedVariableCriteriaIncentiveV2 extends DeployableTarget<
         const eventAbi = knownSignatures[criteria.signature] as AbiEvent;
         const decodedEvents = parseEventLogs({
           abi: [eventAbi],
-          logs,
+          logs: receiptLogs,
         });
         if (decodedEvents == undefined || decodedEvents.length === 0) {
           throw new NoMatchingLogsError(

package/src/Incentives/ERC20VariableCriteriaIncentiveV2.ts

@@ -9,6 +9,7 @@ import {
   type AbiEvent,
   type AbiFunction,
   type Address,
+  type GetLogsReturnType,
   type Hex,
   decodeAbiParameters,
   decodeFunctionData,
@@ -22,6 +23,7 @@ import { ERC20VariableCriteriaIncentiveV2 as ERC20VariableCriteriaIncentiveV2Bas
 import {
   SignatureType,
   ValueType,
+  decodeAndReorderLogArgs,
   getScalarValueFromTuple,
   isCriteriaFieldIndexTuple,
 } from '../Actions/EventAction';
@@ -115,6 +117,7 @@ export interface GetIncentiveScalarV2Params {
   chainId: number;
   hash: Hex;
   knownSignatures: Record<Hex, AbiFunction | AbiEvent>;
+  logs?: GetLogsReturnType<AbiEvent, AbiEvent[], true>;
 }
 
 /**
@@ -247,25 +250,63 @@ export class ERC20VariableCriteriaIncentiveV2 extends ERC20VariableIncentive<
    * @throws {InvalidCriteriaTypeError | NoMatchingLogsError | DecodedArgsError}
    */
   public async getIncentiveScalar(
-    { chainId, hash, knownSignatures }: GetIncentiveScalarV2Params,
+    { chainId, hash, knownSignatures, logs }: GetIncentiveScalarV2Params,
     params?: ReadParams,
   ): Promise<bigint> {
     const criteria = await this.getIncentiveCriteria(params);
     if (criteria.criteriaType === SignatureType.EVENT) {
-      const transactionReceipt = await getTransactionReceipt(this._config, {
-        chainId,
-        hash,
-      });
+      const eventAbi = knownSignatures[criteria.signature] as AbiEvent;
+
       if (criteria.fieldIndex === CheatCodes.GAS_REBATE_INCENTIVE) {
+        const transactionReceipt = await getTransactionReceipt(this._config, {
+          chainId,
+          hash,
+        });
         const totalCost =
           transactionReceipt.gasUsed * transactionReceipt.effectiveGasPrice + // Normal gas cost
           (transactionReceipt.blobGasUsed ?? 0n) *
             (transactionReceipt.blobGasPrice ?? 0n); // Blob gas cost - account for potential undefined values
         return totalCost;
       }
-      const logs = transactionReceipt.logs;
 
-      if (logs.length === 0) {
+      // if logs are provided, use them to extract the scalar
+      if (logs && logs.length > 0) {
+        try {
+          // only check logs that match the criteria signature
+          const signatureMatchingLogs = logs
+            .filter((log) => log.topics && log.topics[0] === criteria.signature)
+            .map((log) => decodeAndReorderLogArgs(eventAbi, log));
+
+          if (signatureMatchingLogs.length > 0) {
+            for (const log of signatureMatchingLogs) {
+              if (isCriteriaFieldIndexTuple(criteria.fieldIndex)) {
+                return getScalarValueFromTuple(
+                  log.args as unknown[],
+                  criteria.fieldIndex,
+                );
+              }
+              const scalarValue = log.args
+                ? (log.args as string[])[criteria.fieldIndex]
+                : undefined;
+              if (scalarValue !== undefined) {
+                return BigInt(scalarValue);
+              }
+            }
+          }
+        } catch (e) {
+          throw new DecodedArgsError(
+            `An error occurred while extracting scalar from logs: ${(e as Error).message}`,
+          );
+        }
+      }
+
+      const transactionReceipt = await getTransactionReceipt(this._config, {
+        chainId,
+        hash,
+      });
+      const receiptLogs = transactionReceipt.logs;
+
+      if (receiptLogs.length === 0) {
         throw new NoMatchingLogsError(
           `No logs found for event signature ${criteria.signature}`,
         );
@@ -276,7 +317,7 @@ export class ERC20VariableCriteriaIncentiveV2 extends ERC20VariableIncentive<
         const eventAbi = knownSignatures[criteria.signature] as AbiEvent;
         const decodedEvents = parseEventLogs({
           abi: [eventAbi],
-          logs,
+          logs: receiptLogs,
         });
         if (decodedEvents == undefined || decodedEvents.length === 0) {
           throw new NoMatchingLogsError(