P-Chain: Block-level fee Calculator

vms/platformvm/block/builder/builder.go

@@ -331,11 +331,15 @@ func packBlockTxs(
 		return nil, err
 	}
 
+	feeCalculator, err := state.PickFeeCalculator(backend.Config, stateDiff)
+	if err != nil {
+		return nil, err
+	}
+
 	var (
 		blockTxs []*txs.Tx
 		inputs   set.Set[ids.ID]
 	)
-
 	for {
 		tx, exists := mempool.Peek()
 		if !exists {
@@ -355,9 +359,10 @@ func packBlockTxs(
 		}
 
 		executor := &txexecutor.StandardTxExecutor{
-			Backend: backend,
-			State:   txDiff,
-			Tx:      tx,
+			Backend:       backend,
+			State:         txDiff,
+			FeeCalculator: feeCalculator,
+			Tx:            tx,
 		}
 
 		err = tx.Unsigned.Visit(executor)

vms/platformvm/block/builder/helpers_test.go

@@ -259,15 +259,20 @@ func addSubnet(t *testing.T, env *environment) {
 	stateDiff, err := state.NewDiff(genesisID, env.blkManager)
 	require.NoError(err)
 
+	feeCalculator, err := state.PickFeeCalculator(env.config, stateDiff)
+	require.NoError(err)
+
 	executor := txexecutor.StandardTxExecutor{
-		Backend: &env.backend,
-		State:   stateDiff,
-		Tx:      testSubnet1,
+		Backend:       &env.backend,
+		State:         stateDiff,
+		FeeCalculator: feeCalculator,
+		Tx:            testSubnet1,
 	}
 	require.NoError(testSubnet1.Unsigned.Visit(&executor))
 
 	stateDiff.AddTx(testSubnet1, status.Committed)
 	require.NoError(stateDiff.Apply(env.state))
+	require.NoError(env.state.Commit())
 }
 
 func defaultState(

vms/platformvm/block/executor/helpers_test.go

@@ -280,11 +280,16 @@ func addSubnet(env *environment) {
 	if err != nil {
 		panic(err)
 	}
+	feeCalculator, err := state.PickFeeCalculator(env.config, stateDiff)
+	if err != nil {
+		panic(err)
+	}
 
 	executor := executor.StandardTxExecutor{
-		Backend: env.backend,
-		State:   stateDiff,
-		Tx:      testSubnet1,
+		Backend:       env.backend,
+		State:         stateDiff,
+		FeeCalculator: feeCalculator,
+		Tx:            testSubnet1,
 	}
 	err = testSubnet1.Unsigned.Visit(&executor)
 	if err != nil {
@@ -295,6 +300,9 @@ func addSubnet(env *environment) {
 	if err := stateDiff.Apply(env.state); err != nil {
 		panic(err)
 	}
+	if err := env.state.Commit(); err != nil {
+		panic(err)
+	}
 }
 
 func defaultState(

vms/platformvm/block/executor/manager.go

@@ -142,10 +142,16 @@ func (m *manager) VerifyTx(tx *txs.Tx) error {
 		return err
 	}
 
+	feeCalculator, err := state.PickFeeCalculator(m.txExecutorBackend.Config, stateDiff)
+	if err != nil {
+		return err
+	}
+
 	return tx.Unsigned.Visit(&executor.StandardTxExecutor{
-		Backend: m.txExecutorBackend,
-		State:   stateDiff,
-		Tx:      tx,
+		Backend:       m.txExecutorBackend,
+		State:         stateDiff,
+		FeeCalculator: feeCalculator,
+		Tx:            tx,
 	})
 }
 

vms/platformvm/block/executor/verifier.go

@@ -15,6 +15,7 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm/status"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/executor"
+	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
 )
 
 var (
@@ -66,7 +67,17 @@ func (v *verifier) BanffProposalBlock(b *block.BanffProposalBlock) error {
 		return err
 	}
 
-	inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs(b.Transactions, onDecisionState, b.Parent())
+	feeCalculator, err := state.PickFeeCalculator(v.txExecutorBackend.Config, onDecisionState)
+	if err != nil {
+		return err
+	}
+
+	inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs(
+		b.Transactions,
+		feeCalculator,
+		onDecisionState,
+		b.Parent(),
+	)
 	if err != nil {
 		return err
 	}
@@ -86,6 +97,7 @@ func (v *verifier) BanffProposalBlock(b *block.BanffProposalBlock) error {
 		onDecisionState,
 		onCommitState,
 		onAbortState,
+		feeCalculator,
 		inputs,
 		atomicRequests,
 		onAcceptFunc,
@@ -119,7 +131,11 @@ func (v *verifier) BanffStandardBlock(b *block.BanffStandardBlock) error {
 		return errBanffStandardBlockWithoutChanges
 	}
 
-	return v.standardBlock(&b.ApricotStandardBlock, onAcceptState)
+	feeCalculator, err := state.PickFeeCalculator(v.txExecutorBackend.Config, onAcceptState)
+	if err != nil {
+		return err
+	}
+	return v.standardBlock(&b.ApricotStandardBlock, feeCalculator, onAcceptState)
 }
 
 func (v *verifier) ApricotAbortBlock(b *block.ApricotAbortBlock) error {
@@ -151,7 +167,13 @@ func (v *verifier) ApricotProposalBlock(b *block.ApricotProposalBlock) error {
 		return err
 	}
 
-	return v.proposalBlock(b, nil, onCommitState, onAbortState, nil, nil, nil)
+	var (
+		staticFeeConfig = v.txExecutorBackend.Config.StaticFeeConfig
+		upgradeConfig   = v.txExecutorBackend.Config.UpgradeConfig
+		timestamp       = onCommitState.GetTimestamp() // Equal to parent timestamp
+		feeCalculator   = fee.NewStaticCalculator(staticFeeConfig, upgradeConfig, timestamp)
+	)
+	return v.proposalBlock(b, nil, onCommitState, onAbortState, feeCalculator, nil, nil, nil)
 }
 
 func (v *verifier) ApricotStandardBlock(b *block.ApricotStandardBlock) error {
@@ -165,7 +187,13 @@ func (v *verifier) ApricotStandardBlock(b *block.ApricotStandardBlock) error {
 		return err
 	}
 
-	return v.standardBlock(b, onAcceptState)
+	var (
+		staticFeeConfig = v.txExecutorBackend.Config.StaticFeeConfig
+		upgradeConfig   = v.txExecutorBackend.Config.UpgradeConfig
+		timestamp       = onAcceptState.GetTimestamp() // Equal to parent timestamp
+		feeCalculator   = fee.NewStaticCalculator(staticFeeConfig, upgradeConfig, timestamp)
+	)
+	return v.standardBlock(b, feeCalculator, onAcceptState)
 }
 
 func (v *verifier) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error {
@@ -187,8 +215,10 @@ func (v *verifier) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error {
 		)
 	}
 
+	feeCalculator := fee.NewStaticCalculator(v.txExecutorBackend.Config.StaticFeeConfig, v.txExecutorBackend.Config.UpgradeConfig, currentTimestamp)
 	atomicExecutor := executor.AtomicTxExecutor{
 		Backend:       v.txExecutorBackend,
+		FeeCalculator: feeCalculator,
 		ParentID:      parentID,
 		StateVersions: v,
 		Tx:            b.Tx,
@@ -356,6 +386,7 @@ func (v *verifier) proposalBlock(
 	onDecisionState state.Diff,
 	onCommitState state.Diff,
 	onAbortState state.Diff,
+	feeCalculator fee.Calculator,
 	inputs set.Set[ids.ID],
 	atomicRequests map[ids.ID]*atomic.Requests,
 	onAcceptFunc func(),
@@ -364,6 +395,7 @@ func (v *verifier) proposalBlock(
 		OnCommitState: onCommitState,
 		OnAbortState:  onAbortState,
 		Backend:       v.txExecutorBackend,
+		FeeCalculator: feeCalculator,
 		Tx:            b.Tx,
 	}
 
@@ -403,9 +435,10 @@ func (v *verifier) proposalBlock(
 // standardBlock populates the state of this block if [nil] is returned
 func (v *verifier) standardBlock(
 	b *block.ApricotStandardBlock,
+	feeCalculator fee.Calculator,
 	onAcceptState state.Diff,
 ) error {
-	inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs(b.Transactions, onAcceptState, b.Parent())
+	inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs(b.Transactions, feeCalculator, onAcceptState, b.Parent())
 	if err != nil {
 		return err
 	}
@@ -426,7 +459,7 @@ func (v *verifier) standardBlock(
 	return nil
 }
 
-func (v *verifier) processStandardTxs(txs []*txs.Tx, state state.Diff, parentID ids.ID) (
+func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculator, state state.Diff, parentID ids.ID) (
 	set.Set[ids.ID],
 	map[ids.ID]*atomic.Requests,
 	func(),
@@ -440,9 +473,10 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, state state.Diff, parentID
 	)
 	for _, tx := range txs {
 		txExecutor := executor.StandardTxExecutor{
-			Backend: v.txExecutorBackend,
-			State:   state,
-			Tx:      tx,
+			Backend:       v.txExecutorBackend,
+			State:         state,
+			FeeCalculator: feeCalculator,
+			Tx:            tx,
 		}
 		if err := tx.Unsigned.Visit(&txExecutor); err != nil {
 			txID := tx.ID()

vms/platformvm/service_test.go

@@ -38,7 +38,6 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm/state"
 	"github.com/ava-labs/avalanchego/vms/platformvm/status"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
-	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest"
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 	"github.com/ava-labs/avalanchego/wallet/subnet/primary/common"
@@ -376,8 +375,9 @@ func TestGetBalance(t *testing.T) {
 	require := require.New(t)
 	service, _, _ := defaultService(t)
 
-	feeCalc := fee.NewStaticCalculator(service.vm.Config.StaticFeeConfig, service.vm.Config.UpgradeConfig, service.vm.clock.Time())
-	createSubnetFee, err := feeCalc.CalculateFee(&txs.Tx{Unsigned: &txs.CreateSubnetTx{}})
+	feeCalculator, err := state.PickFeeCalculator(&service.vm.Config, service.vm.state)
+	require.NoError(err)
+	createSubnetFee, err := feeCalculator.CalculateFee(&txs.Tx{Unsigned: &txs.CreateSubnetTx{}})
 	require.NoError(err)
 
 	// Ensure GetStake is correct for each of the genesis validators

vms/platformvm/state/chain_time_helpers.go

@@ -9,6 +9,8 @@ import (
 
 	"github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/utils/timer/mockable"
+	"github.com/ava-labs/avalanchego/vms/platformvm/config"
+	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
 )
 
 func NextBlockTime(state Chain, clk *mockable.Clock) (time.Time, bool, error) {
@@ -68,3 +70,12 @@ func GetNextStakerChangeTime(state Chain) (time.Time, error) {
 		return time.Time{}, database.ErrNotFound
 	}
 }
+
+// PickFeeCalculator creates either a static or a dynamic fee calculator,
+// depending on the active upgrade.
+//
+// PickFeeCalculator does not modify [state].
+func PickFeeCalculator(cfg *config.Config, state Chain) (fee.Calculator, error) {
+	timestamp := state.GetTimestamp()
+	return fee.NewStaticCalculator(cfg.StaticFeeConfig, cfg.UpgradeConfig, timestamp), nil
+}