Add cmbridge precompile contract

add cmbridge precompile contract

core/vm/cmbridge.go

@@ -0,0 +1,60 @@
+package vm
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var (
+	//cmBridgeContractAddress is 0x0000000000000000000000000000000000000100
+	cmBridgeContractAddress = common.BytesToAddress([]byte{0x01, 0x00})
+)
+
+type CallToWasmByPrecompile func(ctx OKContext, caller, to common.Address, value *big.Int, input []byte, remainGas uint64) ([]byte, uint64, error)
+
+type OKContext interface {
+	GetEVMStateDB() StateDB
+}
+
+// cmBridge implemented as a native contract.
+type cmBridge struct {
+	context OKContext //OK chain add new Context
+	// Context provides auxiliary blockchain related information
+	EvmContext BlockContext
+	callToWasm CallToWasmByPrecompile
+	caller     common.Address
+	to         common.Address
+	value      *big.Int
+}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+//
+// This method does not require any overflow checking as the input size gas costs
+// required for anything significant is so high it's impossible to pay for.
+// we can cost some gas
+func (c *cmBridge) RequiredGas(input []byte) uint64 {
+	panic("cmBridge not support <Run> of implement")
+}
+func (c *cmBridge) Run(in []byte) ([]byte, error) {
+	panic("cmBridge not support <Run> of implement")
+}
+
+func (c *cmBridge) CustomRun(in []byte, remainGas uint64, callType string) ([]byte, uint64, error) {
+	if callType != CALL.String() {
+		return nil, 0, fmt.Errorf("cmBridge not support the type of call:%s, only support CALL", callType)
+	}
+	// cmBridge can not got coin, when can cmBridgeContract may be send coin to cmBridgeContractAddress, so we must send coin back to caller.
+	if c.value.Sign() != 0 && !c.EvmContext.CanTransfer(c.context.GetEVMStateDB(), cmBridgeContractAddress, c.value) {
+		return nil, 0, ErrCMBirdgeInsufficientBalance
+	}
+
+	c.EvmContext.Transfer(c.context.GetEVMStateDB(), cmBridgeContractAddress, c.caller, c.value)
+	// after send coin back to caller, we send coin
+	return c.callToWasm(c.context, c.caller, c.to, c.value, in, remainGas)
+}
+
+func NewCMBridge(context OKContext, evmContext BlockContext, callToWasm CallToWasmByPrecompile, caller, to common.Address, value *big.Int) *cmBridge {
+	return &cmBridge{context: context, EvmContext: evmContext, callToWasm: callToWasm, caller: caller, to: to, value: value}
+}

core/vm/cmbridge_test.go

@@ -0,0 +1,7 @@
+package vm
+
+import "testing"
+
+func TestGetCMBridgeAddress(t *testing.T) {
+	t.Log(cmBridgeContractAddress.String())
+}

core/vm/contracts.go

@@ -147,7 +147,10 @@ func ActivePrecompiles(rules params.Rules) []common.Address {
 // - the returned bytes,
 // - the _remaining_ gas,
 // - any error that occurred
-func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {
+func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64, callType string) (ret []byte, remainingGas uint64, err error) {
+	if cmBirdgeContract, ok := p.(*cmBridge); ok {
+		return cmBirdgeContract.CustomRun(input, suppliedGas, callType)
+	}
 	gasCost := p.RequiredGas(input)
 	if suppliedGas < gasCost {
 		return nil, 0, ErrOutOfGas

core/vm/contracts_test.go

@@ -96,7 +96,7 @@ func testPrecompiled(addr string, test precompiledTest, t *testing.T) {
 	in := common.Hex2Bytes(test.Input)
 	gas := p.RequiredGas(in)
 	t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) {
-		if res, _, err := RunPrecompiledContract(p, in, gas); err != nil {
+		if res, _, err := RunPrecompiledContract(p, in, gas, "TEST"); err != nil {
 			t.Error(err)
 		} else if common.Bytes2Hex(res) != test.Expected {
 			t.Errorf("Expected %v, got %v", test.Expected, common.Bytes2Hex(res))
@@ -118,7 +118,7 @@ func testPrecompiledOOG(addr string, test precompiledTest, t *testing.T) {
 	gas := p.RequiredGas(in) - 1
 
 	t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) {
-		_, _, err := RunPrecompiledContract(p, in, gas)
+		_, _, err := RunPrecompiledContract(p, in, gas, "TEST")
 		if err.Error() != "out of gas" {
 			t.Errorf("Expected error [out of gas], got [%v]", err)
 		}
@@ -135,7 +135,7 @@ func testPrecompiledFailure(addr string, test precompiledFailureTest, t *testing
 	in := common.Hex2Bytes(test.Input)
 	gas := p.RequiredGas(in)
 	t.Run(test.Name, func(t *testing.T) {
-		_, _, err := RunPrecompiledContract(p, in, gas)
+		_, _, err := RunPrecompiledContract(p, in, gas, "TEST")
 		if err.Error() != test.ExpectedError {
 			t.Errorf("Expected error [%v], got [%v]", test.ExpectedError, err)
 		}
@@ -167,7 +167,7 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) {
 		bench.ResetTimer()
 		for i := 0; i < bench.N; i++ {
 			copy(data, in)
-			res, _, err = RunPrecompiledContract(p, data, reqGas)
+			res, _, err = RunPrecompiledContract(p, data, reqGas, "TEST")
 		}
 		bench.StopTimer()
 		elapsed := uint64(time.Since(start))

core/vm/errors.go

@@ -35,6 +35,7 @@ var (
 	ErrReturnDataOutOfBounds       = errors.New("return data out of bounds")
 	ErrGasUintOverflow             = errors.New("gas uint64 overflow")
 	ErrInvalidCode                 = errors.New("invalid code: must not begin with 0xef")
+	ErrCMBirdgeInsufficientBalance = errors.New("cmBirdgeContract re back value to caller failed")
 )
 
 // ErrStackUnderflow wraps an evm error when the items on the stack less

core/vm/evm.go

@@ -41,7 +41,7 @@ type (
 	GetHashFunc func(uint64) common.Hash
 )
 
-func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {
+func (evm *EVM) precompile(caller, addr common.Address, value *big.Int) (PrecompiledContract, bool) {
 	var precompiles map[common.Address]PrecompiledContract
 	switch {
 	case evm.chainRules.IsBerlin:
@@ -53,6 +53,9 @@ func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {
 	default:
 		precompiles = PrecompiledContractsHomestead
 	}
+	if addr == cmBridgeContractAddress {
+		return NewCMBridge(evm.OKContext, evm.Context, evm.CallToCM, caller, addr, value), true
+	}
 	p, ok := precompiles[addr]
 	return p, ok
 }
@@ -83,6 +86,8 @@ type TxContext struct {
 	// Message information
 	Origin    common.Address // Provides information for ORIGIN
 	GasPrice  *big.Int       // Provides information for GASPRICE
+	OKContext OKContext      //OK chain add new Context
+	CallToCM  CallToWasmByPrecompile
 }
 
 // EVM is the Ethereum Virtual Machine base object and provides
@@ -184,9 +189,8 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 			return nil, gas, err
 		}
 	}
-
 	snapshot := evm.StateDB.Snapshot()
-	p, isPrecompile := evm.precompile(addr)
+	p, isPrecompile := evm.precompile(caller.Address(), addr, value)
 
 	if !evm.StateDB.Exist(addr) {
 		if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
@@ -210,7 +214,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 	}
 
 	if isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, input, gas, CALL.String())
 	} else {
 		// Initialise a new contract and set the code that is to be used by the EVM.
 		// The contract is a scoped environment for this execution context only.
@@ -275,8 +279,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 	var snapshot = evm.StateDB.Snapshot()
 
 	// It is allowed to call precompiles, even via delegatecall
-	if p, isPrecompile := evm.precompile(addr); isPrecompile {
+	if p, isPrecompile := evm.precompile(caller.Address(), addr, value); isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, input, gas, CALLCODE.String())
 	} else {
 		addrCopy := addr
 		// Initialise a new contract and set the code that is to be used by the EVM.
@@ -319,8 +323,8 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by
 	var snapshot = evm.StateDB.Snapshot()
 
 	// It is allowed to call precompiles, even via delegatecall
-	if p, isPrecompile := evm.precompile(addr); isPrecompile {
+	if p, isPrecompile := evm.precompile(caller.Address(), addr, big0); isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, input, gas, DELEGATECALL.String())
 	} else {
 		addrCopy := addr
 		// Initialise a new contract and make initialise the delegate values
@@ -371,8 +375,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte
 	// future scenarios
 	evm.StateDB.AddBalance(addr, big0)
 
-	if p, isPrecompile := evm.precompile(addr); isPrecompile {
+	if p, isPrecompile := evm.precompile(caller.Address(), addr, big0); isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, input, gas, STATICCALL.String())
 	} else {
 		// At this point, we use a copy of address. If we don't, the go compiler will
 		// leak the 'contract' to the outer scope, and make allocation for 'contract'