P-chain - Multidimensional Dynamic Fees

tests/e2e/p/dynamic_fees.go

@@ -0,0 +1,140 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+//go:build test
+
+package p
+
+import (
+	"fmt"
+
+	"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/vms/platformvm"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+
+	commonfee "github.com/ava-labs/avalanchego/vms/components/fee"
+	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 := commonfee.DynamicFeesConfig{
+			MinGasPrice:       commonfee.GasPrice(1),
+			UpdateDenominator: commonfee.Gas(5),
+
+			// BlockUnitsTarget are set to cause an increase of fees while simple transactions are issued
+			GasTargetRate: commonfee.Gas(120),
+		}
+
+		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{
+				"P": {
+					"dynamic-fees-config": customDynamicFeesConfig,
+				},
+			},
+		}
+		e2e.Env.StartPrivateNetwork(privateNetwork)
+
+		ginkgo.By("setup a wallet and a P-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)
+		pWallet := baseWallet.P()
+		pChainClient := platformvm.NewClient(nodeURI.URI)
+
+		// retrieve initial balances
+		pBuilder := pWallet.Builder()
+		pContext := pBuilder.Context()
+		avaxAssetID := pContext.AVAXAssetID
+		pBalances, err := pWallet.Builder().GetBalance()
+		require.NoError(err)
+		pStartBalance := pBalances[avaxAssetID]
+		tests.Outf("{{blue}} P-chain balance before P->X export: %d {{/}}\n", pStartBalance)
+
+		ginkgo.By("checking that initial fee values match with configured ones", func() {
+			nextFeeRates, _, err := pChainClient.GetNextGasData(e2e.DefaultContext())
+			require.NoError(err)
+			require.Equal(customDynamicFeesConfig.MinGasPrice, nextFeeRates)
+		})
+
+		ginkgo.By("issue expensive transactions so to increase the fee rates to be paid for accepting the transactons",
+			func() {
+				initialOwner := &secp256k1fx.OutputOwners{
+					Threshold: 1,
+					Addrs: []ids.ShortID{
+						keychain.Keys[0].Address(),
+					},
+				}
+
+				var subnetID ids.ID
+				ginkgo.By("create a permissioned subnet", func() {
+					subnetTx, err := pWallet.IssueCreateSubnetTx(
+						initialOwner,
+						e2e.WithDefaultContext(),
+					)
+					require.NoError(err)
+
+					subnetID = subnetTx.ID()
+				})
+
+				nextFeeRates, _, err := pChainClient.GetNextGasData(e2e.DefaultContext())
+				require.NoError(err)
+				tests.Outf("{{blue}} next fee rates: %v {{/}}\n", nextFeeRates)
+
+				ginkgo.By("repeatedly change the permissioned subnet owner to increase fee rates", func() {
+					txsCount := 10
+					for i := 0; i < txsCount; i++ {
+						nextOwner := &secp256k1fx.OutputOwners{
+							Threshold: 1,
+							Addrs: []ids.ShortID{
+								keychain.Keys[1].Address(),
+							},
+						}
+
+						_, err = pWallet.IssueTransferSubnetOwnershipTx(
+							subnetID,
+							nextOwner,
+							e2e.WithDefaultContext(),
+						)
+						require.NoError(err)
+
+						updatedFeeRates, _, err := pChainClient.GetNextGasData(e2e.DefaultContext())
+						require.NoError(err)
+						tests.Outf("{{blue}} current fee rates: %v {{/}}\n", updatedFeeRates)
+
+						ginkgo.By("check that fee rates components have increased")
+						require.GreaterOrEqual(nextFeeRates, updatedFeeRates,
+							fmt.Sprintf("previous fee rates %v, current fee rates %v", nextFeeRates, updatedFeeRates),
+						)
+						nextFeeRates = updatedFeeRates
+					}
+				})
+
+				ginkgo.By("wait for the fee rates to decrease", func() {
+					initialFeeRates := nextFeeRates
+					e2e.Eventually(func() bool {
+						var err error
+						nextFeeRates, _, err = pChainClient.GetNextGasData(e2e.DefaultContext())
+						require.NoError(err)
+						tests.Outf("{{blue}} next fee rates: %v {{/}}\n", nextFeeRates)
+						return nextFeeRates < initialFeeRates
+					}, e2e.DefaultTimeout, e2e.DefaultPollingInterval, "failed to see gas price decrease before timeout")
+					tests.Outf("\n{{blue}}fee rates have decreased to %v{{/}}\n", nextFeeRates)
+				})
+			},
+		)
+	})
+})

vms/components/fee/calculator.go

@@ -6,6 +6,9 @@ package fee
 import (
 	"errors"
 	"fmt"
+	"math"
+	"math/big"
+	"time"
 
 	safemath "github.com/ava-labs/avalanchego/utils/math"
 )
@@ -31,6 +34,10 @@ type Calculator struct {
 	// latestTxComplexity tracks complexity of latest tx being processed.
 	// latestTxComplexity is especially helpful while building a tx.
 	latestTxComplexity Dimensions
+
+	// currentExcessGas stores current excess gas, cumulated over time
+	// to be updated once a block is accepted with cumulatedGas
+	currentExcessGas Gas
 }
 
 func NewCalculator(feeWeights Dimensions, gasPrice GasPrice, gasCap Gas) *Calculator {
@@ -41,6 +48,45 @@ func NewCalculator(feeWeights Dimensions, gasPrice GasPrice, gasCap Gas) *Calcul
 	}
 }
 
+func NewUpdatedManager(
+	feesConfig DynamicFeesConfig,
+	gasCap, currentExcessGas Gas,
+	parentBlkTime, childBlkTime time.Time,
+) (*Calculator, error) {
+	res := &Calculator{
+		feeWeights:       feesConfig.FeeDimensionWeights,
+		gasCap:           gasCap,
+		currentExcessGas: currentExcessGas,
+	}
+
+	targetGas, err := TargetGas(feesConfig, parentBlkTime, childBlkTime)
+	if err != nil {
+		return nil, fmt.Errorf("failed calculating target gas: %w", err)
+	}
+
+	if currentExcessGas > targetGas {
+		currentExcessGas -= targetGas
+	} else {
+		currentExcessGas = ZeroGas
+	}
+
+	res.gasPrice = fakeExponential(feesConfig.MinGasPrice, currentExcessGas, feesConfig.UpdateDenominator)
+	return res, nil
+}
+
+func TargetGas(feesConfig DynamicFeesConfig, parentBlkTime, childBlkTime time.Time) (Gas, error) {
+	if parentBlkTime.Compare(childBlkTime) > 0 {
+		return ZeroGas, fmt.Errorf("unexpected block times, parentBlkTim %v, childBlkTime %v", parentBlkTime, childBlkTime)
+	}
+
+	elapsedTime := uint64(childBlkTime.Unix() - parentBlkTime.Unix())
+	targetGas, over := safemath.Mul64(uint64(feesConfig.GasTargetRate), elapsedTime)
+	if over != nil {
+		targetGas = math.MaxUint64
+	}
+	return Gas(targetGas), nil
+}
+
 func (c *Calculator) GetGasPrice() GasPrice {
 	return c.gasPrice
 }
@@ -57,6 +103,14 @@ func (c *Calculator) GetGasCap() Gas {
 	return c.gasCap
 }
 
+func (c *Calculator) GetExcessGas() (Gas, error) {
+	g, err := safemath.Add64(uint64(c.currentExcessGas), uint64(c.cumulatedGas))
+	if err != nil {
+		return ZeroGas, err
+	}
+	return Gas(g), nil
+}
+
 // AddFeesFor updates latest tx complexity. It should be called once when tx is being verified
 // and may be called multiple times when tx is being built (and tx components are added in time).
 // AddFeesFor checks that gas cap is not breached. It also returns the updated tx fee for convenience.
@@ -117,3 +171,27 @@ func (c *Calculator) GetLatestTxFee() (uint64, error) {
 	}
 	return safemath.Mul64(uint64(c.gasPrice), uint64(gas))
 }
+
+// fakeExponential approximates factor * e ** (numerator / denominator) using
+// Taylor expansion.
+func fakeExponential(f GasPrice, n, d Gas) GasPrice {
+	var (
+		factor      = new(big.Int).SetUint64(uint64(f))
+		numerator   = new(big.Int).SetUint64(uint64(n))
+		denominator = new(big.Int).SetUint64(uint64(d))
+		output      = new(big.Int)
+		accum       = new(big.Int).Mul(factor, denominator)
+	)
+	for i := 1; accum.Sign() > 0; i++ {
+		output.Add(output, accum)
+
+		accum.Mul(accum, numerator)
+		accum.Div(accum, denominator)
+		accum.Div(accum, big.NewInt(int64(i)))
+	}
+	output = output.Div(output, denominator)
+	if !output.IsUint64() {
+		return math.MaxUint64
+	}
+	return GasPrice(output.Uint64())
+}