@boostxyz/sdk 0.0.0-alpha.11 → 0.0.0-alpha.12

package/src/errors.ts

@@ -1,10 +1,13 @@
 import {
+  type AbiEvent,
+  type AbiFunction,
   type Hex,
   type Log,
   type WaitForTransactionReceiptReturnType,
   zeroHash,
 } from 'viem';
 import type { Criteria } from './Actions/EventAction';
+import type { EventLogs } from './Actions/EventAction';
 import type { BoostRegistry } from './BoostRegistry';
 import type { Incentive } from './Incentives/Incentive';
 
@@ -248,6 +251,44 @@ export class InvalidComponentInterfaceError extends Error {
   }
 }
 
+/**
+ * This error is thrown when a param is not transparently stored onchain
+ *
+ * @export
+ * @class UnparseableAbiParamError
+ * @typedef {UnparseableAbiParamError}
+ * @extends {Error}
+ */
+export class UnparseableAbiParamError extends Error {
+  /**
+   * the param index that is unparseable
+   *
+   * @type {number}
+   */
+  input_param_idx: number;
+  /**
+   * The given event that contains the unparseable param
+   *
+   * @type {AbiEvent}
+   */
+  event: AbiEvent;
+  /**
+   * Creates an instance of UnknownTransferPayloadSupplied.
+   *
+   * @constructor
+   * @param {number} input_param_idx
+   * @param {AbiEvent} event
+   */
+  constructor(input_param_idx: number, event: AbiEvent) {
+    super(
+      `Parameter is not transparently stored onchain. Parameter ${input_param_idx} in event ${event.name} cannot be used in an action`,
+      { cause: event },
+    );
+    this.event = event;
+    this.input_param_idx = input_param_idx;
+  }
+}
+
 /**
  * This error is thrown when attempting a Budget transfer and arguments aren't of the type `FungibleTransferPayload` or `ERC1155TransferPayload`
  *
@@ -380,6 +421,28 @@ export class TooManyEventActionStepsProvidedError extends Error {
   }
 }
 
+/**
+ * Function action validation context to help debug other validation errors
+ *
+ * @interface FunctionActionValidationMeta
+ * @typedef {FunctionActionValidationMeta}
+ */
+interface FunctionActionValidationMeta {
+  decodedArgs: readonly (string | bigint)[];
+  /**
+   * The value pulled off the log being validated against
+   *
+   * @type {*}
+   * biome-ignore lint/suspicious/noExplicitAny: this can be a few different types based on what the log emits
+   */
+  fieldValue: any;
+  /**
+   * The criteria being used to compare during validation
+   *
+   * @type {Criteria}
+   */
+  criteria: Criteria;
+}
 /**
  * Event action validation context to help debug other validation errors
  *
@@ -392,7 +455,7 @@ interface EventActionValidationMeta {
    *
    * @type {Log}
    */
-  log: Log;
+  log?: EventLogs[0];
   /**
    * The value pulled off the log being validated against
    *
@@ -413,17 +476,23 @@ interface EventActionValidationMeta {
  * Instantiated with relevent context data for more in depth debugging.
  *
  * @export
- * @class EventActionValidationError
- * @typedef {EventActionValidationError}
+ * @class FieldActionValidationError
+ * @typedef {FieldActionValidationError}
  * @extends {Error}
  */
-export class EventActionValidationError extends Error {
+export class FieldActionValidationError extends Error {
+  /**
+   * The function input arguments being validated against
+   *
+   * @type {decodedArgs}
+   */
+  decodedArgs?: readonly (string | bigint)[];
   /**
    * The viem log being validated against
    *
    * @type {Log}
    */
-  log: Log;
+  log?: EventLogs[0];
   /**
    * The value pulled off the log being validated against
    *
@@ -438,7 +507,7 @@ export class EventActionValidationError extends Error {
    */
   criteria: Criteria;
   /**
-   * Creates an instance of EventActionValidationError.
+   * Creates an instance of FieldActionValidationError.
    *
    * @constructor
    * @param {string} message
@@ -449,12 +518,48 @@ export class EventActionValidationError extends Error {
    */
   constructor(
     message: string,
-    { fieldValue, criteria, log }: EventActionValidationMeta,
+    {
+      fieldValue,
+      criteria,
+      ...args
+    }: EventActionValidationMeta | FunctionActionValidationMeta,
   ) {
     super(message);
     this.fieldValue = fieldValue;
     this.criteria = criteria;
-    this.log = log;
+
+    switch (true) {
+      case 'log' in args:
+        this.log = args.log;
+        break;
+      case 'decodedArgs' in args:
+        this.decodedArgs = args.decodedArgs;
+    }
+  }
+}
+
+/**
+ * Thrown when abi-decoded args on log is undefined
+ *
+ * @export
+ * @class FieldValueUndefinedError
+ * @typedef {FieldValueUndefinedError}
+ * @extends {FieldActionValidationError}
+ */
+export class DecodedArgsMalformedError extends FieldActionValidationError {
+  /**
+   * Creates an instance of DecodedArgsUndefinedError.
+   *
+   * @constructor
+   * @param {DecodedArgsMalformedError} metadata
+   */
+  constructor(
+    metadata: EventActionValidationMeta | FunctionActionValidationMeta,
+  ) {
+    super(
+      'Decoded Args are malformed; Check which params are indexed',
+      metadata,
+    );
   }
 }
 
@@ -464,16 +569,18 @@ export class EventActionValidationError extends Error {
  * @export
  * @class FieldValueUndefinedError
  * @typedef {FieldValueUndefinedError}
- * @extends {EventActionValidationError}
+ * @extends {FieldActionValidationError}
  */
-export class FieldValueUndefinedError extends EventActionValidationError {
+export class FieldValueUndefinedError extends FieldActionValidationError {
   /**
    * Creates an instance of FieldValueUndefinedError.
    *
    * @constructor
    * @param {EventActionValidationMeta} metadata
    */
-  constructor(metadata: EventActionValidationMeta) {
+  constructor(
+    metadata: EventActionValidationMeta | FunctionActionValidationMeta,
+  ) {
     super('Field value is undefined', metadata);
   }
 }
@@ -484,16 +591,18 @@ export class FieldValueUndefinedError extends EventActionValidationError {
  * @export
  * @class InvalidNumericalCriteriaError
  * @typedef {InvalidNumericalCriteriaError}
- * @extends {EventActionValidationError}
+ * @extends {FieldActionValidationError}
  */
-export class InvalidNumericalCriteriaError extends EventActionValidationError {
+export class InvalidNumericalCriteriaError extends FieldActionValidationError {
   /**
    * Creates an instance of InvalidNumericalCriteria.
    *
    * @constructor
    * @param {EventActionValidationMeta} metadata
    */
-  constructor(metadata: EventActionValidationMeta) {
+  constructor(
+    metadata: EventActionValidationMeta | FunctionActionValidationMeta,
+  ) {
     super(
       'Numerical comparisons cannot be used with non-numerical criteria',
       metadata,
@@ -501,22 +610,51 @@ export class InvalidNumericalCriteriaError extends EventActionValidationError {
   }
 }
 
+/**
+ * Thrown when decoding function data fails.
+ *
+ * @export
+ * @class FunctionDataDecodeError
+ * @typedef {FunctionDataDecodeError}
+ * @extends {Error}
+ */
+export class FunctionDataDecodeError extends Error {
+  public abi: AbiFunction[];
+  public originalError: Error;
+
+  /**
+   * Creates an instance of FunctionDataDecodeError.
+   *
+   * @constructor
+   * @param {AbiFunction[]} abi - The ABI of the function.
+   * @param {Error} originalError - The original error that was thrown.
+   */
+  constructor(abi: AbiFunction[], originalError: Error) {
+    super(`Failed to decode function data: ${originalError.message}`);
+    this.name = 'FunctionDataDecodeError';
+    this.abi = abi;
+    this.originalError = originalError;
+  }
+}
+
 /**
  * Thrown when an the log's field value is being compared a field type that isn't bytes or string during event action validation
  *
  * @export
  * @class FieldValueNotComparableError
  * @typedef {FieldValueNotComparableError}
- * @extends {EventActionValidationError}
+ * @extends {FieldActionValidationError}
  */
-export class FieldValueNotComparableError extends EventActionValidationError {
+export class FieldValueNotComparableError extends FieldActionValidationError {
   /**
    * Creates an instance of FieldValueNotComparableError.
    *
    * @constructor
    * @param {EventActionValidationMeta} metadata
    */
-  constructor(metadata: EventActionValidationMeta) {
+  constructor(
+    metadata: EventActionValidationMeta | FunctionActionValidationMeta,
+  ) {
     super('Filter can only be used with bytes or string field type', metadata);
   }
 }
@@ -527,16 +665,18 @@ export class FieldValueNotComparableError extends EventActionValidationError {
  * @export
  * @class UnrecognizedFilterTypeError
  * @typedef {UnrecognizedFilterTypeError}
- * @extends {EventActionValidationError}
+ * @extends {FieldActionValidationError}
  */
-export class UnrecognizedFilterTypeError extends EventActionValidationError {
+export class UnrecognizedFilterTypeError extends FieldActionValidationError {
   /**
    * Creates an instance of UnrecognizedFilterTypeError.
    *
    * @constructor
    * @param {EventActionValidationMeta} metadata
    */
-  constructor(metadata: EventActionValidationMeta) {
+  constructor(
+    metadata: EventActionValidationMeta | FunctionActionValidationMeta,
+  ) {
     super('Invalid FilterType provided', metadata);
   }
 }