fix: decodeEventLog mixing order of parameters (#3688)

* fix: keep unnamed args ordered when indexed are mixed

* chore: changeset

* Update tricky-hairs-pretend.md

* Update decodeEventLog.test.ts

* Update decodeEventLog.ts

---------

Co-authored-by: jxom <7336481+jxom@users.noreply.github.com>

Author: jgalat

.changeset/tricky-hairs-pretend.md

@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Fixed ordering of decoded arguments in `decodeEventLog`.

src/utils/abi/decodeEventLog.test.ts

@@ -169,6 +169,49 @@ test('unnamed args: Transfer(address,address,uint256)', () => {
   })
 })
 
+test('unnamed args: mixed ordering of indexed args', () => {
+  const event = decodeEventLog({
+    abi: [
+      {
+        inputs: [
+          {
+            indexed: true,
+            type: 'address',
+          },
+          {
+            indexed: false,
+            type: 'uint256',
+          },
+          {
+            indexed: true,
+            type: 'address',
+          },
+        ],
+        name: 'Transfer',
+        type: 'event',
+      },
+    ],
+    data: '0x0000000000000000000000000000000000000000000000000000000000000001',
+    topics: [
+      '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+      '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+      '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+    ],
+  })
+  assertType<typeof event>({
+    eventName: 'Transfer',
+    args: ['0x', 1n, '0x'],
+  })
+  expect(event).toEqual({
+    args: [
+      '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+      1n,
+      '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+    ],
+    eventName: 'Transfer',
+  })
+})
+
 test('Foo(string)', () => {
   const event = decodeEventLog({
     abi: [

src/utils/abi/decodeEventLog.ts

@@ -131,19 +131,24 @@ export function decodeEventLog<
   const { name, inputs } = abiItem
   const isUnnamed = inputs?.some((x) => !('name' in x && x.name))
 
-  let args: any = isUnnamed ? [] : {}
+  const args: any = isUnnamed ? [] : {}
 
   // Decode topics (indexed args).
-  const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
+  const indexedInputs = inputs
+    .map((x, i) => [x, i] as const)
+    .filter(([x]) => 'indexed' in x && x.indexed)
   for (let i = 0; i < indexedInputs.length; i++) {
-    const param = indexedInputs[i]
+    const [param, argIndex] = indexedInputs[i]
     const topic = argTopics[i]
     if (!topic)
       throw new DecodeLogTopicsMismatch({
         abiItem,
         param: param as AbiParameter & { indexed: boolean },
       })
-    args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic })
+    args[isUnnamed ? argIndex : param.name || argIndex] = decodeTopic({
+      param,
+      value: topic,
+    })
   }
 
   // Decode data (non-indexed args).
@@ -153,12 +158,12 @@ export function decodeEventLog<
       try {
         const decodedData = decodeAbiParameters(nonIndexedInputs, data)
         if (decodedData) {
-          if (isUnnamed) args = [...args, ...decodedData]
-          else {
-            for (let i = 0; i < nonIndexedInputs.length; i++) {
+          if (isUnnamed)
+            for (let i = 0; i < inputs.length; i++)
+              args[i] = args[i] ?? decodedData.shift()
+          else
+            for (let i = 0; i < nonIndexedInputs.length; i++)
               args[nonIndexedInputs[i].name!] = decodedData[i]
-            }
-          }
         }
       } catch (err) {
         if (strict) {