rpc, evm: use binary search to estimate gas (#272)

* do binary search to estimate gas

Closes #268

- Also refactor ApplyMessage to be more reuseable

move binary search to rpc api side to have a clean context each try

remove EstimateGas grpc api

* extract BinSearch function and add unit test

* do estimateGas in grpc query

Co-authored-by: Federico Kunze Küllmer <31522760+fedekunze@users.noreply.github.com>

CHANGELOG.md

@@ -68,6 +68,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (rpc)  [#124](https://github.com/tharsis/ethermint/issues/124) Implement `txpool_content`, `txpool_inspect` and `txpool_status` RPC methods
 * (rpc) [tharsis#112](https://github.com/tharsis/ethermint/pull/153) Fix `eth_coinbase` to return the ethereum address of the validator
 * (rpc) [tharsis#176](https://github.com/tharsis/ethermint/issues/176) Support fetching pending nonce
+* (rpc) [tharsis#272](https://github.com/tharsis/ethermint/pull/272) do binary search to estimate gas accurately
 
 ### Bug Fixes
 

client/docs/swagger-ui/swagger.yaml

@@ -1433,6 +1433,225 @@ paths:
           type: string
       tags:
         - Query
+  /ethermint/evm/v1alpha1/estimate_gas:
+    get:
+      summary: EstimateGas implements the `eth_estimateGas` rpc api
+      operationId: EstimateGas
+      responses:
+        '200':
+          description: A successful response.
+          schema:
+            type: object
+            properties:
+              gas:
+                type: string
+                format: uint64
+                title: the estimated gas
+            title: EstimateGasResponse defines EstimateGas response
+        default:
+          description: An unexpected error response
+          schema:
+            type: object
+            properties:
+              error:
+                type: string
+              code:
+                type: integer
+                format: int32
+              message:
+                type: string
+              details:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    type_url:
+                      type: string
+                      description: >-
+                        A URL/resource name that uniquely identifies the type of
+                        the serialized
+
+                        protocol buffer message. This string must contain at
+                        least
+
+                        one "/" character. The last segment of the URL's path
+                        must represent
+
+                        the fully qualified name of the type (as in
+
+                        `path/google.protobuf.Duration`). The name should be in
+                        a canonical form
+
+                        (e.g., leading "." is not accepted).
+
+
+                        In practice, teams usually precompile into the binary
+                        all types that they
+
+                        expect it to use in the context of Any. However, for
+                        URLs which use the
+
+                        scheme `http`, `https`, or no scheme, one can optionally
+                        set up a type
+
+                        server that maps type URLs to message definitions as
+                        follows:
+
+
+                        * If no scheme is provided, `https` is assumed.
+
+                        * An HTTP GET on the URL must yield a
+                        [google.protobuf.Type][]
+                          value in binary format, or produce an error.
+                        * Applications are allowed to cache lookup results based
+                        on the
+                          URL, or have them precompiled into a binary to avoid any
+                          lookup. Therefore, binary compatibility needs to be preserved
+                          on changes to types. (Use versioned type names to manage
+                          breaking changes.)
+
+                        Note: this functionality is not currently available in
+                        the official
+
+                        protobuf release, and it is not used for type URLs
+                        beginning with
+
+                        type.googleapis.com.
+
+
+                        Schemes other than `http`, `https` (or the empty scheme)
+                        might be
+
+                        used with implementation specific semantics.
+                    value:
+                      type: string
+                      format: byte
+                      description: >-
+                        Must be a valid serialized protocol buffer of the above
+                        specified type.
+                  description: >-
+                    `Any` contains an arbitrary serialized protocol buffer
+                    message along with a
+
+                    URL that describes the type of the serialized message.
+
+
+                    Protobuf library provides support to pack/unpack Any values
+                    in the form
+
+                    of utility functions or additional generated methods of the
+                    Any type.
+
+
+                    Example 1: Pack and unpack a message in C++.
+
+                        Foo foo = ...;
+                        Any any;
+                        any.PackFrom(foo);
+                        ...
+                        if (any.UnpackTo(&foo)) {
+                          ...
+                        }
+
+                    Example 2: Pack and unpack a message in Java.
+
+                        Foo foo = ...;
+                        Any any = Any.pack(foo);
+                        ...
+                        if (any.is(Foo.class)) {
+                          foo = any.unpack(Foo.class);
+                        }
+
+                     Example 3: Pack and unpack a message in Python.
+
+                        foo = Foo(...)
+                        any = Any()
+                        any.Pack(foo)
+                        ...
+                        if any.Is(Foo.DESCRIPTOR):
+                          any.Unpack(foo)
+                          ...
+
+                     Example 4: Pack and unpack a message in Go
+
+                         foo := &pb.Foo{...}
+                         any, err := ptypes.MarshalAny(foo)
+                         ...
+                         foo := &pb.Foo{}
+                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
+                           ...
+                         }
+
+                    The pack methods provided by protobuf library will by
+                    default use
+
+                    'type.googleapis.com/full.type.name' as the type URL and the
+                    unpack
+
+                    methods only use the fully qualified type name after the
+                    last '/'
+
+                    in the type URL, for example "foo.bar.com/x/y.z" will yield
+                    type
+
+                    name "y.z".
+
+
+
+                    JSON
+
+                    ====
+
+                    The JSON representation of an `Any` value uses the regular
+
+                    representation of the deserialized, embedded message, with
+                    an
+
+                    additional field `@type` which contains the type URL.
+                    Example:
+
+                        package google.profile;
+                        message Person {
+                          string first_name = 1;
+                          string last_name = 2;
+                        }
+
+                        {
+                          "@type": "type.googleapis.com/google.profile.Person",
+                          "firstName": <string>,
+                          "lastName": <string>
+                        }
+
+                    If the embedded message type is well-known and has a custom
+                    JSON
+
+                    representation, that representation will be embedded adding
+                    a field
+
+                    `value` which holds the custom JSON in addition to the
+                    `@type`
+
+                    field. Example (for message [google.protobuf.Duration][]):
+
+                        {
+                          "@type": "type.googleapis.com/google.protobuf.Duration",
+                          "value": "1.212s"
+                        }
+      parameters:
+        - name: args
+          description: same json format as the json rpc api.
+          in: query
+          required: false
+          type: string
+          format: byte
+        - name: gas_cap
+          description: the default gas cap to be used.
+          in: query
+          required: false
+          type: string
+          format: uint64
+      tags:
+        - Query
   /ethermint/evm/v1alpha1/eth_call:
     get:
       summary: EthCall implements the `eth_call` rpc api
@@ -1721,6 +1940,12 @@ paths:
           required: false
           type: string
           format: byte
+        - name: gas_cap
+          description: the default gas cap to be used.
+          in: query
+          required: false
+          type: string
+          format: uint64
       tags:
         - Query
   /ethermint/evm/v1alpha1/params:
@@ -12878,6 +13103,14 @@ definitions:
       values
 
       instead of *big.Int.
+  ethermint.evm.v1alpha1.EstimateGasResponse:
+    type: object
+    properties:
+      gas:
+        type: string
+        format: uint64
+        title: the estimated gas
+    title: EstimateGasResponse defines EstimateGas response
   ethermint.evm.v1alpha1.Log:
     type: object
     properties:

docs/core/proto-docs.md

@@ -32,6 +32,7 @@
     - [Msg](#ethermint.evm.v1alpha1.Msg)
 
 - [ethermint/evm/v1alpha1/query.proto](#ethermint/evm/v1alpha1/query.proto)
+    - [EstimateGasResponse](#ethermint.evm.v1alpha1.EstimateGasResponse)
     - [EthCallRequest](#ethermint.evm.v1alpha1.EthCallRequest)
     - [QueryAccountRequest](#ethermint.evm.v1alpha1.QueryAccountRequest)
     - [QueryAccountResponse](#ethermint.evm.v1alpha1.QueryAccountResponse)
@@ -467,6 +468,21 @@ Msg defines the evm Msg service.
 
 
 
+<a name="ethermint.evm.v1alpha1.EstimateGasResponse"></a>
+
+### EstimateGasResponse
+EstimateGasResponse defines EstimateGas response
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `gas` | [uint64](#uint64) |  | the estimated gas |
+
+
+
+
+
+
 <a name="ethermint.evm.v1alpha1.EthCallRequest"></a>
 
 ### EthCallRequest
@@ -476,6 +492,7 @@ EthCallRequest defines EthCall request
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
 | `args` | [bytes](#bytes) |  | same json format as the json rpc api. |
+| `gas_cap` | [uint64](#uint64) |  | the default gas cap to be used |
 
 
 
@@ -841,6 +858,7 @@ Query defines the gRPC querier service.
 | `Params` | [QueryParamsRequest](#ethermint.evm.v1alpha1.QueryParamsRequest) | [QueryParamsResponse](#ethermint.evm.v1alpha1.QueryParamsResponse) | Params queries the parameters of x/evm module. | GET|/ethermint/evm/v1alpha1/params|
 | `StaticCall` | [QueryStaticCallRequest](#ethermint.evm.v1alpha1.QueryStaticCallRequest) | [QueryStaticCallResponse](#ethermint.evm.v1alpha1.QueryStaticCallResponse) | StaticCall queries the static call value of x/evm module. | GET|/ethermint/evm/v1alpha1/static_call|
 | `EthCall` | [EthCallRequest](#ethermint.evm.v1alpha1.EthCallRequest) | [MsgEthereumTxResponse](#ethermint.evm.v1alpha1.MsgEthereumTxResponse) | EthCall implements the `eth_call` rpc api | GET|/ethermint/evm/v1alpha1/eth_call|
+| `EstimateGas` | [EthCallRequest](#ethermint.evm.v1alpha1.EthCallRequest) | [EstimateGasResponse](#ethermint.evm.v1alpha1.EstimateGasResponse) | EstimateGas implements the `eth_estimateGas` rpc api | GET|/ethermint/evm/v1alpha1/estimate_gas|
 
  <!-- end services -->
 

ethereum/rpc/namespaces/eth/api.go

@@ -550,11 +550,21 @@ func (e *PublicAPI) doCall(
 	if err != nil {
 		return nil, err
 	}
-	req := evmtypes.EthCallRequest{Args: bz}
+	req := evmtypes.EthCallRequest{Args: bz, GasCap: ethermint.DefaultRPCGasLimit}
+
+	// From ContextWithHeight: if the provided height is 0,
+	// it will return an empty context and the gRPC query will use
+	// the latest block height for querying.
 	res, err := e.queryClient.EthCall(rpctypes.ContextWithHeight(blockNr.Int64()), &req)
 	if err != nil {
 		return nil, err
 	}
+	if len(res.VmError) > 0 {
+		if res.VmError == vm.ErrExecutionReverted.Error() {
+			return nil, evmtypes.NewExecErrorWithReason(res.Ret)
+		}
+		return nil, errors.New(res.VmError)
+	}
 
 	if res.Failed() {
 		if res.VmError == vm.ErrExecutionReverted.Error() {
@@ -567,18 +577,28 @@ func (e *PublicAPI) doCall(
 }
 
 // EstimateGas returns an estimate of gas usage for the given smart contract call.
-func (e *PublicAPI) EstimateGas(args evmtypes.CallArgs) (hexutil.Uint64, error) {
+func (e *PublicAPI) EstimateGas(args evmtypes.CallArgs, blockNrOptional *rpctypes.BlockNumber) (hexutil.Uint64, error) {
 	e.logger.Debug("eth_estimateGas")
 
+	blockNr := rpctypes.EthPendingBlockNumber
+	if blockNrOptional != nil {
+		blockNr = *blockNrOptional
+	}
+
+	bz, err := json.Marshal(&args)
+	if err != nil {
+		return 0, err
+	}
+	req := evmtypes.EthCallRequest{Args: bz, GasCap: ethermint.DefaultRPCGasLimit}
+
 	// From ContextWithHeight: if the provided height is 0,
 	// it will return an empty context and the gRPC query will use
 	// the latest block height for querying.
-	data, err := e.doCall(args, 0)
+	res, err := e.queryClient.EstimateGas(rpctypes.ContextWithHeight(blockNr.Int64()), &req)
 	if err != nil {
 		return 0, err
 	}
-
-	return hexutil.Uint64(data.GasUsed), nil
+	return hexutil.Uint64(res.Gas), nil
 }
 
 // GetBlockByHash returns the block identified by hash.
@@ -1027,7 +1047,8 @@ func (e *PublicAPI) setTxDefaults(args rpctypes.SendTxArgs) (rpctypes.SendTxArgs
 			Data:       input,
 			AccessList: args.AccessList,
 		}
-		estimated, err := e.EstimateGas(callArgs)
+		blockNr := rpctypes.NewBlockNumber(big.NewInt(0))
+		estimated, err := e.EstimateGas(callArgs, &blockNr)
 		if err != nil {
 			return args, err
 		}

proto/ethermint/evm/v1alpha1/query.proto

@@ -71,6 +71,12 @@ service Query {
   rpc EthCall(EthCallRequest) returns (MsgEthereumTxResponse) {
     option (google.api.http).get = "/ethermint/evm/v1alpha1/eth_call";
   }
+
+  // EstimateGas implements the `eth_estimateGas` rpc api
+  rpc EstimateGas(EthCallRequest) returns (EstimateGasResponse) {
+    option (google.api.http).get = "/ethermint/evm/v1alpha1/estimate_gas";
+  }
+
 }
 
 // QueryAccountRequest is the request type for the Query/Account RPC method.
@@ -251,4 +257,12 @@ message QueryStaticCallResponse {
 message EthCallRequest {
   // same json format as the json rpc api.
   bytes args = 1;
+  // the default gas cap to be used
+  uint64 gas_cap = 2;
+}
+
+// EstimateGasResponse defines EstimateGas response
+message EstimateGasResponse {
+  // the estimated gas
+  uint64 gas = 1;
 }