pool: track pending cost per payer (#845)

runtime/resolved_tx.go

@@ -96,6 +96,7 @@ func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (
 	baseGasPrice *big.Int,
 	gasPrice *big.Int,
 	payer thor.Address,
+	prepaid *big.Int,
 	returnGas func(uint64) error,
 	err error,
 ) {
@@ -113,19 +114,20 @@ func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (
 		return returnedEnergy, nil
 	}
 
-	prepaid := new(big.Int).Mul(new(big.Int).SetUint64(r.tx.Gas()), gasPrice)
+	// prepaid is the max total of gas cost available to spend on this transaction
+	prepaid = new(big.Int).Mul(new(big.Int).SetUint64(r.tx.Gas()), gasPrice)
 	if r.Delegator != nil {
 		var sufficient bool
 		if sufficient, err = energy.Sub(*r.Delegator, prepaid); err != nil {
 			return
 		}
 		if sufficient {
-			return baseGasPrice, gasPrice, *r.Delegator, func(rgas uint64) error {
+			return baseGasPrice, gasPrice, *r.Delegator, prepaid, func(rgas uint64) error {
 				_, err := doReturnGas(rgas)
 				return err
 			}, nil
 		}
-		return nil, nil, thor.Address{}, nil, errors.New("insufficient energy")
+		return nil, nil, thor.Address{}, nil, nil, errors.New("insufficient energy")
 	}
 
 	commonTo := r.CommonTo()
@@ -164,7 +166,7 @@ func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (
 					return
 				}
 				if ok {
-					return baseGasPrice, gasPrice, sponsor, doReturnGasAndSetCredit, nil
+					return baseGasPrice, gasPrice, sponsor, prepaid, doReturnGasAndSetCredit, nil
 				}
 			}
 			// deduct from To
@@ -174,7 +176,7 @@ func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (
 				return
 			}
 			if sufficient {
-				return baseGasPrice, gasPrice, *commonTo, doReturnGasAndSetCredit, nil
+				return baseGasPrice, gasPrice, *commonTo, prepaid, doReturnGasAndSetCredit, nil
 			}
 		}
 	}
@@ -186,9 +188,9 @@ func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (
 	}
 
 	if sufficient {
-		return baseGasPrice, gasPrice, r.Origin, func(rgas uint64) error { _, err := doReturnGas(rgas); return err }, nil
+		return baseGasPrice, gasPrice, r.Origin, prepaid, func(rgas uint64) error { _, err := doReturnGas(rgas); return err }, nil
 	}
-	return nil, nil, thor.Address{}, nil, errors.New("insufficient energy")
+	return nil, nil, thor.Address{}, nil, nil, errors.New("insufficient energy")
 }
 
 // ToContext create a tx context object.

runtime/resolved_tx_test.go

@@ -144,7 +144,7 @@ func (tr *testResolvedTransaction) TestBuyGas() {
 		if err != nil {
 			tr.t.Fatal(err)
 		}
-		_, _, payer, returnGas, err := resolve.BuyGas(state, targetTime)
+		_, _, payer, _, returnGas, err := resolve.BuyGas(state, targetTime)
 		tr.assert.Nil(err)
 		returnGas(100)
 		return payer

runtime/runtime.go

@@ -382,7 +382,7 @@ func (rt *Runtime) PrepareTransaction(tx *tx.Transaction) (*TransactionExecutor,
 		return nil, err
 	}
 
-	baseGasPrice, gasPrice, payer, returnGas, err := resolvedTx.BuyGas(rt.state, rt.ctx.Time)
+	baseGasPrice, gasPrice, payer, _, returnGas, err := resolvedTx.BuyGas(rt.state, rt.ctx.Time)
 	if err != nil {
 		return nil, err
 	}

txpool/tx_object.go

@@ -23,10 +23,13 @@ type txObject struct {
 	*tx.Transaction
 	resolved *runtime.ResolvedTransaction
 
-	timeAdded       int64
-	executable      bool
+	timeAdded      int64
+	localSubmitted bool          // tx is submitted locally on this node, or synced remotely from p2p.
+	payer          *thor.Address // payer of the tx, either origin, delegator, or on-chain delegation payer
+	cost           *big.Int      // total tx cost the payer needs to pay before execution(gas price * gas)
+
+	executable      bool     // don't touch this value, will be updated by the pool
 	overallGasPrice *big.Int // don't touch this value, it's only be used in pool's housekeeping
-	localSubmitted  bool     // tx is submitted locally on this node, or synced remotely from p2p.
 }
 
 func resolveTx(tx *tx.Transaction, localSubmitted bool) (*txObject, error) {
@@ -51,6 +54,14 @@ func (o *txObject) Delegator() *thor.Address {
 	return o.resolved.Delegator
 }
 
+func (o *txObject) Cost() *big.Int {
+	return o.cost
+}
+
+func (o *txObject) Payer() *thor.Address {
+	return o.payer
+}
+
 func (o *txObject) Executable(chain *chain.Chain, state *state.State, headBlock *block.Header) (bool, error) {
 	switch {
 	case o.Gas() > headBlock.GasLimit():
@@ -86,9 +97,18 @@ func (o *txObject) Executable(chain *chain.Chain, state *state.State, headBlock
 		return false, nil
 	}
 
-	if _, _, _, _, err := o.resolved.BuyGas(state, headBlock.Timestamp()+thor.BlockInterval); err != nil {
+	checkpoint := state.NewCheckpoint()
+	defer state.RevertTo(checkpoint)
+
+	_, _, payer, prepaid, _, err := o.resolved.BuyGas(state, headBlock.Timestamp()+thor.BlockInterval)
+	if err != nil {
 		return false, err
 	}
+
+	if !o.executable {
+		o.payer = &payer
+		o.cost = prepaid
+	}
 	return true, nil
 }
 

txpool/tx_object_map.go

@@ -7,25 +7,28 @@ package txpool
 
 import (
 	"errors"
+	"math/big"
 	"sync"
 
 	"github.com/vechain/thor/v2/thor"
 	"github.com/vechain/thor/v2/tx"
 )
 
-// txObjectMap to maintain mapping of tx hash to tx object, and account quota.
+// txObjectMap to maintain mapping of tx hash to tx object, account quota and pending cost.
 type txObjectMap struct {
 	lock      sync.RWMutex
 	mapByHash map[thor.Bytes32]*txObject
 	mapByID   map[thor.Bytes32]*txObject
 	quota     map[thor.Address]int
+	cost      map[thor.Address]*big.Int
 }
 
 func newTxObjectMap() *txObjectMap {
 	return &txObjectMap{
 		mapByHash: make(map[thor.Bytes32]*txObject),
 		mapByID:   make(map[thor.Bytes32]*txObject),
 		quota:     make(map[thor.Address]int),
+		cost:      make(map[thor.Address]*big.Int),
 	}
 }
 
@@ -36,7 +39,7 @@ func (m *txObjectMap) ContainsHash(txHash thor.Bytes32) bool {
 	return found
 }
 
-func (m *txObjectMap) Add(txObj *txObject, limitPerAccount int) error {
+func (m *txObjectMap) Add(txObj *txObject, limitPerAccount int, validatePayer func(payer thor.Address, needs *big.Int) error) error {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
@@ -49,22 +52,50 @@ func (m *txObjectMap) Add(txObj *txObject, limitPerAccount int) error {
 		return errors.New("account quota exceeded")
 	}
 
-	if d := txObj.Delegator(); d != nil {
-		if m.quota[*d] >= limitPerAccount {
+	delegator := txObj.Delegator()
+	if delegator != nil {
+		if m.quota[*delegator] >= limitPerAccount {
 			return errors.New("delegator quota exceeded")
 		}
-		m.quota[*d]++
+	}
+
+	var (
+		cost  *big.Int
+		payer thor.Address
+	)
+
+	if txObj.Cost() != nil {
+		payer = *txObj.Payer()
+		pending := m.cost[payer]
+
+		if pending == nil {
+			cost = new(big.Int).Set(txObj.Cost())
+		} else {
+			cost = new(big.Int).Add(pending, txObj.Cost())
+		}
+
+		if err := validatePayer(payer, cost); err != nil {
+			return err
+		}
 	}
 
 	m.quota[txObj.Origin()]++
+	if delegator != nil {
+		m.quota[*delegator]++
+	}
+
+	if cost != nil {
+		m.cost[payer] = cost
+	}
+
 	m.mapByHash[hash] = txObj
 	m.mapByID[txObj.ID()] = txObj
 	return nil
 }
 
 func (m *txObjectMap) GetByID(id thor.Bytes32) *txObject {
-	m.lock.Lock()
-	defer m.lock.Unlock()
+	m.lock.RLock()
+	defer m.lock.RUnlock()
 	return m.mapByID[id]
 }
 
@@ -79,11 +110,22 @@ func (m *txObjectMap) RemoveByHash(txHash thor.Bytes32) bool {
 			delete(m.quota, txObj.Origin())
 		}
 
-		if d := txObj.Delegator(); d != nil {
-			if m.quota[*d] > 1 {
-				m.quota[*d]--
+		if delegator := txObj.Delegator(); delegator != nil {
+			if m.quota[*delegator] > 1 {
+				m.quota[*delegator]--
 			} else {
-				delete(m.quota, *d)
+				delete(m.quota, *delegator)
+			}
+		}
+
+		// update the pending cost of payers
+		if payer := txObj.Payer(); payer != nil {
+			if pending := m.cost[*payer]; pending != nil {
+				if pending.Cmp(txObj.Cost()) <= 0 {
+					delete(m.cost, *payer)
+				} else {
+					m.cost[*payer] = new(big.Int).Sub(pending, txObj.Cost())
+				}
 			}
 		}
 
@@ -94,6 +136,17 @@ func (m *txObjectMap) RemoveByHash(txHash thor.Bytes32) bool {
 	return false
 }
 
+func (m *txObjectMap) UpdatePendingCost(txObj *txObject) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	if pending := m.cost[*txObj.Payer()]; pending != nil {
+		m.cost[*txObj.Payer()] = new(big.Int).Add(pending, txObj.Cost())
+	} else {
+		m.cost[*txObj.Payer()] = new(big.Int).Set(txObj.Cost())
+	}
+}
+
 func (m *txObjectMap) ToTxObjects() []*txObject {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
@@ -125,11 +178,12 @@ func (m *txObjectMap) Fill(txObjs []*txObject) {
 		}
 		// skip account limit check
 		m.quota[txObj.Origin()]++
-		if d := txObj.Delegator(); d != nil {
-			m.quota[*d]++
+		if delegator := txObj.Delegator(); delegator != nil {
+			m.quota[*delegator]++
 		}
 		m.mapByHash[txObj.Hash()] = txObj
 		m.mapByID[txObj.ID()] = txObj
+		// skip cost check and accumulation
 	}
 }