Merge branch 'topic/hardfork-v4' into feature/composable-transactions

chain/chainhandle.go

@@ -945,7 +945,7 @@ func executeTx(execCtx context.Context, ccc consensus.ChainConsensusCluster, cdb
 
 	switch txBody.Type {
 	case types.TxType_NORMAL, types.TxType_TRANSFER, types.TxType_CALL, types.TxType_MULTICALL, types.TxType_DEPLOY, types.TxType_REDEPLOY:
-		rv, events, txFee, err = contract.Execute(execCtx, bs, cdb, tx.GetTx(), sender, receiver, bi, preloadService, false)
+		rv, events, txFee, err = contract.Execute(execCtx, bs, cdb, tx.GetTx(), sender, receiver, bi, executionMode, false)
 		sender.SubBalance(txFee)
 	case types.TxType_GOVERNANCE:
 		txFee = new(big.Int).SetUint64(0)

contract/contract.go

@@ -45,7 +45,7 @@ func Execute(
 	tx *types.Tx,
 	sender, receiver *state.AccountState,
 	bi *types.BlockHeaderInfo,
-	preloadService int,
+	executionMode int,
 	isFeeDelegation bool,
 ) (rv string, events []*types.Event, usedFee *big.Int, err error) {
 
@@ -80,11 +80,11 @@ func Execute(
 	}
 
 	// open the contract state
-	var contractState *state.ContractState
+	var contractState *statedb.ContractState
 	if isMultiCall {
-		contractState = state.GetMultiCallState(sender.AccountID(), sender.State())
+		contractState = statedb.GetMultiCallState(sender.ID(), sender.State())
 	} else {
-		contractState, err = state.OpenContractState(receiver.AccountID(), receiver.State(), bs.StateDB)
+		contractState, err = statedb.OpenContractState(receiver.ID(), receiver.State(), bs.StateDB)
 	}
 	if err != nil {
 		return
@@ -102,14 +102,14 @@ func Execute(
 	var ctrFee *big.Int
 
 	// create a new context
-	ctx := NewVmContext(execCtx, bs, cdb, sender, receiver, contractState, sender.ID(), tx.GetHash(), bi, "", true, false, receiver.RP(), executionMode, txAmount, gasLimit, isFeeDelegation)
+	ctx := NewVmContext(execCtx, bs, cdb, sender, receiver, contractState, sender.ID(), tx.GetHash(), bi, "", true, false, receiver.RP(), executionMode, txAmount, gasLimit, isFeeDelegation, isMultiCall)
 
 	// execute the transaction
 	if receiver.IsDeploy() {
 		rv, events, ctrFee, err = Create(contractState, txPayload, receiver.ID(), ctx)
 	} else {
-		// create a new context
-		ctx := NewVmContext(execCtx, bs, cdb, sender, receiver, contractState, sender.ID(), tx.GetHash(), bi, "", true, false, receiver.RP(), preloadService, txAmount, gasLimit, isFeeDelegation, isMultiCall)
+		rv, events, ctrFee, err = Call(contractState, txPayload, receiver.ID(), ctx)
+	}
 
 	// close the trace file
 	if ctx.traceFile != nil {
@@ -144,7 +144,7 @@ func Execute(
 
 	if !isMultiCall {
 		// save the contract state
-		err = state.StageContractState(contractState, bs.StateDB)
+		err = statedb.StageContractState(contractState, bs.StateDB)
 		if err != nil {
 			return "", events, usedFee, err
 		}
@@ -154,92 +154,6 @@ func Execute(
 	return rv, events, usedFee, nil
 }
 
-// send a request to preload an executor for the next tx
-func RequestPreload(bs *state.BlockState, bi *types.BlockHeaderInfo, next, current *types.Tx, preloadService int) {
-	loadReqCh <- &preloadRequest{preloadService, bs, bi, next, current}
-}
-
-// the preloadWorker preloads an executor for the next tx
-func preloadWorker() {
-	// infinite loop
-	for {
-		var err error
-
-		// wait for a preload request
-		request := <-loadReqCh
-		// get the reply channel for this request
-		replyCh := preloaders[request.preloadService].replyCh
-
-		// if there are more than 2 requests waiting for a reply, close the oldest one
-		if len(replyCh) > 2 {
-			select {
-			case preload := <-replyCh:
-				preload.ex.close()
-			default:
-			}
-		}
-
-		bs := request.bs
-		tx := request.next // the tx to preload the executor for
-		txBody := tx.GetBody()
-		recipient := txBody.Recipient
-
-		// only preload an executor for a normal, transfer, call or fee delegation tx
-		if (txBody.Type != types.TxType_NORMAL &&
-			txBody.Type != types.TxType_TRANSFER &&
-			txBody.Type != types.TxType_CALL &&
-			txBody.Type != types.TxType_FEEDELEGATION) ||
-			len(recipient) == 0 {
-			continue
-		}
-
-		// if the tx currently being executed is a redeploy
-		if request.current.GetBody().Type == types.TxType_REDEPLOY {
-			// if the next tx is a call to the redeployed contract
-			currentTxBody := request.current.GetBody()
-			if bytes.Equal(recipient, currentTxBody.Recipient) {
-				// do not preload an executor for a contract that is being redeployed
-				replyCh <- &preloadReply{tx, nil, nil}
-				continue
-			}
-		}
-
-		// get the state of the recipient
-		receiver, err := state.GetAccountState(recipient, bs.StateDB)
-		if err != nil {
-			replyCh <- &preloadReply{tx, nil, err}
-			continue
-		}
-
-		// when deploy and call in same block and not deployed yet
-		if receiver.IsNew() || !receiver.IsContract() {
-			// do not preload an executor for a contract that is not deployed yet
-			replyCh <- &preloadReply{tx, nil, nil}
-			continue
-		}
-
-		// open the contract state
-		contractState, err := state.OpenContractState(receiver.AccountID(), receiver.State(), bs.StateDB)
-		if err != nil {
-			replyCh <- &preloadReply{tx, nil, err}
-			continue
-		}
-
-		// create a new context
-		// FIXME need valid context
-		ctx := NewVmContext(context.Background(), bs, nil, nil, receiver, contractState, txBody.GetAccount(), tx.GetHash(), request.bi, "", false, false, receiver.RP(), request.preloadService, txBody.GetAmountBigInt(), txBody.GetGasLimit(), txBody.Type == types.TxType_FEEDELEGATION, txBody.Type == types.TxType_MULTICALL)
-
-		// load a new executor
-		ex, err := PreloadExecutor(bs, contractState, txBody.Payload, receiver.ID(), ctx)
-		if ex == nil && ctx.traceFile != nil {
-			ctx.traceFile.Close()
-		}
-
-		// send reply with executor
-		replyCh <- &preloadReply{tx, ex, err}
-	}
-}
-
 // check if the tx is valid and if the code should be executed
 func checkExecution(txType types.TxType, amount *big.Int, payloadSize int, version int32, isDeploy, isContract bool) (do_execute bool, err error) {
 

contract/vm.go

@@ -134,24 +134,29 @@ func InitContext(numCtx int) {
 	contexts = make([]*vmContext, maxContext)
 }
 
-func NewVmContext(execCtx context.Context, blockState *state.BlockState, cdb ChainAccessor, sender, receiver *state.AccountState,
-	contractState *statedb.ContractState, senderID, txHash []byte, bi *types.BlockHeaderInfo, node string, confirmed,
-	query bool, rp uint64, executionMode int, amount *big.Int, gasLimit uint64, feeDelegation bool) *vmContext {
-
-func getTraceFile(blkno uint64, tx []byte) *os.File {
-	f, _ := os.OpenFile(fmt.Sprintf("%s%s%d.trace", os.TempDir(), string(os.PathSeparator), blkno), os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
-	if f != nil {
-		_, _ = f.WriteString(fmt.Sprintf("[START TX]: %s\n", base58.Encode(tx)))
-	}
-	return f
-}
-
-func NewVmContext(execCtx context.Context, blockState *state.BlockState, cdb ChainAccessor, sender, receiver *state.AccountState, contractState *state.ContractState, senderID, txHash []byte, bi *types.BlockHeaderInfo, node string, confirmed, query bool, rp uint64, service int, amount *big.Int, gasLimit uint64, feeDelegation bool, isMultiCall bool) *vmContext {
+func NewVmContext(
+	execCtx context.Context,
+	blockState *state.BlockState,
+	cdb ChainAccessor,
+	sender, receiver *state.AccountState,
+	contractState *statedb.ContractState,
+	senderID,
+	txHash []byte,
+	bi *types.BlockHeaderInfo,
+	node string,
+	confirmed, query bool,
+	rp uint64,
+	executionMode int,
+	amount *big.Int,
+	gasLimit uint64,
+	feeDelegation, isMultiCall bool,
+) *vmContext {
 
-	cs := &callState{ctrState: contractState, curState: receiver.State()}
+	csReceiver := &callState{ctrState: contractState, accState: receiver}
+	csSender := &callState{accState: sender}
 
 	ctx := &vmContext{
-		curContract:     newContractInfo(cs, senderID, receiver.ID(), rp, amount),
+		curContract:     newContractInfo(csReceiver, senderID, receiver.ID(), rp, amount),
 		bs:              blockState,
 		cdb:             cdb,
 		origin:          senderID,
@@ -170,9 +175,9 @@ func NewVmContext(execCtx context.Context, blockState *state.BlockState, cdb Cha
 
 	// init call state
 	ctx.callState = make(map[types.AccountID]*callState)
-	ctx.callState[receiver.AccountID()] = cs
+	ctx.callState[receiver.AccountID()] = csReceiver
 	if sender != nil && sender != receiver {
-		ctx.callState[sender.AccountID()] = &callState{curState: sender.State()}
+		ctx.callState[sender.AccountID()] = csSender
 	}
 	if TraceBlockNo != 0 && TraceBlockNo == ctx.blockInfo.No {
 		ctx.traceFile = getTraceFile(ctx.blockInfo.No, txHash)
@@ -748,6 +753,35 @@ func (ce *executor) gas() uint64 {
 	return uint64(C.lua_gasget(ce.L))
 }
 
+func (ce *executor) vmLoadCode(id []byte) {
+	var chunkId *C.char
+	if ce.ctx.blockInfo.ForkVersion >= 3 {
+		chunkId = C.CString("@" + types.EncodeAddress(id))
+	} else {
+		chunkId = C.CString(hex.Encode(id))
+	}
+	defer C.free(unsafe.Pointer(chunkId))
+	if cErrMsg := C.vm_loadbuff(
+		ce.L,
+		(*C.char)(unsafe.Pointer(&ce.code[0])),
+		C.size_t(len(ce.code)),
+		chunkId,
+		ce.ctx.service-C.int(maxContext),
+	); cErrMsg != nil {
+		errMsg := C.GoString(cErrMsg)
+		ce.err = errors.New(errMsg)
+		ctrLgr.Debug().Err(ce.err).Str("contract", types.EncodeAddress(id)).Msg("failed to load code")
+	}
+}
+
+func (ce *executor) vmLoadCall() {
+	if cErrMsg := C.vm_loadcall(ce.L); cErrMsg != nil {
+		errMsg := C.GoString(cErrMsg)
+		ce.err = errors.New(errMsg)
+	}
+	C.luaL_set_service(ce.L, ce.ctx.service)
+}
+
 func getMultiCallInfo(ci *types.CallInfo, payload []byte) error {
 	payload = append([]byte{'['}, payload...)
 	payload = append(payload, ']')
@@ -1189,7 +1223,8 @@ func getCode(contractState *statedb.ContractState, bs *state.BlockState) ([]byte
 	return code, nil
 }
 
-func getContract(contractState *state.ContractState, bs *state.BlockState) []byte {
+func getContract(contractState *statedb.ContractState, bs *state.BlockState) []byte {
+	// the code from multicall is not loaded, because there is no code hash
 	if len(contractState.GetCodeHash()) == 0 {
 		return nil
 	}
@@ -1200,7 +1235,7 @@ func getContract(contractState *state.ContractState, bs *state.BlockState) []byt
 	return luacUtil.LuaCode(code).ByteCode()
 }
 
-func getMultiCallContract(contractState *state.ContractState) []byte {
+func getMultiCallContract(contractState *statedb.ContractState) []byte {
 
 	if multicall_payload == nil {
 		var err error
@@ -1220,7 +1255,7 @@ func getMultiCallContract(contractState *state.ContractState) []byte {
 	return multicall_payload.ByteCode()
 }
 
-func GetABI(contractState *state.ContractState, bs *state.BlockState) (*types.ABI, error) {
+func GetABI(contractState *statedb.ContractState, bs *state.BlockState) (*types.ABI, error) {
 	var abi *types.ABI
 
 	abi = bs.GetABI(contractState.GetAccountID())
@@ -1275,45 +1310,3 @@ func Compile(code string, parent *LState) (luacUtil.LuaCode, error) {
 	}
 	return byteCodeAbi, nil
 }
-
-func vmAutoload(L *LState, funcName string) bool {
-	s := C.CString(funcName)
-	loaded := C.vm_autoload(L, s)
-	C.free(unsafe.Pointer(s))
-	return loaded != C.int(0)
-}
-
-func (ce *executor) vmLoadCode(id []byte) {
-	var chunkId *C.char
-	if ce.ctx.blockInfo.ForkVersion >= 3 {
-		if ce.ctx.isMultiCall {
-			chunkId = C.CString("@multicall")
-		} else {
-			chunkId = C.CString("@" + types.EncodeAddress(id))
-		}
-	} else {
-		chunkId = C.CString(hex.Encode(id))
-	}
-	defer C.free(unsafe.Pointer(chunkId))
-	if cErrMsg := C.vm_loadbuff(
-		ce.L,
-		(*C.char)(unsafe.Pointer(&ce.code[0])),
-		C.size_t(len(ce.code)),
-		chunkId,
-		ce.ctx.service-C.int(maxContext),
-	); cErrMsg != nil {
-		errMsg := C.GoString(cErrMsg)
-		ce.err = errors.New(errMsg)
-		ctrLgr.Debug().Err(ce.err).Str("contract", types.EncodeAddress(id)).Msg("failed to load code")
-	}
-}
-
-func (ce *executor) vmLoadCall() {
-	if cErrMsg := C.vm_loadcall(
-		ce.L,
-	); cErrMsg != nil {
-		errMsg := C.GoString(cErrMsg)
-		ce.err = errors.New(errMsg)
-	}
-	C.luaL_set_service(ce.L, ce.ctx.service)
-}

contract/vm_dummy/vm_dummy.go

@@ -474,11 +474,11 @@ func contractFrame(l luaTxContract, bs *state.BlockState, cdb contract.ChainAcce
 		return err
 	}
 
-	var eContractState *state.ContractState
+	var eContractState *statedb.ContractState
 	if l.isMultiCall() {
-		eContractState = state.GetMultiCallState(creatorId, creatorState.State())
+		eContractState = statedb.GetMultiCallState(l.sender(), creatorState.State())
 	} else {
-		eContractState, err = state.OpenContractState(contractId, contractState.State(), bs.StateDB)
+		eContractState, err = statedb.OpenContractState(l.recipient(), contractState.State(), bs.StateDB)
 	}
 	if err != nil {
 		return err
@@ -503,9 +503,9 @@ func contractFrame(l luaTxContract, bs *state.BlockState, cdb contract.ChainAcce
 		}
 	}
 
-	if contractId != creatorId {
-		creatorState.SubBalance(l.amount())
-		contractState.AddBalance(l.amount())
+	err = state.SendBalance(creatorState, contractState, l.amount())
+	if err != nil {
+		return err
 	}
 
 	rv, events, cFee, err := run(creatorState, contractState, contractId, eContractState)
@@ -633,7 +633,7 @@ func (l *luaTxCall) Fail(expectedErr string) *luaTxCall {
 
 func (l *luaTxCall) run(execCtx context.Context, bs *state.BlockState, bc *DummyChain, bi *types.BlockHeaderInfo, receiptTx db.Transaction) error {
 	err := contractFrame(l, bs, bc, receiptTx,
-		func(sender, contractV *state.AccountState, contractId types.AccountID, eContractState *state.ContractState) (string, []*types.Event, *big.Int, error) {
+		func(sender, contractV *state.AccountState, contractId types.AccountID, eContractState *statedb.ContractState) (string, []*types.Event, *big.Int, error) {
 
 			ctx := contract.NewVmContext(execCtx, bs, bc, sender, contractV, eContractState, sender.ID(), l.Hash(), bi, "", true, false, contractV.State().SqlRecoveryPoint, contract.BlockFactory, l.amount(), math.MaxUint64, l.feeDelegate, l.multiCall)
 
@@ -643,7 +643,7 @@ func (l *luaTxCall) run(execCtx context.Context, bs *state.BlockState, bc *Dummy
 			}
 
 			if !ctx.IsMultiCall() {
-				err = state.StageContractState(eContractState, bs.StateDB)
+				err = statedb.StageContractState(eContractState, bs.StateDB)
 				if err != nil {
 					return "", nil, ctrFee, err
 				}

state/statedb/contract.go

@@ -153,15 +153,17 @@ func (cs *ContractState) cache() *stateBuffer {
 //---------------------------------------------------------------//
 // global functions
 
-func GetMultiCallState(aid types.AccountID, st *types.State) (*ContractState) {
+func GetMultiCallState(id []byte, st *types.State) (*ContractState) {
+	aid := types.ToAccountID(id)
 	res := &ContractState{
 		State:   st,
 		account: aid,
 	}
 	return res
 }
 
-func OpenContractStateAccount(aid types.AccountID, states *statedb.StateDB) (*ContractState, error) {
+func OpenContractStateAccount(id []byte, states *StateDB) (*ContractState, error) {
+	aid := types.ToAccountID(id)
 	st, err := states.GetAccountState(aid)
 	if err != nil {
 		return nil, err