From 47da34c1395cb01035d08a1a059c71d178de8304 Mon Sep 17 00:00:00 2001 From: Mark Tyneway Date: Wed, 26 Aug 2020 20:50:55 -0700 Subject: [PATCH] nitfixes: to get over the finish line (#16) * Remove broken gas metering attempt * Add newline to fix lint * hardcode return value of eth_estimateGas to gas limit * evm: fix log message * state manager: safer calling * rpc: leave comment to help future debugging Co-authored-by: Karl Floersch Co-authored-by: Kevin Ho --- core/vm/evm.go | 12 ++---- core/vm/state_manager.go | 80 ++++++++++++---------------------------- rpc/handler.go | 9 ++++- 3 files changed, 35 insertions(+), 66 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 74af45f5c8ed..df8ab97a0ffd 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -49,15 +49,11 @@ func run(evm *EVM, contract *Contract, input []byte, readOnly bool) ([]byte, err // Intercept the StateManager calls if contract.Address() == StateManagerAddress { log.Debug("Calling State Manager contract.", "StateManagerAddress", hex.EncodeToString(StateManagerAddress.Bytes())) - gas := stateManagerRequiredGas(input) - if contract.UseGas(gas) { - ret, err := callStateManager(input, evm, contract) - if err != nil { - log.Error("State manager error!", "Error", err) - } - return ret, err + ret, err := callStateManager(input, evm, contract) + if err != nil { + log.Error("State manager error!", "error", err) } - return nil, ErrOutOfGas + return ret, err } if contract.CodeAddr != nil { diff --git a/core/vm/state_manager.go b/core/vm/state_manager.go index 64869c6eb534..e1652e08b1f3 100644 --- a/core/vm/state_manager.go +++ b/core/vm/state_manager.go @@ -5,61 +5,30 @@ import ( "encoding/binary" "encoding/hex" "errors" + "fmt" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" ) -type stateManagerFunctionAndGasCost struct { - smFunction stateManagerFunction - smGasCost uint64 -} type stateManagerFunction func(*EVM, *Contract, []byte) ([]byte, error) -var funcs = map[string]stateManagerFunctionAndGasCost{ - "getStorage(address,bytes32)": { - smFunction: getStorage, - smGasCost: 20000, - }, - "setStorage(address,bytes32,bytes32)": { - smFunction: setStorage, - smGasCost: 20000, - }, - "getOvmContractNonce(address)": { - smFunction: getOvmContractNonce, - smGasCost: 20000, - }, - "incrementOvmContractNonce(address)": { - smFunction: incrementOvmContractNonce, - smGasCost: 20000, - }, - "getCodeContractBytecode(address)": { - smFunction: getCodeContractBytecode, - smGasCost: 20000, - }, - "getCodeContractHash(address)": { - smFunction: getCodeContractHash, - smGasCost: 20000, - }, - "getCodeContractAddressFromOvmAddress(address)": { - smFunction: getCodeContractAddress, - smGasCost: 20000, - }, - "associateCodeContract(address,address)": { - smFunction: associateCodeContract, - smGasCost: 20000, - }, - "registerCreatedContract(address)": { - smFunction: registerCreatedContract, - smGasCost: 20000, - }, +var funcs = map[string]stateManagerFunction{ + "getStorage(address,bytes32)": getStorage, + "setStorage(address,bytes32,bytes32)": setStorage, + "getOvmContractNonce(address)": getOvmContractNonce, + "incrementOvmContractNonce(address)": incrementOvmContractNonce, + "getCodeContractBytecode(address)": getCodeContractBytecode, + "getCodeContractHash(address)": getCodeContractHash, + "getCodeContractAddressFromOvmAddress(address)": getCodeContractAddress, + "associateCodeContract(address,address)": associateCodeContract, + "registerCreatedContract(address)": registerCreatedContract, } - -var methodIds map[[4]byte]stateManagerFunctionAndGasCost +var methodIds map[[4]byte]stateManagerFunction func init() { - methodIds = make(map[[4]byte]stateManagerFunctionAndGasCost, len(funcs)) + methodIds = make(map[[4]byte]stateManagerFunction, len(funcs)) for methodSignature, f := range funcs { methodIds[methodSignatureToMethodID(methodSignature)] = f } @@ -71,23 +40,20 @@ func methodSignatureToMethodID(methodSignature string) [4]byte { return methodID } -func stateManagerRequiredGas(input []byte) (gas uint64) { - var methodID [4]byte - copy(methodID[:], input[:4]) - gas = methodIds[methodID].smGasCost - return gas -} - func callStateManager(input []byte, evm *EVM, contract *Contract) (ret []byte, err error) { var methodID [4]byte + if len(input) == 0 { + return nil, nil + } copy(methodID[:], input[:4]) - ret, err = methodIds[methodID].smFunction(evm, contract, input) - return ret, err -} -/* - * StateManager functions - */ + if method, ok := methodIds[methodID]; ok { + return method(evm, contract, input) + } + + ret, err = methodIds[methodID](evm, contract, input) + return nil, fmt.Errorf("state manager call not found: %s", methodID) +} func setStorage(evm *EVM, contract *Contract, input []byte) (ret []byte, err error) { address := common.BytesToAddress(input[4:36]) diff --git a/rpc/handler.go b/rpc/handler.go index ab32cf47e4bb..0e79eafe4532 100644 --- a/rpc/handler.go +++ b/rpc/handler.go @@ -366,7 +366,14 @@ func (h *handler) handleSubscribe(cp *callProc, msg *jsonrpcMessage) *jsonrpcMes // runMethod runs the Go callback for an RPC method. func (h *handler) runMethod(ctx context.Context, msg *jsonrpcMessage, callb *callback, args []reflect.Value) *jsonrpcMessage { - result, err := callb.call(ctx, msg.Method, args) + var result interface{} + var err error + // TODO: think about long term maintainability of altered RPC methods + if msg.Method == "eth_estimateGas" { + result = 0xffffffff //Gas Limit + } else { + result, err = callb.call(ctx, msg.Method, args) + } if err != nil { return msg.errorResponse(err) }