@boostxyz/sdk 8.0.1 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boostxyz/sdk",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "license": "GPL-3.0-or-later",
   "type": "module",
   "files": [

package/src/Actions/EventAction.test.ts

@@ -1514,6 +1514,48 @@ describe('decodeAndReorderLogArgs', () => {
     expect(result.args[2]).toBe(1n);
     expect(result.args[3]).toBe(5284n);
   });
+
+  test('handles TransferReference with interleaved indexed params', () => {
+    // TransferReference(address sender, address indexed recipient, uint256 amount, address token, string indexed referenceId, bool indexed success)
+    const event: AbiEvent = {
+      type: 'event',
+      name: 'TransferReference',
+      inputs: [
+        { type: 'address', indexed: false, name: 'sender' },
+        { type: 'address', indexed: true, name: 'recipient' },
+        { type: 'uint256', indexed: false, name: 'amount' },
+        { type: 'address', indexed: false, name: 'token' },
+        { type: 'bytes32', indexed: true, name: 'referenceId' },
+        { type: 'bool', indexed: true, name: 'success' },
+      ],
+    };
+
+    const log: Log = {
+      address: "0xee9f1a50138ba636cd50926b02b644f96f8748c7",
+      blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      blockNumber: 1n,
+      data: "0x0000000000000000000000003ebc5ada4f198a831472ef19e4001c17320ca9950000000000000000000000000000000000000000000000001bc16d674ec800000000000000000000000000002cfc85d8e48f8eab294be644d9e25c3030863003",
+      logIndex: 0,
+      removed: false,
+      topics: [
+        "0xa2b940fe4e5490b0393adc0106a79fc2d4d9fb9623ae3fb2ebf0b8fe30d354d2",
+        "0x000000000000000000000000a108fb7a4c41658d4aa7a62f01afdd072c30d22e",
+        "0xde0cdb1d3929682455dae865d1605e27ba4245172afbd52df50ea7b37c81261f",
+        "0x0000000000000000000000000000000000000000000000000000000000000001"
+      ],
+      transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      transactionIndex: 0,
+    };
+
+    const result = decodeAndReorderLogArgs(event, log);
+
+    expect(result.args[0]).toBe("0x3eBC5aDA4F198a831472eF19e4001c17320ca995");
+    expect(result.args[1]).toBe("0xA108FB7A4C41658D4AA7a62F01aFDd072c30D22E");
+    expect(result.args[2]).toBe(2000000000000000000n);
+    expect(result.args[3]).toBe("0x2cFc85d8E48F8EAB294be644d9E25C3030863003");
+    expect(result.args[4]).toBe("0xde0cdb1d3929682455dae865d1605e27ba4245172afbd52df50ea7b37c81261f");
+    expect(result.args[5]).toBe(true);
+  });
 }); 
 
 describe("criteria field index tuple support", () => {

package/src/Actions/EventAction.ts

@@ -20,6 +20,7 @@ import {
   type Hex,
   type Log,
   type Transaction,
+  decodeAbiParameters,
   decodeEventLog,
   decodeFunctionData,
   encodeAbiParameters,
@@ -1926,8 +1927,7 @@ export function unpackFieldIndexes(packed: number): number[] {
 }
 
 /**
- * Decodes an event log and reorders the arguments to match the original ABI order.
- * This is necessary because viem's decodeEventLog reorders indexed parameters to the front.
+ * Decodes an event log and returns arguments in ABI declaration order.
  *
  * @param event - The event ABI definition
  * @param log - The log to decode
@@ -1945,50 +1945,51 @@ export function decodeAndReorderLogArgs(event: AbiEvent, log: Log) {
     event.inputs[2]!.indexed = true;
   }
 
-  const decodedLog = decodeEventLog({
-    abi: [event],
-    data: log.data,
-    topics: log.topics,
-  });
-
-  const argsArray = Array.isArray(decodedLog.args)
-    ? decodedLog.args
-    : Object.values(decodedLog.args);
-
-  if (!event.inputs.some((input) => input.indexed)) {
-    return {
-      ...log,
-      ...decodedLog,
-    } as EventLog;
-  }
+  const indexedInputs: AbiParameter[] = [];
+  const nonIndexedInputs: AbiParameter[] = [];
 
-  const indexedIndices: number[] = [];
-  const nonIndexedIndices: number[] = [];
   for (let i = 0; i < event.inputs.length; i++) {
-    if (event.inputs[i]!.indexed) {
-      indexedIndices.push(i);
+    const input = event.inputs[i]!;
+    if (input.indexed) {
+      indexedInputs.push(input);
     } else {
-      nonIndexedIndices.push(i);
+      nonIndexedInputs.push(input);
     }
   }
 
-  const reorderedArgs = Array.from({ length: event.inputs.length });
-  let currentIndex = 0;
-
-  // Place the indexed arguments in their original positions
-  for (let i = 0; i < indexedIndices.length; i++) {
-    reorderedArgs[indexedIndices[i]!] = argsArray[currentIndex++];
+  const decodedIndexed: unknown[] = [];
+  for (let i = 0; i < indexedInputs.length; i++) {
+    const topic = log.topics[i + 1];
+    if (!topic) {
+      throw new DecodedArgsError(
+        `Missing topic at index ${i + 1} for indexed parameter "${indexedInputs[i]!.name ?? i}"`,
+      );
+    }
+    const [decoded] = decodeAbiParameters([indexedInputs[i]!], topic);
+    decodedIndexed.push(decoded);
   }
 
-  // Place the non-indexed arguments in their original positions
-  for (let i = 0; i < nonIndexedIndices.length; i++) {
-    reorderedArgs[nonIndexedIndices[i]!] = argsArray[currentIndex++];
+  const decodedNonIndexed =
+    nonIndexedInputs.length > 0 && log.data && log.data !== '0x'
+      ? decodeAbiParameters(nonIndexedInputs, log.data)
+      : [];
+
+  const args: unknown[] = new Array(event.inputs.length);
+  let indexedIdx = 0;
+  let nonIndexedIdx = 0;
+
+  for (let i = 0; i < event.inputs.length; i++) {
+    if (event.inputs[i]!.indexed) {
+      args[i] = decodedIndexed[indexedIdx++];
+    } else {
+      args[i] = decodedNonIndexed[nonIndexedIdx++];
+    }
   }
 
   return {
     ...log,
-    eventName: decodedLog.eventName,
-    args: reorderedArgs,
+    eventName: event.name,
+    args,
   } as EventLog;
 }