[Flow EVM] smart contract deployment for COAs

fvm/evm/emulator/emulator.go

@@ -8,6 +8,7 @@ import (
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
 	gethVM "github.com/ethereum/go-ethereum/core/vm"
 	gethCrypto "github.com/ethereum/go-ethereum/crypto"
+	gethParams "github.com/ethereum/go-ethereum/params"
 	"github.com/onflow/atree"
 
 	"github.com/onflow/flow-go/fvm/evm/emulator/state"
@@ -73,14 +74,19 @@ func (bv *ReadOnlyBlockView) BalanceOf(address types.Address) (*big.Int, error)
 	return bv.state.GetBalance(address.ToCommon()), nil
 }
 
+// NonceOf returns the nonce of the given address
+func (bv *ReadOnlyBlockView) NonceOf(address types.Address) (uint64, error) {
+	return bv.state.GetNonce(address.ToCommon()), nil
+}
+
 // CodeOf returns the code of the given address
 func (bv *ReadOnlyBlockView) CodeOf(address types.Address) (types.Code, error) {
 	return bv.state.GetCode(address.ToCommon()), nil
 }
 
-// NonceOf returns the nonce of the given address
-func (bv *ReadOnlyBlockView) NonceOf(address types.Address) (uint64, error) {
-	return bv.state.GetNonce(address.ToCommon()), nil
+// CodeHashOf returns the code hash of the given address
+func (bv *ReadOnlyBlockView) CodeHashOf(address types.Address) ([]byte, error) {
+	return bv.state.GetCodeHash(address.ToCommon()).Bytes(), nil
 }
 
 // BlockView allows mutation of the evm state as part of a block
@@ -99,16 +105,19 @@ func (bl *BlockView) DirectCall(call *types.DirectCall) (*types.Result, error) {
 	if err != nil {
 		return nil, err
 	}
-	var res *types.Result
 	switch call.SubType {
 	case types.DepositCallSubType:
-		res, err = proc.mintTo(call.To, call.Value)
+		return proc.mintTo(call.To, call.Value)
 	case types.WithdrawCallSubType:
-		res, err = proc.withdrawFrom(call.From, call.Value)
+		return proc.withdrawFrom(call.From, call.Value)
+	case types.DeployCallSubType:
+		if !call.EmptyToField() {
+			return proc.deployAt(call.From, call.To, call.Data, call.GasLimit, call.Value)
+		}
+		fallthrough
 	default:
-		res, err = proc.run(call.Message(), types.DirectCallTxType)
+		return proc.runDirect(call.Message(), types.DirectCallTxType)
 	}
-	return res, err
 }
 
 // RunTransaction runs an evm transaction
@@ -205,12 +214,9 @@ func (proc *procedure) withdrawFrom(address types.Address, amount *big.Int) (*ty
 	}
 
 	// check if account exists
-	// while this method is only called from bridged accounts
-	// it might be the case that someone creates a bridged account
+	// while this method is only called for COAs
+	// it might be the case that someone creates a COA
 	// and never transfer tokens to and call for withdraw
-	// TODO: we might revisit this apporach and
-	// 		return res, types.ErrAccountDoesNotExist
-	// instead
 	if !proc.state.Exist(addr) {
 		proc.state.CreateAccount(addr)
 	}
@@ -232,6 +238,121 @@ func (proc *procedure) withdrawFrom(address types.Address, amount *big.Int) (*ty
 	return res, proc.commit()
 }
 
+// deployAt deploys a contract at the given target address
+// behaviour should be similar to what evm.create internal method does with
+// a few differences, don't need to check for previous forks given this
+// functionality was not available to anyone, we don't need to
+// follow snapshoting, given we do commit/revert style in this code base.
+// in the future we might optimize this method accepting deploy-ready byte codes
+// and skip interpreter call, gas calculations and many checks.
+func (proc *procedure) deployAt(
+	caller types.Address,
+	to types.Address,
+	data types.Code,
+	gasLimit uint64,
+	value *big.Int,
+) (*types.Result, error) {
+	res := &types.Result{
+		TxType: types.DirectCallTxType,
+	}
+	addr := to.ToCommon()
+
+	// precheck 1 - check balance of the source
+	if value.Sign() != 0 &&
+		!proc.evm.Context.CanTransfer(proc.state, caller.ToCommon(), value) {
+		return res, gethVM.ErrInsufficientBalance
+	}
+
+	// precheck 2 - ensure there's no existing contract is deployed at the address
+	contractHash := proc.state.GetCodeHash(addr)
+	if proc.state.GetNonce(addr) != 0 ||
+		(contractHash != (gethCommon.Hash{}) && contractHash != gethTypes.EmptyCodeHash) {
+		return res, gethVM.ErrContractAddressCollision
+	}
+
+	callerCommon := caller.ToCommon()
+	// setup caller if doesn't exist
+	if !proc.state.Exist(callerCommon) {
+		proc.state.CreateAccount(callerCommon)
+	}
+	// increment the nonce for the caller
+	proc.state.SetNonce(callerCommon, proc.state.GetNonce(callerCommon)+1)
+
+	// setup account
+	proc.state.CreateAccount(addr)
+	proc.state.SetNonce(addr, 1) // (EIP-158)
+	proc.evm.Context.Transfer(   // transfer value
+		proc.state,
+		caller.ToCommon(),
+		addr,
+		value,
+	)
+
+	// run code through interpreter
+	// this would check for errors and computes the final bytes to be stored under account
+	var err error
+	inter := gethVM.NewEVMInterpreter(proc.evm)
+	contract := gethVM.NewContract(
+		gethVM.AccountRef(caller.ToCommon()),
+		gethVM.AccountRef(addr),
+		value,
+		gasLimit)
+	contract.Code = data
+	contract.CodeHash = gethCrypto.Keccak256Hash(data)
+	contract.CodeAddr = &addr
+	// update access list (Berlin)
+	proc.state.AddAddressToAccessList(addr)
+
+	ret, err := inter.Run(contract, nil, false)
+	gasCost := uint64(len(ret)) * gethParams.CreateDataGas
+	res.GasConsumed = gasCost
+
+	// handle errors
+	if err != nil {
+		// for all errors except this one consume all the remaining gas (Homestead)
+		if err != gethVM.ErrExecutionReverted {
+			res.GasConsumed = gasLimit
+		}
+		res.Failed = true
+		return res, err
+	}
+
+	// update gas usage
+	if gasCost > gasLimit {
+		// consume all the remaining gas (Homestead)
+		res.GasConsumed = gasLimit
+		res.Failed = true
+		return res, gethVM.ErrCodeStoreOutOfGas
+	}
+
+	// check max code size (EIP-158)
+	if len(ret) > gethParams.MaxCodeSize {
+		// consume all the remaining gas (Homestead)
+		res.GasConsumed = gasLimit
+		res.Failed = true
+		return res, gethVM.ErrMaxCodeSizeExceeded
+	}
+
+	// reject code starting with 0xEF (EIP-3541)
+	if len(ret) >= 1 && ret[0] == 0xEF {
+		// consume all the remaining gas (Homestead)
+		res.GasConsumed = gasLimit
+		res.Failed = true
+		return res, gethVM.ErrInvalidCode
+	}
+
+	proc.state.SetCode(addr, ret)
+	res.DeployedContractAddress = to
+	return res, proc.commit()
+}
+
+func (proc *procedure) runDirect(msg *gethCore.Message, txType uint8) (*types.Result, error) {
+	// set the nonce for the message (needed for some opeartions like deployment)
+	msg.Nonce = proc.state.GetNonce(msg.From)
+	proc.evm.TxContext.Origin = msg.From
+	return proc.run(msg, types.DirectCallTxType)
+}
+
 func (proc *procedure) run(msg *gethCore.Message, txType uint8) (*types.Result, error) {
 	res := types.Result{
 		TxType: txType,

fvm/evm/emulator/emulator_test.go

@@ -1,12 +1,14 @@
 package emulator_test
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 	"testing"
 
 	gethCommon "github.com/ethereum/go-ethereum/common"
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
+	gethVM "github.com/ethereum/go-ethereum/core/vm"
 	gethParams "github.com/ethereum/go-ethereum/params"
 	"github.com/stretchr/testify/require"
 
@@ -285,7 +287,81 @@ func TestContractInteraction(t *testing.T) {
 					require.True(t, types.IsEVMValidationError(err))
 				})
 			})
+		})
+	})
+}
+
+func TestDeployAtFunctionality(t *testing.T) {
+	testutils.RunWithTestBackend(t, func(backend *testutils.TestBackend) {
+		testutils.RunWithTestFlowEVMRootAddress(t, backend, func(rootAddr flow.Address) {
+			testContract := testutils.GetStorageTestContract(t)
+			testAccount := types.NewAddressFromString("test")
+			amount := big.NewInt(0).Mul(big.NewInt(1337), big.NewInt(gethParams.Ether))
+			amountToBeTransfered := big.NewInt(0).Mul(big.NewInt(100), big.NewInt(gethParams.Ether))
 
+			// fund test account
+			RunWithNewEmulator(t, backend, rootAddr, func(env *emulator.Emulator) {
+				RunWithNewBlockView(t, env, func(blk types.BlockView) {
+					_, err := blk.DirectCall(types.NewDepositCall(testAccount, amount))
+					require.NoError(t, err)
+				})
+			})
+
+			t.Run("deploy contract at target address", func(t *testing.T) {
+				RunWithNewEmulator(t, backend, rootAddr, func(env *emulator.Emulator) {
+					target := types.Address{1, 2, 3}
+					RunWithNewBlockView(t, env, func(blk types.BlockView) {
+						res, err := blk.DirectCall(
+							types.NewDeployCallWithTargetAddress(
+								testAccount,
+								target,
+								testContract.ByteCode,
+								math.MaxUint64,
+								amountToBeTransfered),
+						)
+						require.NoError(t, err)
+						require.Equal(t, target, res.DeployedContractAddress)
+					})
+					RunWithNewReadOnlyBlockView(t, env, func(blk types.ReadOnlyBlockView) {
+						require.NotNil(t, target)
+						retCode, err := blk.CodeOf(target)
+						require.NoError(t, err)
+						require.NotEmpty(t, retCode)
+
+						retBalance, err := blk.BalanceOf(target)
+						require.NoError(t, err)
+						require.Equal(t, amountToBeTransfered, retBalance)
+
+						retBalance, err = blk.BalanceOf(testAccount)
+						require.NoError(t, err)
+						require.Equal(t, amount.Sub(amount, amountToBeTransfered), retBalance)
+					})
+					// test deployment to an address that is already exist
+					RunWithNewBlockView(t, env, func(blk types.BlockView) {
+						_, err := blk.DirectCall(
+							types.NewDeployCallWithTargetAddress(
+								testAccount,
+								target,
+								testContract.ByteCode,
+								math.MaxUint64,
+								amountToBeTransfered),
+						)
+						require.Equal(t, gethVM.ErrContractAddressCollision, err)
+					})
+					// test deployment with not enough gas
+					RunWithNewBlockView(t, env, func(blk types.BlockView) {
+						_, err := blk.DirectCall(
+							types.NewDeployCallWithTargetAddress(
+								testAccount,
+								types.Address{3, 4, 5},
+								testContract.ByteCode,
+								100,
+								new(big.Int)),
+						)
+						require.Equal(t, fmt.Errorf("out of gas"), err)
+					})
+				})
+			})
 		})
 	})
 }

fvm/evm/evm_test.go

@@ -166,7 +166,7 @@ func TestEVMAddressDeposit(t *testing.T) {
 	})
 }
 
-func TestBridgedAccountWithdraw(t *testing.T) {
+func TestCOAWithdraw(t *testing.T) {
 
 	t.Parallel()
 

fvm/evm/handler/addressAllocator.go

@@ -38,6 +38,10 @@ func NewAddressAllocator(led atree.Ledger, flexAddress flow.Address) (*AddressAl
 	}, nil
 }
 
+func (aa *AddressAllocator) COAFactoryAddress() types.Address {
+	return MakeCOAAddress(0)
+}
+
 // AllocateCOAAddress allocates an address for COA
 func (aa *AddressAllocator) AllocateCOAAddress() (types.Address, error) {
 	data, err := aa.led.GetValue(aa.flexAddress[:], []byte(ledgerAddressAllocatorKey))

fvm/evm/handler/addressAllocator_test.go

@@ -13,7 +13,6 @@ import (
 )
 
 func TestAddressAllocator(t *testing.T) {
-
 	testutils.RunWithTestBackend(t, func(backend *testutils.TestBackend) {
 		testutils.RunWithTestFlowEVMRootAddress(t, backend, func(root flow.Address) {
 			aa, err := handler.NewAddressAllocator(backend, root)
@@ -34,8 +33,11 @@ func TestAddressAllocator(t *testing.T) {
 			require.NoError(t, err)
 			expectedAddress = types.NewAddress(gethCommon.HexToAddress("0x0000000000000000000000020000000000000002"))
 			require.Equal(t, expectedAddress, adr)
-		})
 
+			// factory
+			factory := aa.COAFactoryAddress()
+			expectedAddress = types.NewAddress(gethCommon.HexToAddress("0x0000000000000000000000020000000000000000"))
+			require.Equal(t, expectedAddress, factory)
+		})
 	})
-
 }