P chain dynamic fees

scripts/mocks.mockgen.txt

@@ -40,5 +40,7 @@ github.com/ava-labs/avalanchego/vms/proposervm=PostForkBlock=vms/proposervm/mock
 github.com/ava-labs/avalanchego/vms/registry=VMGetter=vms/registry/mock_vm_getter.go
 github.com/ava-labs/avalanchego/vms/registry=VMRegistry=vms/registry/mock_vm_registry.go
 github.com/ava-labs/avalanchego/vms=Factory,Manager=vms/mock_manager.go
+github.com/ava-labs/avalanchego/wallet/chain/p=BuilderBackend=wallet/chain/p/mocks/mock_builder_backend.go
+github.com/ava-labs/avalanchego/wallet/chain/p=SignerBackend=wallet/chain/p/mocks/mock_signer_backend.go
 github.com/ava-labs/avalanchego/x/sync=Client=x/sync/mock_client.go
 github.com/ava-labs/avalanchego/x/sync=NetworkClient=x/sync/mock_network_client.go

tests/e2e/p/staking_rewards.go

@@ -237,6 +237,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.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.
@@ -290,13 +301,14 @@ 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

@@ -19,8 +19,12 @@ import (
 	"github.com/ava-labs/avalanchego/utils/units"
 	"github.com/ava-labs/avalanchego/vms/components/avax"
 	"github.com/ava-labs/avalanchego/vms/platformvm"
+	"github.com/ava-labs/avalanchego/vms/platformvm/config"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
+	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fees"
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+
+	commonfees "github.com/ava-labs/avalanchego/vms/components/fees"
 )
 
 // PChainWorkflow is an integration test for normal P-Chain operations
@@ -49,25 +53,18 @@ 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 X-chain tx fee {{/}}\n")
 			infoClient := info.NewClient(nodeURI.URI)
-			fees, err := infoClient.GetTxFee(e2e.DefaultContext())
+			xchainFees, err := infoClient.GetTxFee(e2e.DefaultContext())
 			require.NoError(err)
-			txFees := uint64(fees.TxFee)
-			tests.Outf("{{green}} txFee: %d {{/}}\n", txFees)
+			xChainTxFees := uint64(xchainFees.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.
@@ -126,8 +123,9 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 				OutputOwners: outputOwner,
 			}
 
+			pChainExportFee := uint64(0)
 			ginkgo.By("export avax from P to X chain", func() {
-				_, err := pWallet.IssueExportTx(
+				tx, err := pWallet.IssueExportTx(
 					xWallet.BlockchainID(),
 					[]*avax.TransferableOutput{
 						{
@@ -140,6 +138,18 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 					e2e.WithDefaultContext(),
 				)
 				require.NoError(err)
+
+				// retrieve fees paid for the tx
+				feeCfg := config.EUpgradeDynamicFeesConfig
+				feeCalc := fees.Calculator{
+					IsEForkActive:    true,
+					FeeManager:       commonfees.NewManager(feeCfg.UnitFees),
+					ConsumedUnitsCap: feeCfg.BlockUnitsCap,
+					Credentials:      tx.Creds,
+				}
+
+				require.NoError(tx.Unsigned.Visit(&feeCalc))
+				pChainExportFee = feeCalc.Fee
 			})
 
 			// check balances post export
@@ -154,7 +164,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(
@@ -176,7 +186,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/components/fees/dimensions.go

@@ -0,0 +1,62 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package fees
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/ava-labs/avalanchego/utils/math"
+)
+
+const (
+	Bandwidth Dimension = 0
+	UTXORead  Dimension = 1
+	UTXOWrite Dimension = 2 // includes delete
+	Compute   Dimension = 3 // signatures checks, tx-specific
+
+	FeeDimensions = 4
+
+	uint64Len = 8
+)
+
+var Empty = Dimensions{} // helps avoiding reading unit fees from db for some pre E fork processing
+
+type (
+	Dimension  int
+	Dimensions [FeeDimensions]uint64
+)
+
+func Add(lhs, rhs Dimensions) (Dimensions, error) {
+	var res Dimensions
+	for i := 0; i < FeeDimensions; i++ {
+		v, err := math.Add64(lhs[i], rhs[i])
+		if err != nil {
+			return res, err
+		}
+		res[i] = v
+	}
+	return res, nil
+}
+
+func (d *Dimensions) Bytes() []byte {
+	res := make([]byte, FeeDimensions*uint64Len)
+	for i := Dimension(0); i < FeeDimensions; i++ {
+		binary.BigEndian.PutUint64(res[i*uint64Len:], d[i])
+	}
+	return res
+}
+
+func (d *Dimensions) FromBytes(b []byte) error {
+	if len(b) != FeeDimensions*uint64Len {
+		return fmt.Errorf("unexpected bytes length: expected %d, actual %d",
+			FeeDimensions*uint64Len,
+			len(b),
+		)
+	}
+	for i := Dimension(0); i < FeeDimensions; i++ {
+		d[i] = binary.BigEndian.Uint64(b[i*uint64Len : (i+1)*uint64Len])
+	}
+	return nil
+}

vms/components/fees/helpers.go

@@ -0,0 +1,71 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package fees
+
+import (
+	"fmt"
+
+	"github.com/ava-labs/avalanchego/codec"
+	"github.com/ava-labs/avalanchego/utils/crypto/secp256k1"
+	"github.com/ava-labs/avalanchego/utils/wrappers"
+	"github.com/ava-labs/avalanchego/vms/components/avax"
+	"github.com/ava-labs/avalanchego/vms/components/verify"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+)
+
+func GetInputsDimensions(c codec.Manager, v uint16, ins []*avax.TransferableInput) (Dimensions, error) {
+	var consumedUnits Dimensions
+	for _, in := range ins {
+		cost, err := in.In.Cost()
+		if err != nil {
+			return consumedUnits, fmt.Errorf("failed retrieving cost of input %s: %w", in.ID, err)
+		}
+
+		inSize, err := c.Size(v, in)
+		if err != nil {
+			return consumedUnits, fmt.Errorf("failed retrieving size of input %s: %w", in.ID, err)
+		}
+		uInSize := uint64(inSize)
+
+		consumedUnits[Bandwidth] += uInSize - codec.CodecVersionSize
+		consumedUnits[UTXORead] += cost + uInSize // inputs are read
+		consumedUnits[UTXOWrite] += uInSize       // inputs are deleted
+	}
+	return consumedUnits, nil
+}
+
+func GetOutputsDimensions(c codec.Manager, v uint16, outs []*avax.TransferableOutput) (Dimensions, error) {
+	var consumedUnits Dimensions
+	for _, out := range outs {
+		outSize, err := c.Size(v, out)
+		if err != nil {
+			return consumedUnits, fmt.Errorf("failed retrieving size of output %s: %w", out.ID, err)
+		}
+		uOutSize := uint64(outSize)
+
+		consumedUnits[Bandwidth] += uOutSize - codec.CodecVersionSize
+		consumedUnits[UTXOWrite] += uOutSize
+	}
+	return consumedUnits, nil
+}
+
+func GetCredentialsDimensions(c codec.Manager, v uint16, inputSigIndices []uint32) (Dimensions, error) {
+	var consumedUnits Dimensions
+
+	// Workaround to ensure that codec picks interface instead of the pointer to evaluate size.
+	// TODO ABENEGIA: fix this
+	creds := make([]verify.Verifiable, 0, 1)
+	creds = append(creds, &secp256k1fx.Credential{
+		Sigs: make([][secp256k1.SignatureLen]byte, len(inputSigIndices)),
+	})
+
+	credSize, err := c.Size(v, creds)
+	if err != nil {
+		return consumedUnits, fmt.Errorf("failed retrieving size of credentials: %w", err)
+	}
+	credSize -= wrappers.IntLen // length of the slice, we want the single credential
+
+	consumedUnits[Bandwidth] += uint64(credSize) - codec.CodecVersionSize
+	return consumedUnits, nil
+}

vms/components/fees/manager.go

@@ -0,0 +1,92 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package fees
+
+import (
+	"fmt"
+
+	safemath "github.com/ava-labs/avalanchego/utils/math"
+)
+
+type Manager struct {
+	// Avax denominated unit fees for all fee dimensions
+	unitFees Dimensions
+
+	// cumulatedUnits helps aggregating the units consumed by a block
+	// so that we can verify it's not too big/build it properly.
+	cumulatedUnits Dimensions
+}
+
+func NewManager(unitFees Dimensions) *Manager {
+	return &Manager{
+		unitFees: unitFees,
+	}
+}
+
+func (m *Manager) GetUnitFees() Dimensions {
+	return m.unitFees
+}
+
+// CalculateFee must be a stateless method
+func (m *Manager) CalculateFee(units Dimensions) (uint64, error) {
+	fee := uint64(0)
+
+	for i := Dimension(0); i < FeeDimensions; i++ {
+		contribution, err := safemath.Mul64(m.unitFees[i], units[i])
+		if err != nil {
+			return 0, err
+		}
+		fee, err = safemath.Add64(contribution, fee)
+		if err != nil {
+			return 0, err
+		}
+	}
+	return fee, nil
+}
+
+// CumulateUnits tries to cumulate the consumed units [units]. Before
+// actually cumulating them, it checks whether the result would breach [bounds].
+// If so, it returns the first dimension to breach bounds.
+func (m *Manager) CumulateUnits(units, bounds Dimensions) (bool, Dimension) {
+	// Ensure we can consume (don't want partial update of values)
+	for i := Dimension(0); i < FeeDimensions; i++ {
+		consumed, err := safemath.Add64(m.cumulatedUnits[i], units[i])
+		if err != nil {
+			return true, i
+		}
+		if consumed > bounds[i] {
+			return true, i
+		}
+	}
+
+	// Commit to consumption
+	for i := Dimension(0); i < FeeDimensions; i++ {
+		consumed, err := safemath.Add64(m.cumulatedUnits[i], units[i])
+		if err != nil {
+			return true, i
+		}
+		m.cumulatedUnits[i] = consumed
+	}
+	return false, 0
+}
+
+// Sometimes, e.g. while building a tx, we'd like freedom to speculatively add units
+// and to remove them later on. [RemoveUnits] grants this freedom
+func (m *Manager) RemoveUnits(unitsToRm Dimensions) error {
+	var revertedUnits Dimensions
+	for i := Dimension(0); i < FeeDimensions; i++ {
+		prev, err := safemath.Sub(m.cumulatedUnits[i], unitsToRm[i])
+		if err != nil {
+			return fmt.Errorf("%w: dimension %d", err, i)
+		}
+		revertedUnits[i] = prev
+	}
+
+	m.cumulatedUnits = revertedUnits
+	return nil
+}
+
+func (m *Manager) GetCumulatedUnits() Dimensions {
+	return m.cumulatedUnits
+}