implement eth_getStorageAt method. initial pass (#433)

* implement eth_getStorageAt method.  initial pass

Signed-off-by: lukelee-sl <[email protected]>

* address SonarCloud issues

Signed-off-by: lukelee-sl <[email protected]>

* reduce cognitive complexity

Signed-off-by: lukelee-sl <[email protected]>

* make block number optional

Signed-off-by: lukelee-sl <[email protected]>

* address code review comments

Signed-off-by: lukelee-sl <[email protected]>

* address sonarcloud checks

Signed-off-by: lukelee-sl <[email protected]>

* Merge remote changes

Signed-off-by: lukelee-sl <[email protected]>

* fix code merging issue

Signed-off-by: lukelee-sl <[email protected]>

* remove unneeded function

Signed-off-by: lukelee-sl <[email protected]>

* fix typo

Signed-off-by: lukelee-sl <[email protected]>

* fix typo

Signed-off-by: lukelee-sl <[email protected]>

* address code review comments

Signed-off-by: lukelee-sl <[email protected]>

* use static constants for pending, latest and earliest

Signed-off-by: lukelee-sl <[email protected]>

* update limit

Signed-off-by: lukelee-sl <[email protected]>

Author: lukelee-sl

packages/relay/src/index.ts

@@ -72,7 +72,7 @@ export interface Eth {
 
   getLogs(blockHash: string|null, fromBlock: string|null, toBlock: string|null, address: string|null, topics: any[]|null, requestId?: string): Promise<Log[]>;
 
-  getStorageAt(address: string, slot: string, blockNumber: string|null, requestId?: string): JsonRpcError;
+  getStorageAt(address: string, slot: string, blockNumber: string|null, requestId?: string): Promise<string>;
 
   getTransactionByBlockHashAndIndex(hash: string, index: number, requestId?: string): Promise<Transaction | null>;
 

packages/relay/src/lib/clients/mirrorNodeClient.ts

@@ -344,6 +344,15 @@ export class MirrorNodeClient {
             .replace(MirrorNodeClient.TIMESTAMP_PLACEHOLDER, timestamp);
     }
 
+    public async getLatestContractResultsByAddress(address: string, blockEndTimestamp: string | undefined, limit: number) {
+        // retrieve the timestamp of the contract
+        const contractResultsParams: IContractResultsParams = blockEndTimestamp 
+            ? { timestamp: `lte:${blockEndTimestamp}` } 
+            : {};
+        const limitOrderParams: ILimitOrderParams = this.getLimitOrderQueryParam(limit, 'desc'); 
+        return this.getContractResultsByAddress(address, contractResultsParams, limitOrderParams);
+    }
+
     getQueryParams(params: object) {
         let paramString = '';
         for (const [key, value] of Object.entries(params)) {

packages/relay/src/lib/errors/JsonRpcError.ts

@@ -111,4 +111,9 @@ export const predefined = {
     code: -32010,
     message: 'Request timeout. Please try again.'
   }),
+  'RESOURCE_NOT_FOUND': new JsonRpcError({
+    name: 'Resource not found',
+    code: -32001,
+    message: 'Requested resource not found'
+  }),
 };

packages/relay/src/lib/eth.ts

@@ -69,6 +69,10 @@ export class EthImpl implements Eth {
   static ethGetTransactionCount = 'eth_getTransactionCount';
   static ethSendRawTransaction = 'eth_sendRawTransaction';
 
+  // block constants 
+  static blockLatest = 'latest';
+  static blockEarliest = 'earliest';
+  static blockPending = 'pending';
 
   /**
    * The sdk client use for connecting to both the consensus nodes and mirror node. The account
@@ -139,7 +143,7 @@ export class EthImpl implements Eth {
     const requestIdPrefix = formatRequestIdMessage(requestId);
     this.logger.trace(`${requestIdPrefix} feeHistory(blockCount=${blockCount}, newestBlock=${newestBlock}, rewardPercentiles=${rewardPercentiles})`);
     try {
-      const latestBlockNumber = await this.translateBlockTag('latest', requestId);
+      const latestBlockNumber = await this.translateBlockTag(EthImpl.blockLatest, requestId);
       const newestBlockNumber = await this.translateBlockTag(newestBlock, requestId);
 
       if (newestBlockNumber > latestBlockNumber) {
@@ -441,10 +445,43 @@ export class EthImpl implements Eth {
     return predefined.UNSUPPORTED_METHOD;
   }
 
-  getStorageAt(address: string, slot: string, blockNumber: string | null, requestId?: string): JsonRpcError {
+  /**
+   * Gets the value from a storage position at the given Ethereum address. 
+   *
+   * @param address
+   * @param slot
+   * @param blockNumberOrTag
+   */
+  async getStorageAt(address: string, slot: string, blockNumberOrTag?: string | null, requestId?: string) : Promise<string> {
     const requestIdPrefix = formatRequestIdMessage(requestId);
-    this.logger.trace(`${requestIdPrefix} getStorageAt(address=${address}, slot=${slot}, blockNumber=${blockNumber})`, address, slot, blockNumber);
-    return predefined.UNSUPPORTED_METHOD;
+    let result = EthImpl.zeroHex32Byte; // if contract or slot not found then return 32 byte 0
+    const blockResponse  = await this.getHistoricalBlockResponse(blockNumberOrTag, false);
+    const blockEndTimestamp = blockResponse?.timestamp?.to;
+    const contractResult = await this.mirrorNodeClient.getLatestContractResultsByAddress(address, blockEndTimestamp, 1);
+
+    if (contractResult?.results?.length > 0) {
+      // retrieve the contract result details 
+      await this.mirrorNodeClient.getContractResultsDetails(address, contractResult.results[0].timestamp)
+        .then( contractResultDetails => {
+          if(contractResultDetails && contractResultDetails.state_changes) {
+            // loop through the state changes to match slot and return value
+            for (const stateChange of contractResultDetails.state_changes) {
+              if(stateChange.slot === slot) {
+                result = stateChange.value_written;
+              }
+            }
+          }
+        })
+        .catch( (e: any) => {
+          this.logger.error(
+            e,
+            `${requestIdPrefix} Failed to retrieve contract result details for contract address ${address} at timestamp=${contractResult.results[0].timestamp}`,
+          );
+          throw e;  
+        });
+    }
+
+    return result;
   }
 
   /**
@@ -913,9 +950,9 @@ export class EthImpl implements Eth {
    * @private
    */
   private async translateBlockTag(tag: string | null, requestId?: string): Promise<number> {
-    if (tag === null || tag === 'latest' || tag === 'pending') {
+    if (tag === null || tag === EthImpl.blockLatest || tag === EthImpl.blockPending) {
       return Number(await this.blockNumber(requestId));
-    } else if (tag === 'earliest') {
+    } else if (tag === EthImpl.blockEarliest) {
       return 0;
     } else {
       return Number(tag);
@@ -932,25 +969,8 @@ export class EthImpl implements Eth {
    * @param blockHashOrNumber
    * @param showDetails
    */
-  private async getBlock(blockHashOrNumber: string, showDetails: boolean, requestId?: string): Promise<Block | null> {
-    let blockResponse: any;
-    if (blockHashOrNumber == null || blockHashOrNumber == 'latest' || blockHashOrNumber == 'pending') {
-      const blockPromise = this.mirrorNodeClient.getLatestBlock(requestId);
-      const blockAnswer = await blockPromise;
-      blockResponse = blockAnswer.blocks[0];
-    } else if (blockHashOrNumber == 'earliest') {
-      blockResponse = await this.mirrorNodeClient.getBlock(0, requestId);
-    } else if (blockHashOrNumber.length < 32) {
-      // anything less than 32 characters is treated as a number
-      blockResponse = await this.mirrorNodeClient.getBlock(Number(blockHashOrNumber), requestId);
-    } else {
-      blockResponse = await this.mirrorNodeClient.getBlock(blockHashOrNumber, requestId);
-    }
-
-    if (_.isNil(blockResponse) || blockResponse.hash === undefined) {
-      // block not found
-      return null;
-    }
+  private async getBlock(blockHashOrNumber: string, showDetails: boolean, requestId?: string ): Promise<Block | null> {
+    const blockResponse = await this.getHistoricalBlockResponse(blockHashOrNumber, true);
 
     const timestampRange = blockResponse.timestamp;
     const timestampRangeParams = [`gte:${timestampRange.from}`, `lte:${timestampRange.to}`];
@@ -1016,6 +1036,41 @@ export class EthImpl implements Eth {
     });
   }
 
+  /**
+   * returns the block response  
+   * otherwise return undefined.
+   *
+   * @param blockNumberOrTag
+   * @param returnLatest
+   */
+  private async getHistoricalBlockResponse(blockNumberOrTag?: string | null, returnLatest?: boolean): Promise<any | null> {
+    let blockResponse: any;
+    // Determine if the latest block should be returned and if not then just return null
+    if (!returnLatest && 
+      (blockNumberOrTag == null || blockNumberOrTag === EthImpl.blockLatest || blockNumberOrTag === EthImpl.blockPending)) {
+      return null;
+    }
+
+    if (blockNumberOrTag == null || blockNumberOrTag === EthImpl.blockLatest || blockNumberOrTag === EthImpl.blockPending) {
+      const blockPromise = this.mirrorNodeClient.getLatestBlock();
+      const blockAnswer = await blockPromise;
+      blockResponse = blockAnswer.blocks[0];
+    } else if (blockNumberOrTag == EthImpl.blockEarliest) {
+      blockResponse = await this.mirrorNodeClient.getBlock(0);
+    } else if (blockNumberOrTag.length < 32) {
+      // anything less than 32 characters is treated as a number
+      blockResponse = await this.mirrorNodeClient.getBlock(Number(blockNumberOrTag));
+    } else {
+      blockResponse = await this.mirrorNodeClient.getBlock(blockNumberOrTag);
+    }
+    if (_.isNil(blockResponse) || blockResponse.hash === undefined) {
+      // block not found. 
+      throw predefined.RESOURCE_NOT_FOUND;
+    }
+
+    return blockResponse;
+  }
+
   private static getTransactionCountFromBlockResponse(block: any) {
     if (block === null || block.count === undefined) {
       // block not found

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

@@ -1498,6 +1498,79 @@ describe('Eth calls using MirrorNode', async function () {
       expect(hasError).to.be.true;
     });
   });
+
+  describe('eth_getStorageAt', async function() {
+    it('eth_getStorageAt with match with block', async function () {
+      // mirror node request mocks
+      mock.onGet(`blocks/${blockNumber}`).reply(200, defaultBlock);
+      mock.onGet(`contracts/${contractAddress1}/results?timestamp=lte:${defaultBlock.timestamp.to}&limit=1&order=desc`).reply(200, defaultContractResults);
+      mock.onGet(`contracts/${contractAddress1}/results/${contractTimestamp1}`).reply(200, defaultDetailedContractResults);
+
+      const result = await ethImpl.getStorageAt(contractAddress1, defaultDetailedContractResults.state_changes[0].slot, EthImpl.numberTo0x(blockNumber));
+      expect(result).to.exist;
+      if (result == null) return;
+  
+      // verify slot value
+      expect(result).equal(defaultDetailedContractResults.state_changes[0].value_written);
+    });
+
+    it('eth_getStorageAt with match with latest block', async function () {
+      // mirror node request mocks
+      mock.onGet(`contracts/${contractAddress1}/results?limit=1&order=desc`).reply(200, defaultContractResults);
+      mock.onGet(`contracts/${contractAddress1}/results/${contractTimestamp1}`).reply(200, defaultDetailedContractResults);
+
+      const result = await ethImpl.getStorageAt(contractAddress1, defaultDetailedContractResults.state_changes[0].slot, "latest");
+      expect(result).to.exist;
+      if (result == null) return;
+  
+      // verify slot value
+      expect(result).equal(defaultDetailedContractResults.state_changes[0].value_written);
+    });
+
+    it('eth_getStorageAt with match null block', async function () {
+      // mirror node request mocks
+      mock.onGet(`contracts/${contractAddress1}/results?limit=1&order=desc`).reply(200, defaultContractResults);
+      mock.onGet(`contracts/${contractAddress1}/results/${contractTimestamp1}`).reply(200, defaultDetailedContractResults);
+
+      const result = await ethImpl.getStorageAt(contractAddress1, defaultDetailedContractResults.state_changes[0].slot);
+      expect(result).to.exist;
+      if (result == null) return;
+  
+      // verify slot value
+      expect(result).equal(defaultDetailedContractResults.state_changes[0].value_written);
+    });
+
+    it('eth_getStorageAt should throw a predefined NO_SUITABLE_PEERS when block not found', async function () {
+
+      let hasError = false;
+      try {
+        mock.onGet(`blocks/${blockNumber}`).reply(200, null);
+        const result = await ethImpl.getStorageAt(contractAddress1, defaultDetailedContractResults.state_changes[0].slot, EthImpl.numberTo0x(blockNumber));  
+      } catch (e: any) {
+        hasError = true;
+        expect(e.code).to.equal(-32001);
+        expect(e.name).to.equal('Resource not found');
+      }
+      expect(hasError).to.be.true;
+    });
+
+    it('eth_getStorageAt should throw error when contract not found', async function () {
+      // mirror node request mocks
+      mock.onGet(`blocks/${blockNumber}`).reply(200, defaultBlock);
+      mock.onGet(`contracts/${contractAddress1}/results?timestamp=lte:${defaultBlock.timestamp.to}&limit=1&order=desc`).reply(200, defaultContractResults);
+      mock.onGet(`contracts/${contractAddress1}/results/${contractTimestamp1}`).reply(404, detailedContractResultNotFound);
+
+      let hasError = false;
+      try {
+        const result = await ethImpl.getStorageAt(contractAddress1, defaultDetailedContractResults.state_changes[0].slot, EthImpl.numberTo0x(blockNumber));
+      } catch (e: any) {
+        hasError = true;
+        expect(e.statusCode).to.equal(404);
+        expect(e.message).to.equal("Request failed with status code 404");
+      }  
+      expect(hasError).to.be.true;
+    });
+  });
 });
 
 describe('Eth', async function () {
@@ -1684,7 +1757,6 @@ describe('Eth', async function () {
     'sendTransaction',
     'protocolVersion',
     'coinbase',
-    'getStorageAt',
   ];
 
   unsupportedMethods.forEach(method => {

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

@@ -414,6 +414,36 @@ describe('MirrorNodeClient', async function () {
     expect(firstResult.to).equal(contractResult.to);
   });
 
+  it('`getLatestContractResultsByAddress` by address no timestamp', async () => {
+    const address = '0x0000000000000000000000000000000000001f41';
+    mock.onGet(`contracts/${address}/results?limit=1&order=desc`).reply(200, { results: [contractResult], links: { next: null } });
+
+    const result = await mirrorNodeInstance.getLatestContractResultsByAddress(address, undefined, 1);
+    expect(result).to.exist;
+    expect(result.links).to.exist;
+    expect(result.links.next).to.equal(null);
+    expect(result.results.length).to.gt(0);
+    const firstResult = result.results[0];
+    expect(firstResult.contract_id).equal(detailedContractResult.contract_id);
+    expect(firstResult.function_parameters).equal(contractResult.function_parameters);
+    expect(firstResult.to).equal(contractResult.to);
+  });
+
+  it('`getLatestContractResultsByAddress` by address with timestamp, limit 2', async () => {
+    const address = '0x0000000000000000000000000000000000001f41';
+    mock.onGet(`contracts/${address}/results?timestamp=lte:987654.000123456&limit=2&order=desc`).reply(200, { results: [contractResult], links: { next: null } });
+
+    const result = await mirrorNodeInstance.getLatestContractResultsByAddress(address, "987654.000123456", 2);
+    expect(result).to.exist;
+    expect(result.links).to.exist;
+    expect(result.links.next).to.equal(null);
+    expect(result.results.length).to.gt(0);
+    const firstResult = result.results[0];
+    expect(firstResult.contract_id).equal(detailedContractResult.contract_id);
+    expect(firstResult.function_parameters).equal(contractResult.function_parameters);
+    expect(firstResult.to).equal(contractResult.to);
+  });
+
   const log = {
     'address': '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
     'bloom': '0x549358c4c2e573e02410ef7b5a5ffa5f36dd7398',

packages/server/tests/integration/server.spec.ts

@@ -316,17 +316,6 @@ describe('RPC Server', async function() {
 
     BaseTest.unsupportedJsonRpcMethodChecks(res);
   });
-
-  it('should execute "eth_getStorageAt"', async function() {
-    const res = await this.testClient.post('/', {
-      'id': '2',
-      'jsonrpc': '2.0',
-      'method': 'eth_getStorageAt',
-      'params': [null]
-    });
-
-    BaseTest.unsupportedJsonRpcMethodChecks(res);
-  });
 });
 
 class BaseTest {