cerc-io/go-ethereum
18
0
Fork 0
Code Issues 9 Pull Requests Packages Projects Releases 66 Wiki Activity

nitfixes: to get over the finish line (#16)

Browse Source 
* 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 <karl@karlfloersch.com>
Co-authored-by: Kevin Ho <kevinjho1996@gmail.com>
This commit is contained in:
Mark Tyneway 2020-08-26 20:50:55 -07:00 committed by GitHub
parent 1efe552752
commit 47da34c139
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 35 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/vm/evm.go
View File

@ -49,16 +49,12 @@ 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)
log.Error("State manager error!", "error", err)
}
return ret, err
}
return nil, ErrOutOfGas
}
if contract.CodeAddr != nil {
precompiles := PrecompiledContractsHomestead

80
core/vm/state_manager.go
View File

@ -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])

9
rpc/handler.go
View File

@ -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)
}