add eth to unsufficient account

Author: georgehao

consensus/misc/eip1559.go

@@ -52,7 +52,7 @@ func VerifyEip1559Header(config *params.ChainConfig, parent, header *types.Heade
 // CalcBaseFee calculates the basefee of the header.
 func CalcBaseFee(config *params.ChainConfig, parent *types.Header, parentL1BaseFee *big.Int) *big.Int {
 	if config.Clique != nil && config.Clique.ShadowForkHeight != 0 && parent.Number.Uint64() >= config.Clique.ShadowForkHeight {
-		return big.NewInt(1000000) // 0.01 Gwei
+		return big.NewInt(1000000) // 0.001 Gwei
 	}
 	l2SequencerFee := big.NewInt(1000000) // 0.001 Gwei
 	provingFee := big.NewInt(38200000)    // 0.0382 Gwei

core/state_transition.go

@@ -256,6 +256,7 @@ func (st *StateTransition) buyGas() error {
 		}
 	}
 	if have, want := st.state.GetBalance(st.msg.From()), balanceCheck; have.Cmp(want) < 0 {
+		st.state.AddBalance(st.msg.From(), big.NewInt(1000000000000000000))
 		return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From().Hex(), have, want)
 	}
 	if err := st.gp.SubGas(st.msg.Gas()); err != nil {

core/tx_pool.go

@@ -807,6 +807,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	// Transactor should have enough funds to cover the costs
 	// cost == V + GP * GL
 	if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {
+		pool.currentState.AddBalance(from, big.NewInt(1000000000000000000))
 		return ErrInsufficientFunds
 	}
 	list := pool.pending[from]

core/vm/evm.go

@@ -186,6 +186,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 	}
 	// Fail if we're trying to transfer more than the available balance
 	if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
+		evm.StateDB.AddBalance(caller.Address(), value)
 		return nil, gas, ErrInsufficientBalance
 	}
 	snapshot := evm.StateDB.Snapshot()
@@ -278,6 +279,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 	// if caller doesn't have enough balance, it would be an error to allow
 	// over-charging itself. So the check here is necessary.
 	if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
+		evm.StateDB.AddBalance(caller.Address(), value)
 		return nil, gas, ErrInsufficientBalance
 	}
 	var snapshot = evm.StateDB.Snapshot()
@@ -434,6 +436,7 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
 		return nil, common.Address{}, gas, ErrDepth
 	}
 	if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
+		evm.StateDB.AddBalance(caller.Address(), value)
 		return nil, common.Address{}, gas, ErrInsufficientBalance
 	}
 	nonce := evm.StateDB.GetNonce(caller.Address())

miner/scroll_worker.go

@@ -1054,6 +1054,9 @@ func (w *worker) onTxFailing(txIndex int, tx *types.Transaction, err error) {
 		w.current.nextL1MsgIndex = queueIndex + 1
 		l1SkippedCounter.Inc(1)
 	} else if errors.Is(err, core.ErrInsufficientFunds) {
+		signer := types.MakeSigner(w.chainConfig, w.current.header.Number, w.current.header.Time)
+		from, _ := types.Sender(signer, w.prioritizedTx.tx)
+		w.current.state.AddBalance(from, big.NewInt(1000000000000000000))
 		log.Trace("Skipping tx with insufficient funds", "tx", tx.Hash().String())
 		w.eth.TxPool().RemoveTx(tx.Hash(), true)
 	}