nitfixes: to get over the finish line

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 {

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

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