X-chain - update unit fees

tests/e2e/p/workflow.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ava-labs/avalanchego/utils/constants"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls"
 	"github.com/ava-labs/avalanchego/utils/units"
+	"github.com/ava-labs/avalanchego/vms/avm"
 	"github.com/ava-labs/avalanchego/vms/avm/config"
 	"github.com/ava-labs/avalanchego/vms/avm/txs/fees"
 	"github.com/ava-labs/avalanchego/vms/components/avax"
@@ -52,6 +53,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 			xBuilder := xWallet.Builder()
 			xContext := xBuilder.Context()
 			pChainClient := platformvm.NewClient(nodeURI.URI)
+			xChainClient := avm.NewClient(nodeURI.URI, "X")
 
 			tests.Outf("{{blue}} fetching minimal stake amounts {{/}}\n")
 			minValStake, minDelStake, err := pChainClient.GetMinStake(e2e.DefaultContext(), constants.PlatformChainID)
@@ -188,9 +190,12 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 
 				// retrieve fees paid for the tx
 				feeCfg := config.GetDynamicFeesConfig(true /*isEActive*/)
+				feeRates, _, err := xChainClient.GetFeeRates(e2e.DefaultContext())
+				require.NoError(err)
+
 				feeCalc := fees.NewDynamicCalculator(
 					xbuilder.Parser.Codec(),
-					commonfees.NewManager(feeCfg.FeeRate),
+					commonfees.NewManager(feeRates),
 					feeCfg.BlockMaxComplexity,
 					tx.Creds,
 				)

tests/e2e/x/dynamic_fees.go

@@ -0,0 +1,126 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package x
+
+import (
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/tests"
+	"github.com/ava-labs/avalanchego/tests/fixture/e2e"
+	"github.com/ava-labs/avalanchego/tests/fixture/tmpnet"
+	"github.com/ava-labs/avalanchego/utils/units"
+	"github.com/ava-labs/avalanchego/vms/avm"
+	"github.com/ava-labs/avalanchego/vms/components/verify"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+
+	commonfees "github.com/ava-labs/avalanchego/vms/components/fees"
+	ginkgo "github.com/onsi/ginkgo/v2"
+)
+
+var _ = ginkgo.Describe("[Dynamic Fees]", func() {
+	require := require.New(ginkgo.GinkgoT())
+
+	ginkgo.It("should ensure that the dynamic multifees are affected by load", func() {
+		customDynamicFeesConfig := commonfees.DynamicFeesConfig{
+			InitialFeeRate:     commonfees.Dimensions{1, 2, 3, 4},
+			MinFeeRate:         commonfees.Dimensions{1, 1, 1, 1},
+			UpdateCoefficient:  commonfees.Dimensions{1, 1, 1, 1},
+			BlockMaxComplexity: commonfees.Max,
+
+			// BlockUnitsTarget are set to cause an increase of fees while simple transactions are issued
+			BlockTargetComplexityRate: commonfees.Dimensions{300, 80, 150, 800},
+		}
+
+		ginkgo.By("creating a new private network to ensure isolation from other tests")
+		privateNetwork := &tmpnet.Network{
+			Owner: "avalanchego-e2e-dynamic-fees",
+			ChainConfigs: map[string]tmpnet.FlagsMap{
+				"X": {
+					"dynamic-fees-config": customDynamicFeesConfig,
+				},
+			},
+		}
+		e2e.Env.StartPrivateNetwork(privateNetwork)
+
+		ginkgo.By("setup a wallet and a X-chain client")
+		node := privateNetwork.Nodes[0]
+		nodeURI := tmpnet.NodeURI{
+			NodeID: node.NodeID,
+			URI:    node.URI,
+		}
+		keychain := secp256k1fx.NewKeychain(privateNetwork.PreFundedKeys...)
+		baseWallet := e2e.NewWallet(keychain, nodeURI)
+		xWallet := baseWallet.X()
+		xChainClient := avm.NewClient(nodeURI.URI, "X")
+
+		// retrieve initial balances
+		xBuilder := xWallet.Builder()
+		xContext := xBuilder.Context()
+		avaxAssetID := xContext.AVAXAssetID
+		xBalances, err := xWallet.Builder().GetFTBalance()
+		require.NoError(err)
+		xStartBalance := xBalances[avaxAssetID]
+		tests.Outf("{{blue}} X-chain initial balance: %d {{/}}\n", xStartBalance)
+
+		ginkgo.By("checking that initial fee values match with configured ones", func() {
+			currFeeRates, _, err := xChainClient.GetFeeRates(e2e.DefaultContext())
+			require.NoError(err)
+			require.Equal(customDynamicFeesConfig.InitialFeeRate, currFeeRates)
+		})
+
+		ginkgo.By("issue expensive transactions so to increase the fee rates to be paid for accepting the transactons",
+			func() {
+				currFeeRates := commonfees.Empty
+
+				ginkgo.By("repeatedly change the permissioned subnet owner to increase fee rates", func() {
+					txsCount := 10
+					for i := 0; i < txsCount; i++ {
+						owner := secp256k1fx.OutputOwners{
+							Threshold: 1,
+							Addrs: []ids.ShortID{
+								keychain.Keys[1].Address(),
+							},
+						}
+
+						_, err := xWallet.IssueCreateAssetTx(
+							"HI",
+							"HI",
+							byte(txsCount),
+							map[uint32][]verify.State{
+								0: {
+									&secp256k1fx.TransferOutput{
+										Amt:          units.Schmeckle,
+										OutputOwners: owner,
+									},
+								},
+							},
+						)
+						require.NoError(err)
+
+						updatedFeeRates, _, err := xChainClient.GetFeeRates(e2e.DefaultContext())
+						require.NoError(err)
+						tests.Outf("{{blue}} current fee rates: %v {{/}}\n", updatedFeeRates)
+
+						ginkgo.By("check that fee rates components have increased")
+						require.True(commonfees.Compare(currFeeRates, updatedFeeRates))
+						currFeeRates = updatedFeeRates
+					}
+				})
+
+				ginkgo.By("wait for the fee rates to decrease", func() {
+					initialFeeRates := currFeeRates
+					e2e.Eventually(func() bool {
+						var err error
+						_, currFeeRates, err = xChainClient.GetFeeRates(e2e.DefaultContext())
+						require.NoError(err)
+						tests.Outf("{{blue}} next fee rates: %v {{/}}\n", currFeeRates)
+						return commonfees.Compare(initialFeeRates, currFeeRates)
+					}, e2e.DefaultTimeout, e2e.DefaultPollingInterval, "failed to see gas price decrease before timeout")
+					tests.Outf("\n{{blue}}fee rates have decreased to %v{{/}}\n", currFeeRates)
+				})
+			},
+		)
+	})
+})

tests/e2e/x/transfer/virtuous.go

@@ -172,6 +172,12 @@ var _ = e2e.DescribeXChainSerial("[Virtuous Transfer Tx AVAX]", func() {
 					require.Contains(err.Error(), "insufficient funds")
 				})
 
+				// retrieve the unit fees that will be used for the BaseTx
+				nodeURI := e2e.Env.GetRandomNodeURI()
+				xChainClient := avm.NewClient(nodeURI.URI, "X")
+				_, feeRates, err := xChainClient.GetFeeRates(e2e.DefaultContext())
+				require.NoError(err)
+
 				tx, err := wallets[fromIdx].X().IssueBaseTx(
 					[]*avax.TransferableOutput{{
 						Asset: avax.Asset{
@@ -193,7 +199,7 @@ var _ = e2e.DescribeXChainSerial("[Virtuous Transfer Tx AVAX]", func() {
 				feeCfg := config.GetDynamicFeesConfig(true /*isEActive*/)
 				feeCalc := fees.NewDynamicCalculator(
 					xbuilder.Parser.Codec(),
-					commonfees.NewManager(feeCfg.FeeRate),
+					commonfees.NewManager(feeRates),
 					feeCfg.BlockMaxComplexity,
 					tx.Creds,
 				)

vms/avm/block/builder/builder.go

@@ -16,11 +16,12 @@ import (
 	"github.com/ava-labs/avalanchego/vms/avm/config"
 	"github.com/ava-labs/avalanchego/vms/avm/state"
 	"github.com/ava-labs/avalanchego/vms/avm/txs"
+	"github.com/ava-labs/avalanchego/vms/avm/txs/fees"
 	"github.com/ava-labs/avalanchego/vms/avm/txs/mempool"
-	"github.com/ava-labs/avalanchego/vms/components/fees"
 
 	blockexecutor "github.com/ava-labs/avalanchego/vms/avm/block/executor"
 	txexecutor "github.com/ava-labs/avalanchego/vms/avm/txs/executor"
+	commonfees "github.com/ava-labs/avalanchego/vms/components/fees"
 )
 
 // targetBlockSize is the max block size we aim to produce
@@ -76,13 +77,10 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 	}
 
 	preferredHeight := preferred.Height()
-	preferredTimestamp := preferred.Timestamp()
-
 	nextHeight := preferredHeight + 1
-	nextTimestamp := b.clk.Time() // [timestamp] = max(now, parentTime)
-	if preferredTimestamp.After(nextTimestamp) {
-		nextTimestamp = preferredTimestamp
-	}
+
+	parentBlkTime := preferred.Timestamp()
+	nextBlkTime := blockexecutor.NextBlockTime(parentBlkTime, b.clk)
 
 	stateDiff, err := state.NewDiff(preferredID, b.manager)
 	if err != nil {
@@ -94,18 +92,28 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 		inputs        set.Set[ids.ID]
 		remainingSize = targetBlockSize
 
-		chainTime  = stateDiff.GetTimestamp()
-		isEActive  = b.backend.Config.IsEActivated(chainTime)
-		feesCfg    = config.GetDynamicFeesConfig(isEActive)
-		feeManager = fees.NewManager(feesCfg.FeeRate)
+		chainTime = stateDiff.GetTimestamp()
+		isEActive = b.backend.Config.IsEActivated(chainTime)
+		feesCfg   = config.GetDynamicFeesConfig(isEActive)
 	)
+
+	feeManager, err := fees.UpdatedFeeManager(stateDiff, b.backend.Config, parentBlkTime, nextBlkTime)
+	if err != nil {
+		return nil, err
+	}
+
 	for {
 		tx, exists := b.mempool.Peek()
-		// Invariant: [mempool.MaxTxSize] < [targetBlockSize]. This guarantees
-		// that we will only stop building a block once there are no
-		// transactions in the mempool or the block is at least
-		// [targetBlockSize - mempool.MaxTxSize] bytes full.
-		if !exists || len(tx.Bytes()) > remainingSize {
+		if !exists {
+			break
+		}
+		txSize := len(tx.Bytes())
+
+		// pre e upgrade is active, we fill blocks till a target size
+		// post e upgrade is active, we fill blocks till a target complexity
+		done := (!isEActive && txSize > remainingSize) ||
+			(isEActive && !commonfees.Compare(feeManager.GetCumulatedComplexity(), feesCfg.BlockTargetComplexityRate))
+		if done {
 			break
 		}
 		b.mempool.Remove(tx)
@@ -156,9 +164,13 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 		inputs.Union(executor.Inputs)
 
 		txDiff.AddTx(tx)
+		txDiff.SetFeeRates(feeManager.GetFeeRates())
+		txDiff.SetLastBlockComplexity(feeManager.GetCumulatedComplexity())
 		txDiff.Apply(stateDiff)
 
-		remainingSize -= len(tx.Bytes())
+		if isEActive {
+			remainingSize -= txSize
+		}
 		blockTxs = append(blockTxs, tx)
 	}
 
@@ -169,7 +181,7 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 	statelessBlk, err := block.NewStandardBlock(
 		preferredID,
 		nextHeight,
-		nextTimestamp,
+		nextBlkTime,
 		blockTxs,
 		b.backend.Codec,
 	)