feat: add optional expression logging to GRE (#728)

* feat: add optional expression logging to GRE

Closes: #702
Signed-off-by: Tomás Migone <[email protected]>

Author: tmigone

.gitignore

@@ -19,3 +19,5 @@ bin/
 # Coverage and other reports
 /reports
 coverage.json
+
+tx-*.log

cli/contracts.ts

@@ -1,4 +1,14 @@
-import { providers, Signer } from 'ethers'
+import {
+  Contract,
+  ContractFunction,
+  ContractReceipt,
+  ContractTransaction,
+  providers,
+  Signer,
+} from 'ethers'
+import { Provider } from '@ethersproject/providers'
+import lodash from 'lodash'
+import fs from 'fs'
 
 import { AddressBook } from './address-book'
 import { logger } from './logging'
@@ -45,12 +55,17 @@ export interface NetworkContracts {
 export const loadContracts = (
   addressBook: AddressBook,
   signerOrProvider?: Signer | providers.Provider,
+  enableTXLogging = false,
 ): NetworkContracts => {
   const contracts = {}
   for (const contractName of addressBook.listEntries()) {
     const contractEntry = addressBook.getEntry(contractName)
     try {
-      const contract = getContractAt(contractName, contractEntry.address)
+      let contract = getContractAt(contractName, contractEntry.address)
+      if (enableTXLogging) {
+        contract.connect = getWrappedConnect(contract, contractName)
+        contract = wrapCalls(contract, contractName)
+      }
       contracts[contractName] = contract
       if (signerOrProvider) {
         contracts[contractName] = contracts[contractName].connect(signerOrProvider)
@@ -61,3 +76,77 @@ export const loadContracts = (
   }
   return contracts as NetworkContracts
 }
+
+// Returns a contract connect function that wrapps contract calls with wrapCalls
+function getWrappedConnect(
+  contract: Contract,
+  contractName: string,
+): (signerOrProvider: string | Provider | Signer) => Contract {
+  const call = contract.connect.bind(contract)
+  const override = (signerOrProvider: string | Provider | Signer): Contract => {
+    const connectedContract = call(signerOrProvider)
+    connectedContract.connect = getWrappedConnect(connectedContract, contractName)
+    return wrapCalls(connectedContract, contractName)
+  }
+  return override
+}
+
+// Returns a contract with wrapped calls
+// The wrapper will run the tx, wait for confirmation and log the details
+function wrapCalls(contract: Contract, contractName: string): Contract {
+  const wrappedContract = lodash.cloneDeep(contract)
+
+  for (const fn of Object.keys(contract.functions)) {
+    const call: ContractFunction<ContractTransaction> = contract.functions[fn]
+    const override = async (...args: Array<any>): Promise<ContractTransaction> => {
+      // Make the call
+      const tx = await call(...args)
+      logContractCall(tx, contractName, fn, args)
+
+      // Wait for confirmation
+      const receipt = await contract.provider.waitForTransaction(tx.hash)
+      logContractReceipt(tx, receipt)
+      return tx
+    }
+
+    wrappedContract.functions[fn] = override
+    wrappedContract[fn] = override
+  }
+
+  return wrappedContract
+}
+
+function logContractCall(
+  tx: ContractTransaction,
+  contractName: string,
+  fn: string,
+  args: Array<any>,
+) {
+  const msg = []
+  msg.push(`> Sent transaction ${contractName}.${fn}`)
+  msg.push(`   sender: ${tx.from}`)
+  msg.push(`   contract: ${tx.to}`)
+  msg.push(`   params: [ ${args} ]`)
+  msg.push(`   txHash: ${tx.hash}`)
+
+  logToConsoleAndFile(msg)
+}
+
+function logContractReceipt(tx: ContractTransaction, receipt: ContractReceipt) {
+  const msg = []
+  msg.push(
+    receipt.status ? `✔ Transaction succeeded: ${tx.hash}` : `✖ Transaction failed: ${tx.hash}`,
+  )
+
+  logToConsoleAndFile(msg)
+}
+
+function logToConsoleAndFile(msg: string[]) {
+  const isoDate = new Date().toISOString()
+  const fileName = `tx-${isoDate.substring(0, 10)}.log`
+
+  msg.map((line) => {
+    console.log(line)
+    fs.appendFileSync(fileName, `[${isoDate}] ${line}\n`)
+  })
+}

gre/gre.ts

@@ -43,6 +43,9 @@ extendEnvironment((hre: HardhatRuntimeEnvironment) => {
     logDebug('*** Initializing Graph Runtime Environment (GRE) ***')
     logDebug(`Main network: ${hre.network.name}`)
 
+    const enableTxLogging = opts.enableTxLogging ?? false
+    logDebug(`Tx logging: ${enableTxLogging ? 'enabled' : 'disabled'}`)
+
     const { l1ChainId, l2ChainId, isHHL1 } = getChains(hre.network.config.chainId)
     const { l1Provider, l2Provider } = getProviders(hre, l1ChainId, l2ChainId, isHHL1)
     const addressBookPath = getAddressBookPath(hre, opts)
@@ -69,6 +72,7 @@ extendEnvironment((hre: HardhatRuntimeEnvironment) => {
       l1GraphConfigPath,
       addressBookPath,
       isHHL1,
+      enableTxLogging,
       l1GetWallets,
       l1GetWallet,
     )
@@ -79,6 +83,7 @@ extendEnvironment((hre: HardhatRuntimeEnvironment) => {
       l2GraphConfigPath,
       addressBookPath,
       isHHL1,
+      enableTxLogging,
       l2GetWallets,
       l2GetWallet,
     )
@@ -102,6 +107,7 @@ function buildGraphNetworkEnvironment(
   graphConfigPath: string | undefined,
   addressBookPath: string,
   isHHL1: boolean,
+  enableTxLogging: boolean,
   getWallets: () => Promise<Wallet[]>,
   getWallet: (address: string) => Promise<Wallet>,
 ): GraphNetworkEnvironment | null {
@@ -127,7 +133,7 @@ function buildGraphNetworkEnvironment(
     addressBook: lazyObject(() => getAddressBook(addressBookPath, chainId.toString())),
     graphConfig: lazyObject(() => readConfig(graphConfigPath, true)),
     contracts: lazyObject(() =>
-      loadContracts(getAddressBook(addressBookPath, chainId.toString()), provider),
+      loadContracts(getAddressBook(addressBookPath, chainId.toString()), provider, enableTxLogging),
     ),
     getDeployer: lazyFunction(() => () => getDeployer(provider)),
     getNamedAccounts: lazyFunction(() => () => getNamedAccounts(provider, graphConfigPath)),

gre/type-extensions.d.ts

@@ -10,6 +10,7 @@ export interface GraphRuntimeEnvironmentOptions {
   l1GraphConfig?: string
   l2GraphConfig?: string
   graphConfig?: string
+  enableTxLogging?: boolean
 }
 
 export type AccountNames =