P-chain - Multidimensional Static Fees

tests/e2e/p/permissionless_subnets.go

@@ -63,9 +63,9 @@ var _ = e2e.DescribePChain("[Permissionless Subnets]", func() {
 					owner,
 					e2e.WithDefaultContext(),
 				)
-
-				subnetID = subnetTx.ID()
 				require.NoError(err)
+				subnetID = subnetTx.ID()
+
 				require.NotEqual(subnetID, constants.PrimaryNetworkID)
 			})
 

tests/e2e/p/staking_rewards.go

@@ -240,6 +240,17 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 		delegatorData := data[0].Delegators[0]
 		actualGammaDelegationPeriod := time.Duration(delegatorData.EndTime-delegatorData.StartTime) * time.Second
 
+		preRewardBalances := make(map[ids.ShortID]uint64, len(rewardKeys))
+		for _, rewardKey := range rewardKeys {
+			keychain := secp256k1fx.NewKeychain(rewardKey)
+			baseWallet := e2e.NewWallet(keychain, nodeURI)
+			pWallet := baseWallet.P()
+			balances, err := pWallet.Builder().GetBalance()
+			require.NoError(err)
+			preRewardBalances[rewardKey.Address()] = balances[pWallet.Builder().Context().AVAXAssetID]
+		}
+		require.Len(preRewardBalances, len(rewardKeys))
+
 		ginkgo.By("waiting until all validation periods are over")
 		// The beta validator was the last added and so has the latest end time. The
 		// delegation periods are shorter than the validation periods.
@@ -293,12 +304,12 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 
 		ginkgo.By("checking expected rewards against actual rewards")
 		expectedRewardBalances := map[ids.ShortID]uint64{
-			alphaValidationRewardKey.Address(): expectedValidationReward,
-			alphaDelegationRewardKey.Address(): expectedDelegationFee,
-			betaValidationRewardKey.Address():  0, // Validator didn't meet uptime requirement
-			betaDelegationRewardKey.Address():  0, // Validator didn't meet uptime requirement
-			gammaDelegationRewardKey.Address(): expectedDelegatorReward,
-			deltaDelegationRewardKey.Address(): 0, // Validator didn't meet uptime requirement
+			alphaValidationRewardKey.Address(): preRewardBalances[alphaValidationRewardKey.Address()] + expectedValidationReward,
+			alphaDelegationRewardKey.Address(): preRewardBalances[alphaDelegationRewardKey.Address()] + expectedDelegationFee,
+			betaValidationRewardKey.Address():  preRewardBalances[betaValidationRewardKey.Address()] + 0, // Validator didn't meet uptime requirement
+			betaDelegationRewardKey.Address():  preRewardBalances[betaDelegationRewardKey.Address()] + 0, // Validator didn't meet uptime requirement
+			gammaDelegationRewardKey.Address(): preRewardBalances[gammaDelegationRewardKey.Address()] + expectedDelegatorReward,
+			deltaDelegationRewardKey.Address(): preRewardBalances[deltaDelegationRewardKey.Address()] + 0, // Validator didn't meet uptime requirement
 		}
 		for address := range expectedRewardBalances {
 			require.Equal(expectedRewardBalances[address], rewardBalances[address])

tests/e2e/p/workflow.go

@@ -22,8 +22,10 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm"
 	"github.com/ava-labs/avalanchego/vms/platformvm/signer"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
+	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 
+	commonfee "github.com/ava-labs/avalanchego/vms/components/fee"
 	ginkgo "github.com/onsi/ginkgo/v2"
 )
 
@@ -57,25 +59,24 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 			tests.Outf("{{green}} minimal validator stake: %d {{/}}\n", minValStake)
 			tests.Outf("{{green}} minimal delegator stake: %d {{/}}\n", minDelStake)
 
-			tests.Outf("{{blue}} fetching tx fee {{/}}\n")
+			tests.Outf("{{blue}} fetching minimal stake amounts {{/}}\n")
+			feeCfg, err := pChainClient.GetDynamicFeeConfig(e2e.DefaultContext())
+			require.NoError(err)
+			tests.Outf("{{green}} fee config: %v {{/}}\n", feeCfg)
+
+			tests.Outf("{{blue}} fetching X-chain tx fee {{/}}\n")
 			infoClient := info.NewClient(nodeURI.URI)
-			fees, err := infoClient.GetTxFee(e2e.DefaultContext())
+			staticFees, err := infoClient.GetTxFee(e2e.DefaultContext())
 			require.NoError(err)
-			txFees := uint64(fees.TxFee)
-			tests.Outf("{{green}} txFee: %d {{/}}\n", txFees)
+
+			xChainTxFees := uint64(staticFees.TxFee)
+			tests.Outf("{{green}} X-chain TxFee: %d {{/}}\n", xChainTxFees)
 
 			// amount to transfer from P to X chain
 			toTransfer := 1 * units.Avax
 
 			pShortAddr := keychain.Keys[0].Address()
 			xTargetAddr := keychain.Keys[1].Address()
-			ginkgo.By("check selected keys have sufficient funds", func() {
-				pBalances, err := pWallet.Builder().GetBalance()
-				pBalance := pBalances[avaxAssetID]
-				minBalance := minValStake + txFees + minDelStake + txFees + toTransfer + txFees
-				require.NoError(err)
-				require.GreaterOrEqual(pBalance, minBalance)
-			})
 
 			// Use a random node ID to ensure that repeated test runs
 			// will succeed against a network that persists across runs.
@@ -145,8 +146,12 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 				OutputOwners: outputOwner,
 			}
 
+			pChainExportFee := uint64(0)
 			ginkgo.By("export avax from P to X chain", func() {
-				_, err := pWallet.IssueExportTx(
+				nextGasPrice, nextGasCap, err := pChainClient.GetNextGasData(e2e.DefaultContext())
+				require.NoError(err)
+
+				tx, err := pWallet.IssueExportTx(
 					xContext.BlockchainID,
 					[]*avax.TransferableOutput{
 						{
@@ -159,6 +164,11 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 					e2e.WithDefaultContext(),
 				)
 				require.NoError(err)
+
+				// retrieve fees paid for the tx
+				feeCalc := fee.NewDynamicCalculator(commonfee.NewCalculator(feeCfg.FeeDimensionWeights, nextGasPrice, nextGasCap))
+				pChainExportFee, err = feeCalc.CalculateFee(tx)
+				require.NoError(err)
 			})
 
 			// check balances post export
@@ -173,7 +183,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 			tests.Outf("{{blue}} X-chain balance after P->X export: %d {{/}}\n", xPreImportBalance)
 
 			require.Equal(xPreImportBalance, xStartBalance) // import not performed yet
-			require.Equal(pPreImportBalance, pStartBalance-toTransfer-txFees)
+			require.Equal(pPreImportBalance, pStartBalance-toTransfer-pChainExportFee)
 
 			ginkgo.By("import avax from P into X chain", func() {
 				_, err := xWallet.IssueImportTx(
@@ -195,7 +205,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 			xFinalBalance := xBalances[avaxAssetID]
 			tests.Outf("{{blue}} X-chain balance after P->X import: %d {{/}}\n", xFinalBalance)
 
-			require.Equal(xFinalBalance, xPreImportBalance+toTransfer-txFees) // import not performed yet
+			require.Equal(xFinalBalance, xPreImportBalance+toTransfer-xChainTxFees) // import not performed yet
 			require.Equal(pFinalBalance, pPreImportBalance)
 		})
 })

vms/platformvm/block/builder/builder.go

@@ -331,7 +331,7 @@ func packBlockTxs(
 		return nil, err
 	}
 
-	feeCalculator, err := state.PickFeeCalculator(backend.Config, stateDiff)
+	feeCalculator, err := state.PickFeeCalculator(backend.Config, stateDiff, parentState.GetTimestamp())
 	if err != nil {
 		return nil, err
 	}

vms/platformvm/block/builder/helpers_test.go

@@ -262,7 +262,7 @@ func addSubnet(t *testing.T, env *environment) {
 	stateDiff, err := state.NewDiff(genesisID, env.blkManager)
 	require.NoError(err)
 
-	feeCalculator, err := state.PickFeeCalculator(env.config, stateDiff)
+	feeCalculator, err := state.PickFeeCalculator(env.config, stateDiff, stateDiff.GetTimestamp())
 	require.NoError(err)
 
 	executor := txexecutor.StandardTxExecutor{

vms/platformvm/block/executor/acceptor.go

@@ -79,6 +79,8 @@ func (a *acceptor) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error {
 		return fmt.Errorf("%w %s", errMissingBlockState, blkID)
 	}
 
+	a.metrics.SetBlockGas(blkState.blockGas)
+
 	// Update the state to reflect the changes made in [onAcceptState].
 	if err := blkState.onAcceptState.Apply(a.state); err != nil {
 		return err
@@ -136,6 +138,8 @@ func (a *acceptor) optionBlock(b block.Block, blockType string) error {
 		return err
 	}
 
+	a.metrics.SetBlockGas(parentState.blockGas)
+
 	if err := a.commonAccept(b); err != nil {
 		return err
 	}
@@ -150,6 +154,10 @@ func (a *acceptor) optionBlock(b block.Block, blockType string) error {
 	if !ok {
 		return fmt.Errorf("%w %s", errMissingBlockState, blkID)
 	}
+
+	// we set option complexity at its parent block's one.
+	a.metrics.SetBlockGas(parentState.blockGas)
+
 	if err := blkState.onAcceptState.Apply(a.state); err != nil {
 		return err
 	}
@@ -228,6 +236,8 @@ func (a *acceptor) standardBlock(b block.Block, blockType string) error {
 		return fmt.Errorf("%w %s", errMissingBlockState, blkID)
 	}
 
+	a.metrics.SetBlockGas(blkState.blockGas)
+
 	// Update the state to reflect the changes made in [onAcceptState].
 	if err := blkState.onAcceptState.Apply(a.state); err != nil {
 		return err

vms/platformvm/block/executor/block_state.go

@@ -11,6 +11,8 @@ import (
 	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/avalanchego/vms/platformvm/block"
 	"github.com/ava-labs/avalanchego/vms/platformvm/state"
+
+	commonfee "github.com/ava-labs/avalanchego/vms/components/fee"
 )
 
 type proposalBlockState struct {
@@ -30,5 +32,6 @@ type blockState struct {
 
 	inputs         set.Set[ids.ID]
 	timestamp      time.Time
+	blockGas       commonfee.Gas
 	atomicRequests map[ids.ID]*atomic.Requests
 }

vms/platformvm/block/executor/helpers_test.go

@@ -6,6 +6,7 @@ package executor
 import (
 	"context"
 	"fmt"
+	"math/rand"
 	"testing"
 	"time"
 
@@ -36,6 +37,7 @@ import (
 	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/avalanchego/utils/timer/mockable"
 	"github.com/ava-labs/avalanchego/utils/units"
+	"github.com/ava-labs/avalanchego/vms/components/avax"
 	"github.com/ava-labs/avalanchego/vms/platformvm/api"
 	"github.com/ava-labs/avalanchego/vms/platformvm/config"
 	"github.com/ava-labs/avalanchego/vms/platformvm/fx"
@@ -61,15 +63,14 @@ const (
 	pending stakerStatus = iota
 	current
 
-	defaultWeight = 10000
-	trackChecksum = false
-
 	apricotPhase3 fork = iota
 	apricotPhase5
 	banff
 	cortina
 	durango
 	eUpgrade
+
+	latestFork = eUpgrade
 )
 
 var (
@@ -78,17 +79,24 @@ var (
 	defaultGenesisTime        = time.Date(1997, 1, 1, 0, 0, 0, 0, time.UTC)
 	defaultValidateStartTime  = defaultGenesisTime
 	defaultValidateEndTime    = defaultValidateStartTime.Add(10 * defaultMinStakingDuration)
-	defaultMinValidatorStake  = 5 * units.MilliAvax
-	defaultBalance            = 100 * defaultMinValidatorStake
-	preFundedKeys             = secp256k1.TestKeys()
-	avaxAssetID               = ids.ID{'y', 'e', 'e', 't'}
-	defaultTxFee              = uint64(100)
+
+	defaultMinValidatorStake = 5 * units.MilliAvax
+	defaultMaxValidatorStake = 500 * units.MilliAvax
+	defaultMinDelegatorStake = 1 * units.MilliAvax
+	defaultBalance           = 100 * defaultMinValidatorStake
+	defaultWeight            = defaultBalance / 2
+
+	preFundedKeys = secp256k1.TestKeys()
+	avaxAssetID   = ids.ID{'y', 'e', 'e', 't'}
+	defaultTxFee  = uint64(100)
 
 	genesisBlkID ids.ID
 	testSubnet1  *txs.Tx
 
 	// Node IDs of genesis validators. Initialized in init function
 	genesisNodeIDs []ids.NodeID
+
+	fundedSharedMemoryCalls byte
 )
 
 func init() {
@@ -102,6 +110,10 @@ type stakerStatus uint
 
 type fork uint8
 
+type mutableSharedMemory struct {
+	atomic.SharedMemory
+}
+
 type staker struct {
 	nodeID             ids.NodeID
 	rewardAddress      ids.ShortID
@@ -127,6 +139,7 @@ type environment struct {
 	clk            *mockable.Clock
 	baseDB         *versiondb.Database
 	ctx            *snow.Context
+	msm            *mutableSharedMemory
 	fx             fx.Fx
 	state          state.State
 	mockedState    *state.MockState
@@ -152,6 +165,12 @@ func newEnvironment(t *testing.T, ctrl *gomock.Controller, f fork) *environment
 	res.ctx.AVAXAssetID = avaxAssetID
 	res.ctx.SharedMemory = m.NewSharedMemory(res.ctx.ChainID)
 
+	msm := &mutableSharedMemory{
+		SharedMemory: m.NewSharedMemory(res.ctx.ChainID),
+	}
+	res.ctx.SharedMemory = msm
+	res.msm = msm
+
 	res.fx = defaultFx(res.clk, res.ctx.Log, res.isBootstrapped.Get())
 
 	rewardsCalc := reward.NewCalculator(res.config.RewardConfig)
@@ -288,7 +307,7 @@ func addSubnet(env *environment) {
 	if err != nil {
 		panic(err)
 	}
-	feeCalculator, err := state.PickFeeCalculator(env.config, stateDiff)
+	feeCalculator, err := state.PickFeeCalculator(env.config, stateDiff, stateDiff.GetTimestamp())
 	if err != nil {
 		panic(err)
 	}
@@ -354,9 +373,9 @@ func defaultConfig(t *testing.T, f fork) *config.Config {
 			CreateSubnetTxFee:     100 * defaultTxFee,
 			CreateBlockchainTxFee: 100 * defaultTxFee,
 		},
-		MinValidatorStake: 5 * units.MilliAvax,
-		MaxValidatorStake: 500 * units.MilliAvax,
-		MinDelegatorStake: 1 * units.MilliAvax,
+		MinValidatorStake: defaultMinValidatorStake,
+		MaxValidatorStake: defaultMaxValidatorStake,
+		MinDelegatorStake: defaultMinDelegatorStake,
 		MinStakeDuration:  defaultMinStakingDuration,
 		MaxStakeDuration:  defaultMaxStakingDuration,
 		RewardConfig: reward.Config{
@@ -557,3 +576,56 @@ func addPendingValidator(
 	}
 	return addPendingValidatorTx, nil
 }
+
+// Returns a shared memory where GetDatabase returns a database
+// where [recipientKey] has a balance of [amt]
+func fundedSharedMemory(
+	t *testing.T,
+	env *environment,
+	sourceKey *secp256k1.PrivateKey,
+	peerChain ids.ID,
+	assets map[ids.ID]uint64,
+) atomic.SharedMemory {
+	fundedSharedMemoryCalls++
+	m := atomic.NewMemory(prefixdb.New([]byte{fundedSharedMemoryCalls}, env.baseDB))
+
+	sm := m.NewSharedMemory(env.ctx.ChainID)
+	peerSharedMemory := m.NewSharedMemory(peerChain)
+
+	for assetID, amt := range assets {
+		utxo := &avax.UTXO{
+			UTXOID: avax.UTXOID{
+				TxID:        ids.GenerateTestID(),
+				OutputIndex: rand.Uint32(), // #nosec G404
+			},
+			Asset: avax.Asset{ID: assetID},
+			Out: &secp256k1fx.TransferOutput{
+				Amt: amt,
+				OutputOwners: secp256k1fx.OutputOwners{
+					Locktime:  0,
+					Addrs:     []ids.ShortID{sourceKey.PublicKey().Address()},
+					Threshold: 1,
+				},
+			},
+		}
+		utxoBytes, err := txs.Codec.Marshal(txs.CodecVersion, utxo)
+		require.NoError(t, err)
+
+		inputID := utxo.InputID()
+		require.NoError(t, peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
+			env.ctx.ChainID: {
+				PutRequests: []*atomic.Element{
+					{
+						Key:   inputID[:],
+						Value: utxoBytes,
+						Traits: [][]byte{
+							sourceKey.PublicKey().Address().Bytes(),
+						},
+					},
+				},
+			},
+		}))
+	}
+
+	return sm
+}