Function ApplyTransaction

core/state_processor.go:113–176

ApplyTransaction attempts to apply a transaction to the given state database and uses the input parameters for its environment. It returns the receipt for the transaction, gas used and an error if the transaction failed, indicating the block was invalid.

(config *configs.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, pubStateDb *state.StateDB,
	privateStateDb *state.StateDB, remoteDB database.RemoteDatabase, header *types.Header, tx *types.Transaction, usedGas *uint64,
	cfg vm.Config, accm *accounts.Manager)

// for the transaction, gas used and an error if the transaction failed,
// indicating the block was invalid.
func ApplyTransaction(config *configs.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, pubStateDb *state.StateDB,
	privateStateDb *state.StateDB, remoteDB database.RemoteDatabase, header *types.Header, tx *types.Transaction, usedGas *uint64,
	cfg vm.Config, accm *accounts.Manager) (*types.Receipt, *types.Receipt, uint64, error) {
	msg, err := tx.AsMessage(types.MakeSigner(config))
	if err != nil {
		return nil, nil, 0, err
	}

	// if the tx type is not supported, return early
	if !types.SupportTxType(tx.Type()) {
		return nil, nil, 0, types.ErrNotSupportedTxType
	}

	// this is for sanitize, may be useful later. for now, its useless because it already returned
	if !tx.IsBasic() {
		msg.SetData([]byte{})
	}

	// Create a new context to be used in the EVM environment
	context := NewEVMContext(msg, header, bc, author)
	// Create a new environment which holds all relevant information
	// about the transaction and calling mechanisms.
	vmenv := vm.NewEVM(context, pubStateDb, config, cfg)
	// Apply the transaction to the current state (included in the env)
	_, gas, failed, err := ApplyMessage(vmenv, msg, gp)
	if err != nil {
		return nil, nil, 0, err
	}
	pubStateDb.Finalise(true)
	*usedGas += gas

	// Create a new pubReceipt for the transaction, storing the intermediate root and gas used by the tx
	// based on the eip phase, we're passing whether the root touch-delete accounts.
	pubReceipt := types.NewReceipt([]byte{}, failed, *usedGas)
	pubReceipt.TxHash = tx.Hash()
	pubReceipt.GasUsed = gas
	// if the transaction created a contract, store the creation address in the pubReceipt.
	if msg.To() == nil {
		pubReceipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce())
	}
	// Set the pubReceipt logs and create a bloom for filtering
	pubReceipt.Logs = pubStateDb.GetLogs(tx.Hash())
	pubReceipt.Bloom = types.CreateBloom(types.Receipts{pubReceipt})

	var privReceipt *types.Receipt
	// For private tx, it should process its real private tx payload in participant's node. If account manager is nil,
	// doesn't process private tx. If the node does not support private transaction, skip it.
	if tx.IsPrivate() && accm != nil && types.SupportTxType(tx.Type()) {

		// for now, it's impossible to enter here
		privReceipt, err = tryApplyPrivateTx(config, bc, author, gp, privateStateDb, remoteDB, header, tx, cfg, accm)
		if err != nil {
			if err == NoPermissionError {
				log.Info("No permission to process the transaction.")
				return pubReceipt, privReceipt, gas, nil
			} else {
				log.Error("Cannot process the transaction.", err)
				return pubReceipt, privReceipt, 0, err