Enable gas price

consensus/ethash/consensus.go

@@ -624,6 +624,8 @@ var (
 // reward. The total reward consists of the static block reward and rewards for
 // included uncles. The coinbase of each uncle block is also rewarded.
 func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
+
+	// NOTE: this code will be executed for Raft on Quorum, so the static block reward also applies to Raft
 	// Select the correct block reward based on chain progression
 	blockReward := FrontierBlockReward
 	if config.IsByzantium(header.Number) {
@@ -632,6 +634,7 @@ func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header
 	if config.IsConstantinople(header.Number) {
 		blockReward = ConstantinopleBlockReward
 	}
+
 	// Accumulate the rewards for the miner and any included uncles
 	reward := new(big.Int).Set(blockReward)
 	r := new(big.Int)

core/blockchain.go

@@ -30,7 +30,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/common/mclock"
 	"github.com/ethereum/go-ethereum/common/prque"
 	"github.com/ethereum/go-ethereum/consensus"
@@ -727,11 +726,7 @@ func (bc *BlockChain) GasLimit() uint64 {
 	bc.chainmu.RLock()
 	defer bc.chainmu.RUnlock()
 
-	if bc.Config().IsQuorum {
-		return math.MaxBig256.Uint64() // HACK(joel) a very large number
-	} else {
-		return bc.CurrentBlock().GasLimit()
-	}
+	return bc.CurrentBlock().GasLimit()
 }
 
 // CurrentBlock retrieves the current head block of the canonical chain. The

core/chain_makers.go

@@ -114,7 +114,7 @@ func (b *BlockGen) AddTxWithChain(bc *BlockChain, tx *types.Transaction) {
 	}
 	// End Quorum
 
-	receipt, _, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, privateDb, b.header, tx, &b.header.GasUsed, vm.Config{}, false, nil)
+	receipt, _, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, privateDb, b.header, tx, &b.header.GasUsed, vm.Config{}, false, nil, false)
 	if err != nil {
 		panic(err)
 	}

core/state_processor.go

@@ -84,7 +84,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, pri
 	blockContext := NewEVMBlockContext(header, p.bc, nil)
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
-		mpsReceipt, err := handleMPS(i, tx, gp, usedGas, cfg, statedb, privateStateRepo, p.config, p.bc, header, false)
+		mpsReceipt, err := handleMPS(i, tx, gp, usedGas, cfg, statedb, privateStateRepo, p.config, p.bc, header, false, false)
 		if err != nil {
 			return nil, nil, nil, 0, err
 		}
@@ -112,7 +112,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, pri
 			}
 		}
 
-		if p.config.IsQuorum && tx.GasPrice() != nil && tx.GasPrice().Cmp(common.Big0) > 0 {
+		if p.config.IsQuorum && !p.config.IsGasEnabled(header.Number) && tx.GasPrice() != nil && tx.GasPrice().Cmp(common.Big0) > 0 {
 			return nil, nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), ErrInvalidGasPrice)
 		}
 
@@ -207,7 +207,7 @@ func PrivateStateDBForTxn(isQuorum bool, tx *types.Transaction, stateDb, private
 // handling MPS scenario for a private transaction
 //
 // handleMPS returns the auxiliary receipt and not the standard receipt
-func handleMPS(ti int, tx *types.Transaction, gp *GasPool, usedGas *uint64, cfg vm.Config, statedb *state.StateDB, privateStateRepo mps.PrivateStateRepository, config *params.ChainConfig, bc ChainContext, header *types.Header, applyOnPartiesOnly bool) (mpsReceipt *types.Receipt, err error) {
+func handleMPS(ti int, tx *types.Transaction, gp *GasPool, usedGas *uint64, cfg vm.Config, statedb *state.StateDB, privateStateRepo mps.PrivateStateRepository, config *params.ChainConfig, bc ChainContext, header *types.Header, applyOnPartiesOnly bool, isInnerPrivateTxn bool) (mpsReceipt *types.Receipt, err error) {
 	if tx.IsPrivate() && privateStateRepo != nil && privateStateRepo.IsMPS() {
 		publicStateDBFactory := func() *state.StateDB {
 			db := statedb.Copy()
@@ -222,7 +222,7 @@ func handleMPS(ti int, tx *types.Transaction, gp *GasPool, usedGas *uint64, cfg
 			db.Prepare(tx.Hash(), header.Hash(), ti)
 			return db, nil
 		}
-		mpsReceipt, err = ApplyTransactionOnMPS(config, bc, nil, gp, publicStateDBFactory, privateStateDBFactory, header, tx, usedGas, cfg, privateStateRepo, applyOnPartiesOnly)
+		mpsReceipt, err = ApplyTransactionOnMPS(config, bc, nil, gp, publicStateDBFactory, privateStateDBFactory, header, tx, usedGas, cfg, privateStateRepo, applyOnPartiesOnly, isInnerPrivateTxn)
 	}
 	return
 }
@@ -239,7 +239,8 @@ func handleMPS(ti int, tx *types.Transaction, gp *GasPool, usedGas *uint64, cfg
 // The originalGP gas pool will not be modified
 func ApplyTransactionOnMPS(config *params.ChainConfig, bc ChainContext, author *common.Address, originalGP *GasPool,
 	publicStateDBFactory func() *state.StateDB, privateStateDBFactory func(psi types.PrivateStateIdentifier) (*state.StateDB, error),
-	header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, privateStateRepo mps.PrivateStateRepository, applyOnPartiesOnly bool) (*types.Receipt, error) {
+	header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, privateStateRepo mps.PrivateStateRepository,
+	applyOnPartiesOnly bool, isInnerPrivateTxn bool) (*types.Receipt, error) {
 
 	mpsReceipt := &types.Receipt{
 		QuorumReceiptExtraData: types.QuorumReceiptExtraData{
@@ -278,7 +279,7 @@ func ApplyTransactionOnMPS(config *params.ChainConfig, bc ChainContext, author *
 		// use a clone of the gas pool (as we don't want to consume gas multiple times for each MPS execution, which might blow the block gasLimit on MPS node)
 		gp := new(GasPool).AddGas(originalGP.Gas())
 
-		_, privateReceipt, err := ApplyTransaction(config, bc, author, gp, publicStateDB, privateStateDB, header, tx, usedGas, cfg, !applyAsParty, privateStateRepo)
+		_, privateReceipt, err := ApplyTransaction(config, bc, author, gp, publicStateDB, privateStateDB, header, tx, usedGas, cfg, !applyAsParty, privateStateRepo, isInnerPrivateTxn)
 		if err != nil {
 			return nil, err
 		}
@@ -399,7 +400,7 @@ 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, author *common.Address, gp *GasPool, statedb, privateStateDB *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, forceNonParty bool, privateStateRepo mps.PrivateStateRepository) (*types.Receipt, *types.Receipt, error) {
+func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb, privateStateDB *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, forceNonParty bool, privateStateRepo mps.PrivateStateRepository, isInnerPrivateTxn bool) (*types.Receipt, *types.Receipt, error) {
 	// Quorum - decide the privateStateDB to use
 	privateStateDbToUse := PrivateStateDBForTxn(config.IsQuorum, tx, statedb, privateStateDB)
 	// End Quorum
@@ -411,7 +412,7 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
 		}
 	}
 
-	if config.IsQuorum && tx.GasPrice() != nil && tx.GasPrice().Cmp(common.Big0) > 0 {
+	if config.IsQuorum && !config.IsGasEnabled(header.Number) && tx.GasPrice() != nil && tx.GasPrice().Cmp(common.Big0) > 0 {
 		return nil, nil, ErrInvalidGasPrice
 	}
 
@@ -421,6 +422,8 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
 	}
 	// Quorum: this tx needs to be applied as if we were not a party
 	msg = msg.WithEmptyPrivateData(forceNonParty && tx.IsPrivate())
+	// Quorum: if this is the inner private txn of a PMT then need to indicate this
+	msg = msg.WithInnerPrivateFlag(isInnerPrivateTxn)
 
 	// Create a new context to be used in the EVM environment
 	blockContext := NewEVMBlockContext(header, bc, author)
@@ -450,7 +453,7 @@ func ApplyInnerTransaction(bc ChainContext, author *common.Address, gp *GasPool,
 	singleUseGasPool := new(GasPool).AddGas(innerTx.Gas())
 
 	if privateStateRepo != nil && privateStateRepo.IsMPS() {
-		mpsReceipt, err := handleMPS(txIndex, innerTx, singleUseGasPool, usedGas, evmConf, stateDB, privateStateRepo, bc.Config(), bc, header, true)
+		mpsReceipt, err := handleMPS(txIndex, innerTx, singleUseGasPool, usedGas, evmConf, stateDB, privateStateRepo, bc.Config(), bc, header, true, true)
 		if err != nil {
 			return err
 		}
@@ -464,7 +467,7 @@ func ApplyInnerTransaction(bc ChainContext, author *common.Address, gp *GasPool,
 	prepareStates(innerTx, stateDB, privateStateDB, txIndex)
 
 	used := uint64(0)
-	_, innerPrivateReceipt, err := ApplyTransaction(bc.Config(), bc, author, singleUseGasPool, stateDB, privateStateDB, header, innerTx, &used, evmConf, forceNonParty, privateStateRepo)
+	_, innerPrivateReceipt, err := ApplyTransaction(bc.Config(), bc, author, singleUseGasPool, stateDB, privateStateDB, header, innerTx, &used, evmConf, forceNonParty, privateStateRepo, true)
 	if err != nil {
 		return err
 	}

core/state_transition.go

@@ -115,6 +115,7 @@ func (result *ExecutionResult) Revert() []byte {
 type PrivateMessage interface {
 	Message
 	IsPrivate() bool
+	IsInnerPrivate() bool
 }
 
 // IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
@@ -352,7 +353,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 		} else {
 			to = st.to()
 		}
-		//if input is empty for the smart contract call, return
+		//if input is empty for the smart contract call, return (refunding any gas deducted)
 		if len(data) == 0 && isPrivate {
 			st.refundGas()
 			st.state.AddBalance(st.evm.Context.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))
@@ -422,12 +423,20 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 }
 
 func (st *StateTransition) refundGas() {
-	// Apply refund counter, capped to half of the used gas.
-	refund := st.gasUsed() / 2
-	if refund > st.state.GetRefund() {
-		refund = st.state.GetRefund()
+	// Quorum
+	if msg, ok := st.msg.(PrivateMessage); ok && msg.IsInnerPrivate() {
+		// Quorum
+		// This is the inner private transaction of a PMT, need to ensure that ALL gas is refunded to prevent
+		// a mismatch between a (non-participant) minter and (participant) validator.
+		st.gas += st.gasUsed()
+	} else { // run original code
+		// Apply refund counter, capped to half of the used gas.
+		refund := st.gasUsed() / 2
+		if refund > st.state.GetRefund() {
+			refund = st.state.GetRefund()
+		}
+		st.gas += refund
 	}
-	st.gas += refund
 
 	// Return ETH for remaining gas, exchanged at the original rate.
 	remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)

core/tx_pool.go

@@ -88,6 +88,8 @@ var (
 	// making the transaction invalid, rather a DOS protection.
 	ErrOversizedData = errors.New("oversized data")
 
+	// ErrInvalidGasPrice is returned if gas price is disabled, but a gas price
+	// is specified in the transaction
 	ErrInvalidGasPrice = errors.New("Gas price not 0")
 
 	// ErrEtherValueUnsupported is returned if a transaction specifies an Ether Value
@@ -441,6 +443,13 @@ func (pool *TxPool) GasPrice() *big.Int {
 // SetGasPrice updates the minimum price required by the transaction pool for a
 // new transaction, and drops all transactions below this threshold.
 func (pool *TxPool) SetGasPrice(price *big.Int) {
+	//Quorum
+	if pool.chainconfig.IsQuorum && !pool.chainconfig.IsGasEnabled(pool.chain.CurrentBlock().Header().Number) {
+		log.Info("Transaction pool price threshold not updated as gasPrice is not enabled")
+		return
+	}
+	//End-Quorum
+
 	pool.mu.Lock()
 	defer pool.mu.Unlock()
 
@@ -581,8 +590,9 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 			}
 		}
 
-		// Gas price must be zero for Quorum transaction
-		if tx.GasPriceIntCmp(common.Big0) != 0 {
+		// Quorum
+		// Reject transaction if gas price is disabled, but gas price is specified
+		if (!pool.chainconfig.IsGasEnabled(pool.chain.CurrentBlock().Header().Number)) && tx.GasPriceIntCmp(common.Big0) != 0 {
 			return ErrInvalidGasPrice
 		}
 		// Ether value is not currently supported on private transactions
@@ -593,9 +603,10 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		if err := pcore.CheckAccountPermission(tx.From(), tx.To(), tx.Value(), tx.Data(), tx.Gas(), tx.GasPrice()); err != nil {
 			return err
 		}
-	} else {
+	}
+	if !pool.chainconfig.IsQuorum || pool.chainconfig.IsGasEnabled(pool.chain.CurrentBlock().Header().Number) {
 		// Drop non-local transactions under our own minimal accepted gas price
-		local = local || pool.locals.contains(from) // Quorum: account may be local even if the transaction arrived from the network
+		local = local || pool.locals.contains(from)
 		if !local && tx.GasPriceIntCmp(pool.gasPrice) < 0 {
 			return ErrUnderpriced
 		}
@@ -648,7 +659,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 	// If the transaction pool is full, discard underpriced transactions
 	if uint64(pool.all.Count()+numSlots(tx)) > pool.config.GlobalSlots+pool.config.GlobalQueue {
 		// If the new transaction is underpriced, don't accept it
-		if !pool.chainconfig.IsQuorum && !isLocal && pool.priced.Underpriced(tx) {
+		if (!pool.chainconfig.IsQuorum || pool.chainconfig.IsGasEnabled(pool.chain.CurrentBlock().Header().Number)) && !isLocal && pool.priced.Underpriced(tx) {
 			log.Trace("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice())
 			underpricedTxMeter.Mark(1)
 			return false, ErrUnderpriced
@@ -1284,7 +1295,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Trans
 		}
 		log.Trace("Removed old queued transactions", "count", len(forwards))
 		var drops types.Transactions
-		if !isQuorum {
+		if !pool.chainconfig.IsQuorum || pool.chainconfig.IsGasEnabled(pool.chain.CurrentBlock().Header().Number) {
 			// Drop all transactions that are too costly (low balance or out of gas)
 			drops, _ = list.Filter(pool.currentState.GetBalance(addr), pool.currentMaxGas)
 			for _, tx := range drops {

core/types/transaction.go

@@ -489,16 +489,17 @@ func (t *TransactionsByPriceAndNonce) Pop() {
 //
 // NOTE: In a future PR this will be removed.
 type Message struct {
-	to         *common.Address
-	from       common.Address
-	nonce      uint64
-	amount     *big.Int
-	gasLimit   uint64
-	gasPrice   *big.Int
-	data       []byte
-	accessList AccessList
-	checkNonce bool
-	isPrivate  bool
+	to             *common.Address
+	from           common.Address
+	nonce          uint64
+	amount         *big.Int
+	gasLimit       uint64
+	gasPrice       *big.Int
+	data           []byte
+	accessList     AccessList
+	checkNonce     bool
+	isPrivate      bool
+	isInnerPrivate bool
 }
 
 func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte, accessList AccessList, checkNonce bool) Message {
@@ -625,6 +626,17 @@ func (m Message) IsPrivate() bool {
 	return m.isPrivate
 }
 
+// Quorum
+func (m Message) IsInnerPrivate() bool {
+	return m.isInnerPrivate
+}
+
+// Quorum
+func (m Message) WithInnerPrivateFlag(isInnerPrivateTxn bool) Message {
+	m.isInnerPrivate = isInnerPrivateTxn
+	return m
+}
+
 // overriding msg.data so that when tesseera.receive is invoked we get nothing back
 func (m Message) WithEmptyPrivateData(b bool) Message {
 	if b {

core/vm/evm.go

@@ -323,7 +323,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 
 	// Quorum
 	if evm.ChainConfig().IsQuorum {
-		// skip transfer if value /= 0 (see note: Quorum, States, and Value Transfer)
+		// skip transfer if value == 0 (see note: Quorum, States, and Value Transfer)
 		if value.Sign() != 0 {
 			if evm.quorumReadOnly {
 				return nil, gas, ErrReadOnlyValueTransfer
@@ -599,7 +599,7 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
 		}
 	}
 	if evm.ChainConfig().IsQuorum {
-		// skip transfer if value /= 0 (see note: Quorum, States, and Value Transfer)
+		// skip transfer if value == 0 (see note: Quorum, States, and Value Transfer)
 		if value.Sign() != 0 {
 			if evm.quorumReadOnly {
 				return nil, common.Address{}, gas, ErrReadOnlyValueTransfer

eth/api.go

@@ -126,8 +126,8 @@ func (api *PrivateMinerAPI) SetGasPrice(gasPrice hexutil.Big) bool {
 
 // SetEtherbase sets the etherbase of the miner
 func (api *PrivateMinerAPI) SetEtherbase(etherbase common.Address) bool {
-	api.e.SetEtherbase(etherbase)
-	return true
+	// Quorum: Set return value, so user can be notified if it is disallowed.
+	return api.e.SetEtherbase(etherbase)
 }
 
 // SetRecommitInterval updates the interval for miner sealing work recommitting.

eth/api_backend.go

@@ -391,10 +391,10 @@ func (b *EthAPIBackend) Downloader() *downloader.Downloader {
 }
 
 func (b *EthAPIBackend) SuggestPrice(ctx context.Context) (*big.Int, error) {
-	if b.ChainConfig().IsQuorum {
-		return big.NewInt(0), nil
-	} else {
+	if !b.ChainConfig().IsQuorum || b.ChainConfig().IsGasEnabled(b.eth.blockchain.CurrentBlock().Number()) {
 		return b.gpo.SuggestPrice(ctx)
+	} else {
+		return big.NewInt(0), nil
 	}
 }
 

eth/backend.go

@@ -649,16 +649,22 @@ func (s *Ethereum) shouldPreserve(block *types.Block) bool {
 }
 
 // SetEtherbase sets the mining reward address.
-func (s *Ethereum) SetEtherbase(etherbase common.Address) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-	if _, ok := s.engine.(consensus.Istanbul); ok {
-		log.Error("Cannot set etherbase in Istanbul consensus")
-		return
+// Quorum: method now has a return value
+func (s *Ethereum) SetEtherbase(etherbase common.Address) bool {
+	//Quorum
+	consensusAlgo := s.handler.getConsensusAlgorithm()
+	if consensusAlgo == "istanbul" || consensusAlgo == "clique" || consensusAlgo == "raft" {
+		log.Error("Cannot set etherbase with selected consensus mechanism")
+		return false
 	}
+	//End-Quorum
+
+	s.lock.Lock()
 	s.etherbase = etherbase
+	s.lock.Unlock()
 
 	s.miner.SetEtherbase(etherbase)
+	return true
 }
 
 // StartMining starts the miner with the given number of CPU threads. If mining

les/api_backend.go

@@ -265,7 +265,11 @@ func (b *LesApiBackend) ProtocolVersion() int {
 }
 
 func (b *LesApiBackend) SuggestPrice(ctx context.Context) (*big.Int, error) {
-	return b.gpo.SuggestPrice(ctx)
+	if !b.ChainConfig().IsQuorum || b.ChainConfig().IsGasEnabled(b.eth.BlockChain().CurrentHeader().Number) {
+		return b.gpo.SuggestPrice(ctx)
+	} else {
+		return big.NewInt(0), nil
+	}
 }
 
 func (b *LesApiBackend) ChainDb() ethdb.Database {