Pull evm_address for contract logs (#650)

* Pull evm_address for contract logs

Signed-off-by: Nana Essilfie-Conduah <[email protected]>

* FixgetLogs return, fix tests, add test case for evm address

Signed-off-by: Maksim Dimitrov <[email protected]>

* Remove console.log

Signed-off-by: Maksim Dimitrov <[email protected]>

* Cache contract request. Add test

Signed-off-by: Maksim Dimitrov <[email protected]>

* Add missing mock

Signed-off-by: Maksim Dimitrov <[email protected]>

* Remove console.log, add expect for cache

Signed-off-by: Maksim Dimitrov <[email protected]>

* Fix spacing

Signed-off-by: Maksim Dimitrov <[email protected]>

Signed-off-by: Nana Essilfie-Conduah <[email protected]>
Signed-off-by: Maksim Dimitrov <[email protected]>
Co-authored-by: Maksim Dimitrov <[email protected]>

Author: Nana-EC

packages/relay/src/lib/eth.ts

@@ -467,7 +467,7 @@ export class EthImpl implements Eth {
 
     // To save a request to the mirror node for `latest` and `pending` blocks, we directly return null from `getHistoricalBlockResponse`
     // But if a block number or `earliest` tag is passed and the mirror node returns `null`, we should throw an error.
-    if(!EthImpl.blockTagIsLatestOrPending(blockNumberOrTag) && blockResponse == null) {
+    if (!EthImpl.blockTagIsLatestOrPending(blockNumberOrTag) && blockResponse == null) {
       throw predefined.RESOURCE_NOT_FOUND(`block '${blockNumberOrTag}'.`);
     }
 
@@ -478,7 +478,7 @@ export class EthImpl implements Eth {
       // retrieve the contract result details
       await this.mirrorNodeClient.getContractResultsDetails(address, contractResult.results[0].timestamp)
         .then(contractResultDetails => {
-          if(contractResultDetails?.state_changes != null) {
+          if (contractResultDetails?.state_changes != null) {
             // filter the state changes to match slot and return value
             const stateChange = contractResultDetails.state_changes.find(stateChange => stateChange.slot === slot);
             result = stateChange.value_written;
@@ -626,7 +626,7 @@ export class EthImpl implements Eth {
       const bytecode = await this.sdkClient.getContractByteCode(0, 0, address, EthImpl.ethGetCode, requestId);
       return EthImpl.prepend0x(Buffer.from(bytecode).toString('hex'));
     } catch (e: any) {
-      if(e instanceof SDKClientError) {
+      if (e instanceof SDKClientError) {
         // handle INVALID_CONTRACT_ID
         if (e.isInvalidContractId()) {
           this.logger.debug(`${requestIdPrefix} Unable to find code for contract ${address} in block "${blockNumber}", returning 0x0, err code: ${e.statusCode}`);
@@ -718,7 +718,7 @@ export class EthImpl implements Eth {
       .getContractResults({ blockHash: blockHash, transactionIndex: Number(transactionIndex) }, undefined, requestId)
       .then((contractResults) => this.getTransactionFromContractResults(contractResults, requestId))
       .catch((e: any) => {
-        if(e instanceof JsonRpcError) {
+        if (e instanceof JsonRpcError) {
           throw e;
         }
 
@@ -749,7 +749,7 @@ export class EthImpl implements Eth {
       .getContractResults({ blockNumber: blockNum, transactionIndex: Number(transactionIndex) }, undefined, requestId)
       .then((contractResults) => this.getTransactionFromContractResults(contractResults, requestId))
       .catch((e: any) => {
-        if(e instanceof JsonRpcError) {
+        if (e instanceof JsonRpcError) {
           throw e;
         }
 
@@ -927,10 +927,10 @@ export class EthImpl implements Eth {
     }
 
     let fromAddress;
-    if(contractResult.from) {
+    if (contractResult.from) {
       fromAddress = contractResult.from.substring(0, 42);
       const accountResult = await this.mirrorNodeClient.getAccount(fromAddress, requestId);
-      if(accountResult && accountResult.evm_address && accountResult.evm_address.length > 0) {
+      if (accountResult && accountResult.evm_address && accountResult.evm_address.length > 0) {
         fromAddress = accountResult.evm_address.substring(0,42);
       }
     }
@@ -1107,7 +1107,7 @@ export class EthImpl implements Eth {
   private async getBlock(blockHashOrNumber: string, showDetails: boolean, requestId?: string ): Promise<Block | null> {
     const blockResponse = await this.getHistoricalBlockResponse(blockHashOrNumber, true);
 
-    if(blockResponse == null) return null;
+    if (blockResponse == null) return null;
 
     const timestampRange = blockResponse.timestamp;
     const timestampRangeParams = [`gte:${timestampRange.from}`, `lte:${timestampRange.to}`];
@@ -1218,7 +1218,7 @@ export class EthImpl implements Eth {
     return this.mirrorNodeClient.getContractResultsByAddressAndTimestamp(to, timestamp, requestId)
       .then(contractResultDetails => {
         // 404 is allowed return code so it's possible for contractResultDetails to be null
-        if(contractResultDetails == null) {
+        if (contractResultDetails == null) {
           return null;
         } else {
           const rSig = contractResultDetails.r === null ? null : contractResultDetails.r.substring(0, 66);
@@ -1280,7 +1280,7 @@ export class EthImpl implements Eth {
       let fromBlockNum = 0;
       let toBlockNum;
 
-      if(!fromBlock && !toBlock) {
+      if (!fromBlock && !toBlock) {
         const blockResponse = await this.getHistoricalBlockResponse("latest", true, requestId);
         fromBlockNum = parseInt(blockResponse.number);
         toBlockNum = parseInt(blockResponse.number);
@@ -1289,23 +1289,23 @@ export class EthImpl implements Eth {
           params.timestamp = [];
 
           const fromBlockResponse = await this.getHistoricalBlockResponse(fromBlock || "latest", true, requestId);
-          if(fromBlockResponse != null) {
+          if (fromBlockResponse != null) {
             params.timestamp.push(`gte:${fromBlockResponse.timestamp.from}`);
             fromBlockNum = parseInt(fromBlockResponse.number);
           } else {
             return [];
           }
 
           const toBlockResponse = await this.getHistoricalBlockResponse(toBlock || "latest", true, requestId);
-          if(toBlockResponse != null) {
+          if (toBlockResponse != null) {
             params.timestamp.push(`lte:${toBlockResponse.timestamp.to}`);
             toBlockNum = parseInt(toBlockResponse.number);
           }
       }
 
       if (fromBlockNum > toBlockNum) {
         return [];
-      } else if((toBlockNum - fromBlockNum) > blockRangeLimit) {
+      } else if ((toBlockNum - fromBlockNum) > blockRangeLimit) {
         throw predefined.RANGE_TOO_LARGE(blockRangeLimit);
       }
     }
@@ -1328,24 +1328,44 @@ export class EthImpl implements Eth {
       return [];
     }
 
-    return result.logs.map(log => {
-      return new Log({
-        address: log.address,
-        blockHash: EthImpl.toHash32(log.block_hash),
-        blockNumber: EthImpl.numberTo0x(log.block_number),
-        data: log.data,
-        logIndex: EthImpl.numberTo0x(log.index),
-        removed: false,
-        topics: log.topics,
-        transactionHash: EthImpl.toHash32(log.transaction_hash),
-        transactionIndex: EthImpl.numberTo0x(log.transaction_index)
-      });
-    });
+    const logs: Log[] = [];
+    for(const log of result.logs) {
+      logs.push(
+        new Log({
+          address: await this.getLogEvmAddress(log.address, requestId) || log.address,
+          blockHash: EthImpl.toHash32(log.block_hash),
+          blockNumber: EthImpl.numberTo0x(log.block_number),
+          data: log.data,
+          logIndex: EthImpl.numberTo0x(log.index),
+          removed: false,
+          topics: log.topics,
+          transactionHash: EthImpl.toHash32(log.transaction_hash),
+          transactionIndex: EthImpl.numberTo0x(log.transaction_index)
+        })
+      );
+    }
+
+    return logs;
   }
 
   async maxPriorityFeePerGas(requestId?: string): Promise<string> {
     const requestIdPrefix = formatRequestIdMessage(requestId);
     this.logger.trace(`${requestIdPrefix} maxPriorityFeePerGas()`);
     return EthImpl.zeroHex;
   }
+
+  private async getLogEvmAddress(address: string, requestId: string | undefined) {
+    const cachedLabel = `getLogEvmAddress.${address}`;
+    let contractAddress = cache.get(cachedLabel);
+
+    // If contractAddress === undefined it means there's no cache record
+    // and a mirror node request should be executed.
+    if (contractAddress === undefined) {
+      const contract = await this.mirrorNodeClient.getContract(address, requestId);
+      contractAddress = contract.evm_address;
+      cache.set(cachedLabel, contractAddress, constants.CACHE_TTL.ONE_HOUR);
+    }
+
+    return contractAddress;
+  }
 }

packages/relay/tests/helpers.ts

@@ -165,7 +165,6 @@ const mockData = {
 
 export { expectUnsupportedMethod, expectedError, signTransaction, mockData };
 
-
 export const bytecode = '0x608060405234801561001057600080fd5b5060405161078938038061078983398181016040528101906100329190';
 export const blockHashTrimmed = '0x3c08bbbee74d287b1dcd3f0ca6d1d2cb92c90883c4acf9747de9f3f3162ad25b';
 export const blockHash = `${blockHashTrimmed}999fc7e86699f60f2a3fb3ed9a646c6b`;
@@ -207,6 +206,28 @@ export const defaultBlock = {
     'gas_used': gasUsed1 + gasUsed2,
     'logs_bloom': '0x'
 };
+export const defaultContract = {
+    "admin_key": null,
+    "auto_renew_account": null,
+    "auto_renew_period": 7776000,
+    "contract_id": "0.0.1052",
+    "created_timestamp": "1659622477.294172233",
+    "deleted": false,
+    "evm_address": null,
+    "expiration_timestamp": null,
+    "file_id": "0.0.1051",
+    "max_automatic_token_associations": 0,
+    "memo": "",
+    "obtainer_id": null,
+    "permanent_removal": null,
+    "proxy_account_id": null,
+    "timestamp": {
+      "from": "1659622477.294172233",
+      "to": null
+    },
+    "bytecode": "0x123456",
+    "runtime_bytecode": "0x608060405234801561001057600080fd5b5060405161078938038061078983398181016040528101906100321234"
+};
 export const defaultContractResults = {
     'results': [
         {

packages/relay/tests/lib/eth.spec.ts

@@ -27,7 +27,7 @@ import { Registry } from 'prom-client';
 import sinon from 'sinon';
 import cache from 'js-cache';
 dotenv.config({ path: path.resolve(__dirname, '../test.env') });
-import {RelayImpl, MirrorNodeClientError} from '@hashgraph/json-rpc-relay';
+import { RelayImpl } from '@hashgraph/json-rpc-relay';
 import { predefined } from '../../src/lib/errors/JsonRpcError';
 import { EthImpl } from '../../src/lib/eth';
 import { MirrorNodeClient } from '../../src/lib/clients/mirrorNodeClient';
@@ -417,7 +417,7 @@ describe('Eth calls using MirrorNode', async function () {
     "contract_id": "0.0.1052",
     "created_timestamp": "1659622477.294172233",
     "deleted": false,
-    "evm_address": contractAddress1,
+    "evm_address": null,
     "expiration_timestamp": null,
     "file_id": "0.0.1051",
     "max_automatic_token_associations": 0,
@@ -805,7 +805,7 @@ describe('Eth calls using MirrorNode', async function () {
     try {
       await ethImpl.getBlockByHash(blockHash, false);
     } catch (e) {
-      console.log(e);
+
       expect(e.code).to.equal(-32603);
       expect(e.name).to.equal('Internal error');
     }
@@ -931,7 +931,6 @@ describe('Eth calls using MirrorNode', async function () {
     try {
       await ethImpl.getTransactionByBlockNumberAndIndex(EthImpl.numberTo0x(defaultBlock.number), EthImpl.numberTo0x(defaultBlock.count));
     } catch (e) {
-      console.log(e);
       expect(e.code).to.equal(-32603);
       expect(e.name).to.equal('Internal error');
     }
@@ -1036,7 +1035,6 @@ describe('Eth calls using MirrorNode', async function () {
     try {
       await ethImpl.getTransactionByBlockHashAndIndex(defaultBlock.hash, EthImpl.numberTo0x(defaultBlock.count));
     } catch (e) {
-      console.log(e);
       expect(e.code).to.equal(-32603);
       expect(e.name).to.equal('Internal error');
     }
@@ -1454,13 +1452,58 @@ describe('Eth calls using MirrorNode', async function () {
     });
 
     it('no filters', async function () {
+      const filteredLogs = {
+        logs: [
+          defaultLogs.logs[0],
+          {...defaultLogs.logs[1], address: "0x0000000000000000000000000000000002131952"},
+          {...defaultLogs.logs[2], address: "0x0000000000000000000000000000000002131953"},
+          {...defaultLogs.logs[3], address: "0x0000000000000000000000000000000002131954"}
+        ]
+      };
       mock.onGet("blocks?limit=1&order=desc").reply(200, { blocks: [defaultBlock] });
-      mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, defaultLogs);
+      mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, filteredLogs);
+      filteredLogs.logs.forEach((log, index) => {
+        mock.onGet(`contracts/${log.address}`).reply(200, {...defaultContract, contract_id: `0.0.105${index}`});
+      });
+
+      const result = await ethImpl.getLogs(null, null, null, null, null);
+      expect(result).to.exist;
+
+      expect(result.length).to.eq(4);
+      expectLogData(result[0], filteredLogs.logs[0], defaultDetailedContractResults);
+      expectLogData(result[1], filteredLogs.logs[1], defaultDetailedContractResults);
+      expectLogData(result[2], filteredLogs.logs[2], defaultDetailedContractResults2);
+      expectLogData(result[3], filteredLogs.logs[3], defaultDetailedContractResults3);
+    });
+
+    it('Should return evm address if contract has one', async function () {
+      const filteredLogs = {
+        logs: [defaultLogs.logs[0]]
+      };
+
+      mock.onGet("blocks?limit=1&order=desc").reply(200, { blocks: [defaultBlock] });
+      mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, filteredLogs);
+      mock.onGet(`contracts/${filteredLogs.logs[0].address}`).reply(200, {...defaultContract, evm_address: defaultEvmAddress});
 
       const result = await ethImpl.getLogs(null, null, null, null, null);
       expect(result).to.exist;
 
+      expect(result.length).to.eq(1);
+      expect(result[0].address).to.eq(defaultEvmAddress);
+    });
+
+    it('Should cache contracts/contractIdOrAddress request', async function () {
+      mock.onGet("blocks?limit=1&order=desc").reply(200, { blocks: [defaultBlock] });
+      mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, defaultLogs);
+      mock.onGet(`contracts/${defaultLogs.logs[0].address}`).replyOnce(200, defaultContract); // This mock will fire only once, if the request is not cached, the test will fail with no mock error
+
+      const result = await ethImpl.getLogs(null, null, null, null, null);
+
+      expect(cache.keys().includes('getLogEvmAddress.0x0000000000000000000000000000000002131951')).to.be.true;
+
+      expect(result).to.exist;
       expect(result.length).to.eq(4);
+
       expectLogData1(result[0]);
       expectLogData2(result[1]);
       expectLogData3(result[2]);
@@ -1473,6 +1516,9 @@ describe('Eth calls using MirrorNode', async function () {
       };
       mock.onGet("blocks?limit=1&order=desc").reply(200, { blocks: [defaultBlock] });
       mock.onGet(`contracts/${contractAddress1}/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, filteredLogs);
+      for (const log of filteredLogs.logs) {
+        mock.onGet(`contracts/${log.address}`).reply(200, defaultContract);
+      }
 
       const result = await ethImpl.getLogs(null, null, null, contractAddress1, null);
 
@@ -1491,6 +1537,9 @@ describe('Eth calls using MirrorNode', async function () {
 
       mock.onGet(`blocks/${blockHash}`).reply(200, defaultBlock);
       mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, filteredLogs);
+      for (const log of filteredLogs.logs) {
+        mock.onGet(`contracts/${log.address}`).reply(200, defaultContract);
+      }
 
       const result = await ethImpl.getLogs(blockHash, null, null, null, null);
 
@@ -1515,6 +1564,9 @@ describe('Eth calls using MirrorNode', async function () {
       mock.onGet('blocks/5').reply(200, defaultBlock);
       mock.onGet('blocks/16').reply(200, toBlock);
       mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${toBlock.timestamp.to}`).reply(200, filteredLogs);
+      for (const log of filteredLogs.logs) {
+        mock.onGet(`contracts/${log.address}`).reply(200, defaultContract);
+      }
 
       const result = await ethImpl.getLogs(null, '0x5', '0x10', null, null);
 
@@ -1526,6 +1578,7 @@ describe('Eth calls using MirrorNode', async function () {
     it('with non-existing fromBlock filter', async function () {
       mock.onGet('blocks/5').reply(200, defaultBlock);
       mock.onGet('blocks/16').reply(404, {"_status": { "messages": [{"message": "Not found"}]}});
+
       const result = await ethImpl.getLogs(null, '0x10', '0x5', null, null);
 
       expect(result).to.exist;
@@ -1540,6 +1593,8 @@ describe('Eth calls using MirrorNode', async function () {
       mock.onGet('blocks/5').reply(200, defaultBlock);
       mock.onGet('blocks/16').reply(404, {"_status": { "messages": [{"message": "Not found"}]}});
       mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}`).reply(200, filteredLogs);
+      mock.onGet(`contracts/${filteredLogs.logs[0].address}`).reply(200, defaultContract);
+
       const result = await ethImpl.getLogs(null, '0x5', '0x10', null, null);
 
       expect(result).to.exist;
@@ -1571,6 +1626,9 @@ describe('Eth calls using MirrorNode', async function () {
 
       mock.onGet('blocks?limit=1&order=desc').reply(200, { blocks: [defaultBlock] });
       mock.onGet(`contracts/results/logs?timestamp=gte:${defaultBlock.timestamp.from}&timestamp=lte:${defaultBlock.timestamp.to}`).reply(200, filteredLogs);
+      for (const log of filteredLogs.logs) {
+        mock.onGet(`contracts/${log.address}`).reply(200, defaultContract);
+      }
 
       const result = await ethImpl.getLogs(null, null, 'latest', null, null);
 
@@ -1610,6 +1668,9 @@ describe('Eth calls using MirrorNode', async function () {
         `&topic0=${defaultLogTopics[0]}&topic1=${defaultLogTopics[1]}` +
         `&topic2=${defaultLogTopics[2]}&topic3=${defaultLogTopics[3]}`
       ).reply(200, filteredLogs);
+      for (const log of filteredLogs.logs) {
+        mock.onGet(`contracts/${log.address}`).reply(200, defaultContract);
+      }
 
       const result = await ethImpl.getLogs(null, null, null, null, defaultLogTopics);
 
@@ -1632,6 +1693,9 @@ describe('Eth calls using MirrorNode', async function () {
         `&topic0=${defaultLogTopics[0]}&topic1=${defaultLogTopics[1]}` +
         `&topic2=${defaultLogTopics[2]}&topic3=${defaultLogTopics[3]}`
       ).reply(200, filteredLogs);
+      for (const log of filteredLogs.logs) {
+        mock.onGet(`contracts/${log.address}`).reply(200, defaultContract);
+      }
 
       const result = await ethImpl.getLogs(null, '0x5', '0x10', null, defaultLogTopics);