Developer mode (#668)

* feat: throw error in getTransactionByHash

Signed-off-by: Ivo Yankov <[email protected]>

* feat: add env var for dev mode

Signed-off-by: Ivo Yankov <[email protected]>

* test: add unit tests for reverted tx in getTransactionByHash

Signed-off-by: Ivo Yankov <[email protected]>

* test: add acceptance tests for dev mode

Signed-off-by: Ivo Yankov <[email protected]>

* docs: add docs for dev_mode

Signed-off-by: Ivo Yankov <[email protected]>

Signed-off-by: Ivo Yankov <[email protected]>

Author: Ivo-Yankov

.env.example

@@ -17,3 +17,4 @@ HBAR_RATE_LIMIT_TINYBAR =
 HBAR_RATE_LIMIT_DURATION =
 RATE_LIMIT_DISABLED =
 ETH_GET_LOGS_BLOCK_RANGE_LIMIT =
+DEV_MODE =

README.md

@@ -80,8 +80,11 @@ LIMIT_DURATION = 60000
 HBAR_RATE_LIMIT_TINYBAR = 6000000000
 HBAR_RATE_LIMIT_DURATION = 60000
 RATE_LIMIT_DISABLED = false
+DEV_MODE = false
 ```
 
+Note: Read more about `DEV_MODE` [here](docs/dev-mode.md)
+
 The following table highlights some initial configuration values to consider
 
 | Config     | Default | Description                                                                                                                                                                      |

docs/dev-mode.md

@@ -0,0 +1,21 @@
+# Development mode
+
+`Developer mode` is intended to be used by users when developing and testing smart contracts. It allows `hardhat-chai-matchers` and other similar libraries to correctly assert revert messages of non-pure contract methods. 
+It will also be expanded with special settings to speed up the [local node](https://github.com/hashgraph/hedera-local-node).
+
+## Enabling
+
+To enable `dev mode` start the Relay with the environment variable `DEV_MODE` set to `true`.
+
+
+## Rationale 
+
+In the example below `contract.call()` will make the following requests to the JSON RPC Relay: `eth_chainId, eth_estimateGas, eth_sendRawTransaction, eth_getTransactionByHash`
+
+```typescript
+await expect(contract.call()).to.be.revertedWith("Some revert message");
+```
+
+The asserting method expects to catch an error from any of the called API endpoints. Normally `eth_estimateGas` throws the error if the contract call is about to revert, 
+but that is currently not possible in the context of Hedera. Instead the error can be thrown by `eth_getTransactionByHash` after the transaction has gone through the consensus nodes.
+Since that is not the normal desired behaviour it is only enabled in this mode.

helm-chart/templates/configmap.yaml

@@ -27,3 +27,4 @@ data:
   HBAR_RATE_LIMIT_DURATION: {{ .Values.config.HBAR_RATE_LIMIT_DURATION }}
   ETH_GET_LOGS_BLOCK_RANGE_LIMIT: {{ .Values.config.ETH_GET_LOGS_BLOCK_RANGE_LIMIT }}
   RATE_LIMIT_DISABLED: {{ .Values.config.RATE_LIMIT_DISABLED }}
+  DEV_MODE: {{ .Values.config.DEV_MODE }}

helm-chart/templates/deployment.yaml

@@ -144,6 +144,12 @@ spec:
                 name: {{ include "json-rpc-relay.fullname" . }}
                 key: RATE_LIMIT_DISABLED
                 optional: true
+          - name: DEV_MODE
+            valueFrom:
+              configMapKeyRef:
+                name: {{ include "json-rpc-relay.fullname" . }}
+                key: DEV_MODE
+                optional: true
         ports:
           - containerPort: {{ .Values.ports.containerPort }}
             name: {{ .Values.ports.name  }}

helm-chart/values.yaml

@@ -111,6 +111,7 @@ config:
   HBAR_RATE_LIMIT_DURATION: 60000
   ETH_GET_LOGS_BLOCK_RANGE_LIMIT: 1000
   RATE_LIMIT_DISABLED: false
+  DEV_MODE: false
 
 # Enable rolling_restarts if SDK calls fail this is usually due to stale connections that get cycled on restart
 rolling_restart:

packages/relay/src/lib/eth.ts

@@ -960,6 +960,11 @@ export class EthImpl implements Eth {
     const rSig = contractResult.r === null ? null : contractResult.r.substring(0, 66);
     const sSig = contractResult.s === null ? null : contractResult.s.substring(0, 66);
 
+    if (process.env.DEV_MODE && process.env.DEV_MODE === 'true' && contractResult.result === 'CONTRACT_REVERT_EXECUTED') {
+      let err = predefined.CONTRACT_REVERT(contractResult.error_message);
+      throw err;
+    }
+
     return new Transaction({
       accessList: undefined, // we don't support access lists, so punt for now
       blockHash: contractResult.block_hash.substring(0, 66),

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

@@ -2207,6 +2207,15 @@ describe('Eth', async function () {
     "nonce": 1
   };
 
+
+  const defaultDetailedContractResultByHashReverted = {
+    ...defaultDetailedContractResultByHash, ...{
+      "result": "CONTRACT_REVERT_EXECUTED",
+      "status": "0x0",
+      "error_message": "0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000013536f6d6520726576657274206d65737361676500000000000000000000000000"
+    }
+  };
+
   const defaultReceipt = {
     "blockHash": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c042",
     "blockNumber": "0x11",
@@ -2541,5 +2550,57 @@ describe('Eth', async function () {
       expect(result).to.exist;
       expect(result.gas).to.eq('0x0');
     });
+
+    it('returns reverted transactions', async function () {
+      mock.onGet(`contracts/results/${defaultTxHash}`).reply(200, defaultDetailedContractResultByHashReverted);
+      mock.onGet(`accounts/${defaultFromLongZeroAddress}`).reply(200, {
+        evm_address: `${defaultTransaction.from}`
+      });
+
+      const result = await ethImpl.getTransactionByHash(defaultTxHash);
+
+      expect(result).to.exist;
+      if (result == null) return;
+
+      expect(result.accessList).to.eq(defaultTransaction.accessList);
+      expect(result.blockHash).to.eq(defaultTransaction.blockHash);
+      expect(result.blockNumber).to.eq(defaultTransaction.blockNumber);
+      expect(result.chainId).to.eq(defaultTransaction.chainId);
+      expect(result.from).to.eq(defaultTransaction.from);
+      expect(result.gas).to.eq(defaultTransaction.gas);
+      expect(result.gasPrice).to.eq(defaultTransaction.gasPrice);
+      expect(result.hash).to.eq(defaultTransaction.hash);
+      expect(result.input).to.eq(defaultTransaction.input);
+      expect(result.maxFeePerGas).to.eq(defaultTransaction.maxFeePerGas);
+      expect(result.maxPriorityFeePerGas).to.eq(defaultTransaction.maxPriorityFeePerGas);
+      expect(result.nonce).to.eq(EthImpl.numberTo0x(defaultTransaction.nonce));
+      expect(result.r).to.eq(defaultTransaction.r);
+      expect(result.s).to.eq(defaultTransaction.s);
+      expect(result.to).to.eq(defaultTransaction.to);
+      expect(result.transactionIndex).to.eq(defaultTransaction.transactionIndex);
+      expect(result.type).to.eq(EthImpl.numberTo0x(defaultTransaction.type));
+      expect(result.v).to.eq(EthImpl.numberTo0x(defaultTransaction.v));
+      expect(result.value).to.eq(defaultTransaction.value);
+    })
+
+    it('throws error for reverted transactions when DEV_MODE=true', async function () {
+      const initialDevModeValue = process.env.DEV_MODE;
+      process.env.DEV_MODE = 'true';
+
+      mock.onGet(`contracts/results/${defaultTxHash}`).reply(200, defaultDetailedContractResultByHashReverted);
+      mock.onGet(`accounts/${defaultFromLongZeroAddress}`).reply(200, {
+        evm_address: `${defaultTransaction.from}`
+      });
+
+      try {
+        const result = await ethImpl.getTransactionByHash(defaultTxHash);
+        expect(true).to.eq(false);
+      }
+      catch(error) {
+        expect(error).to.deep.equal(predefined.CONTRACT_REVERT(defaultDetailedContractResultByHashReverted.error_message));
+      }
+
+      process.env.DEV_MODE = initialDevModeValue;
+    })
   });
 });

packages/server/tests/acceptance/rpc.spec.ts

@@ -1302,6 +1302,139 @@ describe('@api RPC Server Acceptance Tests', function () {
                 expect(receipt?.revertReason).to.exist;
                 expect(receipt.revertReason).to.eq(PAYABLE_METHOD_ERROR_DATA);
             });
+
+            describe('eth_getTransactionByHash for reverted payable contract calls', async function() {
+                const payableMethodsData = [
+                    {
+                        data: '0xfe0a3dd7',
+                        method: 'revertWithNothing',
+                        message: '',
+                        errorData: '0x'
+                    },
+                    {
+                        data: '0x0323d234',
+                        method: 'revertWithString',
+                        message: 'Some revert message',
+                        errorData: '0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000013536f6d6520726576657274206d65737361676500000000000000000000000000'
+                    },
+                    {
+                        data: '0x46fc4bb1',
+                        method: 'revertWithCustomError',
+                        message: '',
+                        errorData: '0x0bd3d39c'
+                    },
+                    {
+                        data: '0x33fe3fbd',
+                        method: 'revertWithPanic',
+                        message: '',
+                        errorData: '0x4e487b710000000000000000000000000000000000000000000000000000000000000012'
+                    }
+                ];
+                const hashes: any = [];
+
+                beforeEach(async () => {
+                    requestId = Utils.generateRequestId();
+                });
+
+                before(async function() {
+                    for (let i = 0; i < payableMethodsData.length; i++) {
+                        const transaction = {
+                            // value: ONE_TINYBAR,
+                            gasLimit: 30000,
+                            chainId: Number(CHAIN_ID),
+                            to: reverterEvmAddress,
+                            nonce: await relay.getAccountNonce(accounts[0].address, requestId),
+                            gasPrice: await relay.gasPrice(requestId),
+                            data: payableMethodsData[i].data
+                        };
+                        const signedTx = await accounts[0].wallet.signTransaction(transaction);
+                        const hash = await relay.call('eth_sendRawTransaction', [signedTx], requestId);
+                        hashes.push(hash);
+
+                        // Wait until receipt is available in mirror node
+                        await mirrorNode.get(`/contracts/results/${hash}`, requestId);
+                    }
+                });
+
+                for(let i = 0; i < payableMethodsData.length; i++) {
+                    it(`Payable method ${payableMethodsData[i].method} returns tx object`, async function () {
+                        const tx = await relay.call('eth_getTransactionByHash', [hashes[i]], requestId);
+                        expect(tx).to.exist;
+                        expect(tx.hash).to.exist;
+                        expect(tx.hash).to.eq(hashes[i]);
+                    });
+                }
+
+                describe('DEV_MODE = true', async function () {
+                    before(async () =>{
+                        process.env.DEV_MODE = 'true';
+                    })
+
+                    after(async () =>{
+                        process.env.DEV_MODE = 'false';
+                    })
+
+                    for(let i = 0; i < payableMethodsData.length; i++) {
+                        it(`Payable method ${payableMethodsData[i].method} throws an error`, async function () {
+                            await relay.callFailing('eth_getTransactionByHash', [hashes[i]], {
+                                code: -32008,
+                                message: payableMethodsData[i].message,
+                                data: payableMethodsData[i].errorData
+                            }, requestId);
+                        });
+                    }
+                });
+            });
+
+            describe('eth_call for reverted pure contract calls', async function() {
+                beforeEach(async () => {
+                    requestId = Utils.generateRequestId();
+                });
+
+                const pureMethodsData = [
+                    {
+                        data: '0x2dac842f',
+                        method: 'revertWithNothingPure',
+                        message: '',
+                        errorData: '0x'
+                    },
+                    {
+                        data: '0x8b153371',
+                        method: 'revertWithStringPure',
+                        message: 'Some revert message',
+                        errorData: '0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000013536f6d6520726576657274206d65737361676500000000000000000000000000'
+                    },
+                    {
+                        data: '0x35314694',
+                        method: 'revertWithCustomErrorPure',
+                        message: '',
+                        errorData: '0x0bd3d39c'
+                    },
+                    {
+                        data: '0x83889056',
+                        method: 'revertWithPanicPure',
+                        message: '',
+                        errorData: '0x4e487b710000000000000000000000000000000000000000000000000000000000000012'
+                    }
+                ];
+
+                for (let i = 0; i < pureMethodsData.length; i++) {
+                    it(`Pure method ${pureMethodsData[i].method} returns tx receipt`, async function () {
+                        const callData = {
+                            from: accounts[0].address,
+                            to: reverterEvmAddress,
+                            gas: 30000,
+                            data: pureMethodsData[i].data
+                        };
+
+                        await relay.callFailing('eth_call', [callData], {
+                            code: -32008,
+                            message: pureMethodsData[i].message,
+                            data: pureMethodsData[i].errorData
+                        }, requestId);
+                    });
+                }
+            });
         });
     });
 });