@boostxyz/sdk 5.3.0 → 5.5.0

package/src/Actions/EventAction.ts

@@ -6,8 +6,8 @@ import {
   writeEventActionExecute,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/actions/EventAction.sol/EventAction.json';
+import { abi } from '@boostxyz/signatures/events';
 import { getTransaction, getTransactionReceipt } from '@wagmi/core';
-import type { AbiEventParameter } from 'abitype';
 import { match } from 'ts-pattern';
 import {
   type AbiEvent,
@@ -26,7 +26,9 @@ import {
   fromHex,
   isAddress,
   isAddressEqual,
+  pad,
   toEventSelector,
+  trim,
   zeroAddress,
   zeroHash,
 } from 'viem';
@@ -157,7 +159,7 @@ export interface ActionClaimant {
    *
    * @type {SignatureType}
    */
-  signatureType: SignatureType;
+  signatureType?: SignatureType;
   /**
    * The 4 byte signature of the event or function
    *
@@ -202,7 +204,7 @@ export interface ActionStep {
    *
    * @type {SignatureType}
    */
-  signatureType: SignatureType;
+  signatureType?: SignatureType;
   /**
    * The type of action being performed.
    *
@@ -585,9 +587,15 @@ export class EventAction extends DeployableTarget<
       ) {
         return undefined;
       }
-      const decodedLogs = receipt.logs
-        .filter((log) => log.topics[0] === toEventSelector(event))
-        .map((log) => decodeAndReorderLogArgs(event, log));
+
+      let decodedLogs: EventLogs;
+      if (signature === TRANSFER_SIGNATURE) {
+        ({ decodedLogs } = await this.decodeTransferLogs(receipt));
+      } else {
+        decodedLogs = receipt.logs
+          .filter((log) => log.topics[0] === toEventSelector(event))
+          .map((log) => decodeAndReorderLogArgs(event, log));
+      }
 
       for (let log of decodedLogs) {
         if (!isAddressEqual(log.address, claimant.targetContract)) continue;
@@ -728,7 +736,8 @@ export class EventAction extends DeployableTarget<
 
       // Special handling for Transfer events
       if (actionStep.signature === TRANSFER_SIGNATURE) {
-        return this.decodeTransferLogs(receipt, actionStep);
+        const { decodedLogs, event } = await this.decodeTransferLogs(receipt);
+        return this.isActionEventValid(actionStep, decodedLogs, event);
       }
 
       const decodedLogs = receipt.logs
@@ -801,7 +810,7 @@ export class EventAction extends DeployableTarget<
   }
 
   /**
-   * Decodes transfer logs specifically for ERC721 and ERC20 Transfer events.
+   * Decodes logs specifically for ERC721 and ERC20 Transfer events.
    *
    * This special handling is required because both ERC20 and ERC721 Transfer events:
    * 1. Share the same event signature (0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef)
@@ -813,79 +822,51 @@ export class EventAction extends DeployableTarget<
    * try decoding both ways to determine which type of Transfer event we're dealing with.
    *
    * @param {GetTransactionReceiptReturnType} receipt - The transaction receipt containing the logs
-   * @param {ActionStep} actionStep - The action step being validated
-   * @returns {Promise<boolean>} - Returns true if the transfer logs are valid for either ERC20 or ERC721
+   * @returns {Promise<{ decodedLogs: EventLogs; event: AbiEvent }>} - Returns the decoded logs and the transfer event ABI used for decoding
    * @throws {DecodedArgsError} - Throws if neither ERC20 nor ERC721 decoding succeeds
    */
   private async decodeTransferLogs(
     receipt: GetTransactionReceiptReturnType,
-    actionStep: ActionStep,
-  ) {
+  ): Promise<{ decodedLogs: EventLogs; event: AbiEvent }> {
     const filteredLogs = receipt.logs.filter(
       (log) => log.topics[0] === TRANSFER_SIGNATURE,
     );
+    const event = structuredClone(
+      abi['Transfer(address indexed,address indexed,uint256 indexed)'],
+    ) as AbiEvent;
 
     // ERC721
     try {
       const decodedLogs = filteredLogs.map((log) => {
         const { eventName, args } = decodeEventLog({
-          abi: [
-            {
-              name: 'Transfer',
-              type: 'event',
-              inputs: [
-                { type: 'address', indexed: true },
-                { type: 'address', indexed: true },
-                { type: 'uint256', indexed: true },
-              ],
-            },
-          ],
+          abi: [event],
           data: log.data,
           topics: log.topics,
         });
         return { ...log, eventName, args };
       });
 
-      return this.isActionEventValid(actionStep, decodedLogs, {
-        name: 'Transfer',
-        type: 'event',
-        inputs: [
-          { type: 'address', indexed: true },
-          { type: 'address', indexed: true },
-          { type: 'uint256', indexed: true },
-        ],
-      });
+      return {
+        decodedLogs,
+        event,
+      };
     } catch {
       // ERC20
       try {
+        event.inputs[2]!.indexed = false;
         const decodedLogs = filteredLogs.map((log) => {
           const { eventName, args } = decodeEventLog({
-            abi: [
-              {
-                name: 'Transfer',
-                type: 'event',
-                inputs: [
-                  { type: 'address', indexed: true },
-                  { type: 'address', indexed: true },
-                  { type: 'uint256' },
-                ],
-              },
-            ],
+            abi: [event],
             data: log.data,
             topics: log.topics,
           });
           return { ...log, eventName, args };
         });
 
-        return this.isActionEventValid(actionStep, decodedLogs, {
-          name: 'Transfer',
-          type: 'event',
-          inputs: [
-            { type: 'address', indexed: true },
-            { type: 'address', indexed: true },
-            { type: 'uint256' },
-          ],
-        });
+        return {
+          decodedLogs,
+          event,
+        };
       } catch {
         throw new DecodedArgsError('Failed to decode transfer logs');
       }
@@ -1398,6 +1379,72 @@ function _isEventActionPayloadSimple(
   return Array.isArray((opts as EventActionPayloadSimple).actionSteps);
 }
 
+/**
+ * Determines whether a signature is an event or function signature based on its format.
+ * - 32-byte signatures (0x + 64 chars) that don't start with 28 zeros are event signatures
+ * - 4-byte signatures (0x + 8 chars) or 32-byte signatures with 28 leading zeros are function signatures
+ *
+ * @param {Hex} signature - The signature to check
+ * @returns {SignatureType} The detected signature type
+ */
+export function detectSignatureType(signature: Hex): SignatureType {
+  const hexWithoutPrefix = signature.slice(2);
+
+  // 4-byte function selectors (8 hex chars)
+  if (hexWithoutPrefix.length === 8) {
+    return SignatureType.FUNC;
+  }
+
+  // 32-byte selectors (64 hex chars)
+  if (hexWithoutPrefix.length === 64) {
+    // Check if it starts with 28 bytes (56 chars) of zeros
+    const leadingPart = hexWithoutPrefix.slice(0, 56);
+    if (leadingPart === '0'.repeat(56)) {
+      return SignatureType.FUNC;
+    }
+    return SignatureType.EVENT;
+  }
+
+  throw new Error('Invalid signature format');
+}
+
+/**
+ * Normalizes a hex value to ensure proper byte padding.
+ * This prevents viem's automatic padding which can change the value.
+ * For example:
+ * - "0x1" -> "0x01"
+ * - "0xabc" -> "0x0abc"
+ * - "0xabcd" -> "0xabcd"
+ *
+ * @param {Hex} value - The hex value to normalize
+ * @returns {Hex} The normalized hex string
+ */
+function normalizeUintValue(value: Hex): Hex {
+  return trim(pad(value));
+}
+
+/**
+ * Helper function to prepare an action step for encoding
+ *
+ * @param {ActionStep} step - The action step to prepare
+ * @returns {ActionStep} The prepared action step
+ */
+function prepareActionStep(step: ActionStep) {
+  return {
+    ..._toRawActionStep(step),
+    signatureType: step.signatureType ?? detectSignatureType(step.signature),
+    signature: pad(step.signature),
+    actionType: step.actionType || 0,
+    actionParameter:
+      step.actionParameter.fieldType === PrimitiveType.UINT
+        ? {
+            ...step.actionParameter,
+            filterData: normalizeUintValue(step.actionParameter.filterData),
+          }
+        : step.actionParameter,
+  };
+}
+
 /**
  * Function to properly encode an event action payload.
  *
@@ -1523,23 +1570,17 @@ export function prepareEventActionPayload({
     ],
     [
       {
-        actionClaimant: _toRawActionStep(actionClaimant),
-        actionStepOne: {
-          ..._toRawActionStep(actionStepOne),
-          actionType: actionStepOne.actionType || 0,
-        },
-        actionStepTwo: {
-          ..._toRawActionStep(actionStepTwo),
-          actionType: actionStepTwo.actionType || 0,
-        },
-        actionStepThree: {
-          ..._toRawActionStep(actionStepThree),
-          actionType: actionStepThree.actionType || 0,
-        },
-        actionStepFour: {
-          ..._toRawActionStep(actionStepFour),
-          actionType: actionStepFour.actionType || 0,
+        actionClaimant: {
+          ..._toRawActionStep(actionClaimant),
+          signatureType:
+            actionClaimant.signatureType ??
+            detectSignatureType(actionClaimant.signature),
+          signature: pad(actionClaimant.signature),
         },
+        actionStepOne: prepareActionStep(actionStepOne),
+        actionStepTwo: prepareActionStep(actionStepTwo),
+        actionStepThree: prepareActionStep(actionStepThree),
+        actionStepFour: prepareActionStep(actionStepFour),
       },
     ],
   );
@@ -1632,6 +1673,9 @@ export function packFieldIndexes(indexes: number[]): number {
     }
     packed |= (index & MAX_FIELD_INDEX) << (i * 6); // Each index occupies 6 bits
   });
+  if (indexes.length < 5) {
+    packed |= MAX_FIELD_INDEX << (indexes.length * 6); // Terminator
+  }
 
   return packed;
 }
@@ -1672,7 +1716,10 @@ export function decodeAndReorderLogArgs(event: AbiEvent, log: Log) {
     : Object.values(decodedLog.args);
 
   if (!event.inputs.some((input) => input.indexed)) {
-    return decodedLog as EventLog;
+    return {
+      ...log,
+      ...decodedLog,
+    } as EventLog;
   }
 
   const indexedIndices: number[] = [];
@@ -1685,7 +1732,7 @@ export function decodeAndReorderLogArgs(event: AbiEvent, log: Log) {
     }
   }
 
-  const reorderedArgs = new Array(event.inputs.length);
+  const reorderedArgs = Array.from({ length: event.inputs.length });
   let currentIndex = 0;
 
   // Place the indexed arguments in their original positions