Implement CIP-43: BlockContext(now rename to SysContractCallCtx)

accounts/abi/bind/backends/simulated.go

@@ -607,16 +607,24 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 	// Execute the call.
 	msg := callMsg{call}
 
-	txContext := core.NewEVMTxContext(msg)
-	evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil)
 	// Create a new environment which holds all relevant information
 	// about the transaction and calling mechanisms.
+	txContext := core.NewEVMTxContext(msg)
+	evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil)
 	vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
 	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
-
 	vmRunner := b.blockchain.NewEVMRunner(block.Header(), stateDB)
-
-	return core.NewStateTransition(vmEnv, msg, gasPool, vmRunner).TransitionDb()
+	var sysCtx *core.SysContractCallCtx
+	if b.config.IsEHardfork(block.Number()) {
+		parent := b.blockchain.GetBlockByNumber(block.NumberU64() - 1)
+		sysStateDB, err := b.blockchain.StateAt(parent.Root())
+		if err != nil {
+			return nil, err
+		}
+		sysVmRunner := b.blockchain.NewEVMRunner(block.Header(), sysStateDB)
+		sysCtx = core.NewSysContractCallCtx(sysVmRunner)
+	}
+	return core.NewStateTransition(vmEnv, msg, gasPool, vmRunner, sysCtx).TransitionDb()
 }
 
 // SendTransaction updates the pending block to include the given transaction.

cmd/evm/internal/t8ntool/execution.go

@@ -151,7 +151,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 
 		// FIXME this is broken
 		// (ret []byte, usedGas uint64, failed bool, err error)
-		msgResult, err := core.ApplyMessage(evm, msg, gaspool, nil)
+		msgResult, err := core.ApplyMessage(evm, msg, gaspool, nil, &core.SysContractCallCtx{})
 		if err != nil {
 			statedb.RevertToSnapshot(snapshot)
 			log.Info("rejected tx", "index", i, "hash", tx.Hash(), "from", msg.From(), "error", err)

contracts/gasprice_minimum/gasprice_minimum.go

@@ -27,6 +27,8 @@ import (
 	"github.com/celo-org/celo-blockchain/params"
 )
 
+// Gas price minimum serves as baseFee(EIP1559) after Espresso HF.
+
 var (
 	FallbackGasPriceMinimum *big.Int = big.NewInt(0) // gas price minimum to return if unable to fetch from contract
 	suggestionMultiplier    *big.Int = big.NewInt(5) // The multiplier that we apply to the minimum when suggesting gas price

core/chain_makers.go

@@ -99,14 +99,23 @@ func (b *BlockGen) AddTxWithChain(bc ChainContext, tx *types.Transaction) {
 	b.statedb.Prepare(tx.Hash(), len(b.txs))
 
 	celoMock := testutil.NewCeloMock()
-	receipt, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vm.Config{}, celoMock.Runner)
+
+	receipt, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vm.Config{}, celoMock.Runner, MockSysContractCallCtx())
 	if err != nil {
 		panic(err)
 	}
 	b.txs = append(b.txs, tx)
 	b.receipts = append(b.receipts, receipt)
 }
 
+// MockSysContractCallCtx returns a SysContractCallCtx mock.
+func MockSysContractCallCtx() *SysContractCallCtx {
+	return &SysContractCallCtx{
+		// Set common.ZeroAddress to non-zero value to test on proper base fee distribution
+		gasPriceMinimums: map[common.Address]*big.Int{common.ZeroAddress: common.Big3},
+	}
+}
+
 // GetBalance returns the balance of the given address at the generated block.
 func (b *BlockGen) GetBalance(addr common.Address) *big.Int {
 	return b.statedb.GetBalance(addr)

core/error.go

@@ -70,10 +70,6 @@ var (
 	// minimum specified by the GasPriceMinimum contract.
 	ErrGasPriceDoesNotExceedMinimum = errors.New("gasprice is less than gas price minimum")
 
-	// ErrInsufficientFundsForFees is returned if the account does have enough funds (in the
-	// fee currency used for the transaction) to pay for the gas.
-	ErrInsufficientFundsForFees = errors.New("insufficient funds to pay for fees")
-
 	// ErrNonWhitelistedFeeCurrency is returned if the currency specified to use for the fees
 	// isn't one of the currencies whitelisted for that purpose.
 	ErrNonWhitelistedFeeCurrency = errors.New("non-whitelisted fee currency address")

core/state_prefetcher.go

@@ -55,17 +55,25 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
 		header   = block.Header()
 		vmRunner = p.bc.NewEVMRunner(header, statedb)
 		gaspool  = new(GasPool).AddGas(blockchain_parameters.GetBlockGasLimitOrDefault(vmRunner))
-		baseFee  *big.Int // TODO: gas price minimum
+		baseFee  *big.Int
+		sysCtx   *SysContractCallCtx
 	)
 	// Iterate over and process the individual transactions
 	byzantium := p.config.IsByzantium(block.Number())
+	espresso := p.bc.chainConfig.IsEHardfork(block.Number())
+	if espresso {
+		sysCtx = NewSysContractCallCtx(p.bc.NewEVMRunner(header, statedb))
+	}
 	for i, tx := range block.Transactions() {
 		// If block precaching was interrupted, abort
 		if interrupt != nil && atomic.LoadUint32(interrupt) == 1 {
 			return
 		}
 		// Block precaching permitted to continue, execute the transaction
 		statedb.Prepare(tx.Hash(), i)
+		if espresso {
+			baseFee = sysCtx.GetGasPriceMinimum(tx.FeeCurrency())
+		}
 		if err := precacheTransaction(p.config, p.bc, nil, gaspool, statedb, header, tx, cfg, baseFee); err != nil {
 			return // Ugh, something went horribly wrong, bail out
 		}
@@ -94,6 +102,11 @@ func precacheTransaction(config *params.ChainConfig, bc *BlockChain, author *com
 	txContext := NewEVMTxContext(msg)
 	vm := vm.NewEVM(context, txContext, statedb, config, cfg)
 
-	_, err = ApplyMessage(vm, msg, gaspool, bc.NewEVMRunner(header, statedb))
+	var sysCtx *SysContractCallCtx
+	if config.IsEHardfork(header.Number) {
+		sysVmRunner := bc.NewEVMRunner(header, statedb)
+		sysCtx = NewSysContractCallCtx(sysVmRunner)
+	}
+	_, err = ApplyMessage(vm, msg, gaspool, bc.NewEVMRunner(header, statedb), sysCtx)
 	return err
 }

core/state_processor.go

@@ -81,17 +81,30 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		statedb.IntermediateRoot(true)
 	}
 
+	var (
+		baseFee *big.Int
+		sysCtx  *SysContractCallCtx
+	)
+	if p.bc.Config().IsEHardfork(blockNumber) {
+		sysVmRunner := p.bc.NewEVMRunner(header, statedb)
+		sysCtx = NewSysContractCallCtx(sysVmRunner)
+		if p.bc.Config().Faker {
+			sysCtx = MockSysContractCallCtx()
+		}
+	}
 	blockContext := NewEVMBlockContext(header, p.bc, nil)
-	var gpm *big.Int // collect basefee from blockContext or somewhere else
 	vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
-		msg, err := tx.AsMessage(types.MakeSigner(p.config, header.Number), gpm)
+		if p.bc.chainConfig.IsEHardfork(header.Number) {
+			baseFee = sysCtx.GetGasPriceMinimum(tx.FeeCurrency())
+		}
+		msg, err := tx.AsMessage(types.MakeSigner(p.config, header.Number), baseFee)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
 		}
 		statedb.Prepare(tx.Hash(), i)
-		receipt, err := applyTransaction(msg, p.config, p.bc, nil, gp, statedb, blockNumber, blockHash, tx, usedGas, vmenv, vmRunner)
+		receipt, err := applyTransaction(msg, p.config, gp, statedb, blockNumber, blockHash, tx, usedGas, vmenv, vmRunner, sysCtx)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
 		}
@@ -107,7 +120,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	return receipts, allLogs, *usedGas, nil
 }
 
-func applyTransaction(msg types.Message, config *params.ChainConfig, bc ChainContext, txFeeRecipient *common.Address, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM, vmRunner vm.EVMRunner) (*types.Receipt, error) {
+func applyTransaction(msg types.Message, config *params.ChainConfig, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM, vmRunner vm.EVMRunner, sysCtx *SysContractCallCtx) (*types.Receipt, error) {
 	if config.IsDonut(blockNumber) && !tx.Protected() {
 		return nil, ErrUnprotectedTransaction
 	}
@@ -117,7 +130,7 @@ func applyTransaction(msg types.Message, config *params.ChainConfig, bc ChainCon
 	evm.Reset(txContext, statedb)
 
 	// Apply the transaction to the current state (included in the env).
-	result, err := ApplyMessage(evm, msg, gp, vmRunner)
+	result, err := ApplyMessage(evm, msg, gp, vmRunner, sysCtx)
 	if err != nil {
 		return nil, err
 	}
@@ -160,14 +173,17 @@ func applyTransaction(msg types.Message, config *params.ChainConfig, bc ChainCon
 // 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.
-func ApplyTransaction(config *params.ChainConfig, bc ChainContext, txFeeRecipient *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, vmRunner vm.EVMRunner) (*types.Receipt, error) {
-	// TODO(Joshua): Set appropriate GPM/basefee here
-	msg, err := tx.AsMessage(types.MakeSigner(config, header.Number), nil)
+func ApplyTransaction(config *params.ChainConfig, bc ChainContext, txFeeRecipient *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, vmRunner vm.EVMRunner, sysCtx *SysContractCallCtx) (*types.Receipt, error) {
+	var baseFee *big.Int
+	if config.IsEHardfork(header.Number) {
+		baseFee = sysCtx.GetGasPriceMinimum(tx.FeeCurrency())
+	}
+	msg, err := tx.AsMessage(types.MakeSigner(config, header.Number), baseFee)
 	if err != nil {
 		return nil, err
 	}
 	// Create a new context to be used in the EVM environment
 	blockContext := NewEVMBlockContext(header, bc, txFeeRecipient)
 	vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, config, cfg)
-	return applyTransaction(msg, config, bc, txFeeRecipient, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv, vmRunner)
+	return applyTransaction(msg, config, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv, vmRunner, sysCtx)
 }