Properly decode tuple from multicall (#84)

packages/discovery/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @l2beat/discovery
 
+## 0.19.2
+
+### Patch Changes
+
+- Properly decode tuples from multicall
+
 ## 0.19.1
 
 ### Patch Changes

packages/discovery/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@l2beat/discovery",
   "description": "L2Beat discovery - engine & tooling utilized for keeping an eye on L2s",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {

packages/discovery/src/discovery/handlers/system/SimpleMethodHandler.test.ts

@@ -135,5 +135,33 @@ describe(SimpleMethodHandler.name, () => {
         error: 'Multicall failed',
       })
     })
+
+    it('can correctly decode a tuple', async () => {
+      const response =
+        '0x0000000000000000000000000000000000000000000000000000000001312d00000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000ffffffffffffffffffffffffffffffff'
+      const abi =
+        'function resourceConfig() view returns (tuple(uint32 maxResourceLimit, uint8 elasticityMultiplier, uint8 baseFeeMaxChangeDenominator, uint32 minimumBaseFee, uint32 systemTxMaxGas, uint128 maximumBaseFee))'
+
+      const handler = new SimpleMethodHandler(abi, DiscoveryLogger.SILENT)
+
+      const decoded = handler.decode([
+        {
+          success: true,
+          data: Bytes.fromHex(response),
+        },
+      ])
+
+      expect(decoded).toEqual({
+        field: 'resourceConfig',
+        value: [
+          20000000,
+          10,
+          8,
+          1000000000,
+          1000000,
+          '340282366920938463463374607431768211455',
+        ],
+      })
+    })
   })
 })

packages/discovery/src/discovery/handlers/system/SimpleMethodHandler.ts

@@ -10,8 +10,7 @@ import {
   MulticallResponse,
 } from '../../provider/multicall/types'
 import { HandlerResult, MulticallableHandler } from '../Handler'
-import { callMethod } from '../utils/callMethod'
-import { toContractValue } from '../utils/toContractValue'
+import { callMethod, decodeMethodResult } from '../utils/callMethod'
 import { toFunctionFragment } from '../utils/toFunctionFragment'
 
 export class SimpleMethodHandler implements MulticallableHandler {
@@ -71,17 +70,11 @@ export class SimpleMethodHandler implements MulticallableHandler {
       'Decoding from multicall ',
       this.fragment.name + '()',
     ])
-    const output = this.fragment.outputs?.[0]
-    const resultType = output?.type
-    assert(resultType, 'Expected output type')
-    const decoded = utils.defaultAbiCoder.decode(
-      [resultType],
-      response.data.toString(),
-    )
-    const value = decoded[0] as string
+    const abi = new utils.Interface([this.fragment])
+
     return {
       field: this.field,
-      value: toContractValue(value),
+      value: decodeMethodResult(abi, this.fragment, response.data),
     }
   }
 }

packages/discovery/src/discovery/handlers/utils/callMethod.ts

@@ -18,17 +18,28 @@ export async function callMethod(
   blockNumber: number,
 ) {
   const abi = new utils.Interface([fragment])
+
   try {
     const callData = Bytes.fromHex(abi.encodeFunctionData(fragment, parameters))
     const result = await provider.call(address, callData, blockNumber)
-    const decoded = abi.decodeFunctionResult(fragment, result.toString())
-    const mapped = decoded.map(toContractValue)
+
     return {
-      value: mapped.length === 1 ? mapped[0] : mapped,
+      value: decodeMethodResult(abi, fragment, result),
     }
   } catch (e) {
     return {
       error: isRevert(e) ? EXEC_REVERT_MSG : getErrorMessage(e),
     }
   }
 }
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function decodeMethodResult(
+  abi: utils.Interface,
+  fragment: utils.FunctionFragment,
+  result: Bytes,
+) {
+  const decoded = abi.decodeFunctionResult(fragment, result.toString())
+  const mapped = decoded.map(toContractValue)
+  return mapped.length === 1 ? mapped[0] : mapped
+}