Refactors decodeLogs and creates a new decodeLog function to reuse logic.

Author: jeremy-then

index.d.ts

@@ -22,6 +22,19 @@ interface BridgeEvent {
     arguments: {}
 }
 
+export interface Log {
+    data: string;
+    topics: string[];
+};
+
+export interface AbiElement {
+    type: string;
+    name: string;
+    inputs: {name: string, type: string}[];
+    outputs: {name: string, type: string}[];
+    signature: string;
+}
+
 export default class BridgeTransactionParser {
 
     /**
@@ -59,5 +72,21 @@ export default class BridgeTransactionParser {
      * @returns Object - A transaction object
      */
      decodeBridgeTransaction(web3Tx: Web3Transaction, bridgeTxReceipt: TransactionReceipt): Promise<Transaction>;
+
+     /**
+      * Decodes logs from a transaction receipt
+      * @param txReceipt 
+      * @return {BridgeEvent[]}
+      */
+     decodeLogs(txReceipt: TransactionReceipt): BridgeEvent[];
+
+     /**
+     * Decodes a log data using the given abiElement
+     * @param {Log} log
+     * @param {AbiElement} abiElement 
+     * @returns {BridgeEvent}
+     */
+     decodeLog(log: Log, abiElement: AbiElement): BridgeEvent;
+
 }
 

index.js

@@ -11,18 +11,21 @@ class BridgeTransactionParser {
             throw new Error(`web3Client is required`);
         }
         this.web3Client = web3Client;
+        this.bridge = Bridge.build(this.web3Client);
+        this.jsonInterfaceMap = this.bridge._jsonInterface.reduce((map, item) => {
+            map[item.signature] = item;
+            return map;
+        }, {});
     }
 
     getBridgeTransactionByTxHash = async (transactionHash) => {
         utils.verifyHashOrBlockNumber(transactionHash);
 
         let transaction;
         const txReceipt = await this.web3Client.eth.getTransactionReceipt(transactionHash);
-        
         if (txReceipt?.to === Bridge.address) {
-            const bridge = Bridge.build(this.web3Client);
             const tx = await this.web3Client.eth.getTransaction(txReceipt.transactionHash);
-            transaction = await this.createBridgeTx(bridge, tx, txReceipt);
+            transaction = await this.createBridgeTx(tx, txReceipt);
         }
 
         return transaction;
@@ -76,8 +79,7 @@ class BridgeTransactionParser {
             throw new Error(`Given bridgeTxReceipt is not a bridge transaction`);
         }
 
-        const bridge = Bridge.build(this.web3Client);
-        return this.createBridgeTx(bridge, bridgeTx, bridgeTxReceipt);
+        return this.createBridgeTx(bridgeTx, bridgeTxReceipt);
     }
 
     decodeBridgeMethodParameters = (methodName, data) => {
@@ -97,10 +99,10 @@ class BridgeTransactionParser {
         return args;
     }
 
-    createBridgeTx = async (bridge, tx, txReceipt) => {
+    createBridgeTx = async (tx, txReceipt) => {
         const txData = tx.input;
-        const method = bridge._jsonInterface.find(i => i.signature === txData.substr(0, 10));
-        const events = this.decodeLogs(txReceipt, bridge);
+        const method =  this.jsonInterfaceMap[txData.substring(0, 10)];
+        const events = this.decodeLogs(txReceipt);
         const block = await this.web3Client.eth.getBlock(txReceipt.blockNumber);
 
         let bridgeMethod = '';
@@ -118,32 +120,36 @@ class BridgeTransactionParser {
         );
     };
 
-    decodeLogs = (tx, bridge) => {
+    decodeLogs = (txReceipt) => {
         const events = [];
-        for (let txLog of tx.logs) {
-            const bridgeEvent = bridge._jsonInterface.find(i => i.signature === txLog.topics[0]);
-            
-            if (bridgeEvent) {
-                const args = {};
-                const dataDecoded = this.web3Client.eth.abi.decodeParameters(bridgeEvent.inputs.filter(i => !i.indexed), txLog.data);
-                let topicIndex = 1;
-                for (let input of bridgeEvent.inputs) {
-                    let value;
-                    if (input.indexed) {
-                        value = this.web3Client.eth.abi.decodeParameter(input.type, txLog.topics[topicIndex]);
-                        topicIndex++;
-                    } else {
-                        value = dataDecoded[input.name];
-                    }
-                    args[input.name] = value;
-                }
-                events.push(new BridgeEvent(bridgeEvent.name, bridgeEvent.signature, args));
+        for (let log of txReceipt.logs) {
+            const abiElement = this.jsonInterfaceMap[log.topics[0]];
+            if(!abiElement) {
+                continue;
             }
+            const event = this.decodeLog(log, abiElement);
+            events.push(event);
         }
-    
         return events;
     }
 
+    decodeLog = (log, abiElement) => {
+        const args = {};
+        const dataDecoded = this.web3Client.eth.abi.decodeParameters(abiElement.inputs.filter(i => !i.indexed), log.data);
+        let topicIndex = 1;
+        for (let input of abiElement.inputs) {
+            let value;
+            if (input.indexed) {
+                value = this.web3Client.eth.abi.decodeParameter(input.type, log.topics[topicIndex]);
+                topicIndex++;
+            } else {
+                value = dataDecoded[input.name];
+            }
+            args[input.name] = value;
+        }
+        return new BridgeEvent(abiElement.name, abiElement.signature, args);
+    }
+
 }
 
 module.exports = BridgeTransactionParser;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsksmart/bridge-transaction-parser",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "A tool to find interactions with the Bridge on Rootstock",
   "main": "index.js",
   "scripts": {

package.json

@@ -1,5 +1,5 @@
 const BridgeTransactionParser = require('../../index');
-const Bridge = require('@rsksmart/rsk-precompiled-abis-lovell700').bridge;
+const Bridge = require('@rsksmart/rsk-precompiled-abis').bridge;
 const EventEmitter = require('node:events');
 const { MONITOR_EVENTS, defaultParamsValues } = require('./live-monitor-utils');
 const Web3 = require('web3');