github.com/MetalBlockchain/metalgo@v1.11.9/vms/platformvm/txs/fee/calculator_test.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package fee
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/MetalBlockchain/metalgo/ids"
    13  	"github.com/MetalBlockchain/metalgo/utils/constants"
    14  	"github.com/MetalBlockchain/metalgo/utils/units"
    15  	"github.com/MetalBlockchain/metalgo/vms/platformvm/txs"
    16  	"github.com/MetalBlockchain/metalgo/vms/platformvm/upgrade"
    17  )
    18  
    19  func TestTxFees(t *testing.T) {
    20  	feeTestsDefaultCfg := StaticConfig{
    21  		TxFee:                         1 * units.Avax,
    22  		CreateAssetTxFee:              2 * units.Avax,
    23  		CreateSubnetTxFee:             3 * units.Avax,
    24  		TransformSubnetTxFee:          4 * units.Avax,
    25  		CreateBlockchainTxFee:         5 * units.Avax,
    26  		AddPrimaryNetworkValidatorFee: 6 * units.Avax,
    27  		AddPrimaryNetworkDelegatorFee: 7 * units.Avax,
    28  		AddSubnetValidatorFee:         8 * units.Avax,
    29  		AddSubnetDelegatorFee:         9 * units.Avax,
    30  	}
    31  
    32  	latestForkTime := time.Unix(1713945427, 0)
    33  	upgrades := upgrade.Config{
    34  		EUpgradeTime:      latestForkTime,
    35  		DurangoTime:       latestForkTime.Add(-1 * time.Hour),
    36  		CortinaTime:       latestForkTime.Add(-2 * time.Hour),
    37  		BanffTime:         latestForkTime.Add(-3 * time.Hour),
    38  		ApricotPhase5Time: latestForkTime.Add(-4 * time.Hour),
    39  		ApricotPhase3Time: latestForkTime.Add(-5 * time.Hour),
    40  	}
    41  
    42  	// chain times needed to have specific upgrades active
    43  	preEUpgradeTime := upgrades.EUpgradeTime.Add(-1 * time.Second)
    44  	preApricotPhase3Time := upgrades.ApricotPhase3Time.Add(-1 * time.Second)
    45  
    46  	tests := []struct {
    47  		name       string
    48  		chainTime  time.Time
    49  		unsignedTx func() txs.UnsignedTx
    50  		expected   uint64
    51  	}{
    52  		{
    53  			name:       "AddValidatorTx pre EUpgrade",
    54  			chainTime:  preEUpgradeTime,
    55  			unsignedTx: addValidatorTx,
    56  			expected:   feeTestsDefaultCfg.AddPrimaryNetworkValidatorFee,
    57  		},
    58  		{
    59  			name:       "AddSubnetValidatorTx pre EUpgrade",
    60  			chainTime:  preEUpgradeTime,
    61  			unsignedTx: addSubnetValidatorTx,
    62  			expected:   feeTestsDefaultCfg.AddSubnetValidatorFee,
    63  		},
    64  		{
    65  			name:       "AddDelegatorTx pre EUpgrade",
    66  			chainTime:  preEUpgradeTime,
    67  			unsignedTx: addDelegatorTx,
    68  			expected:   feeTestsDefaultCfg.AddPrimaryNetworkDelegatorFee,
    69  		},
    70  		{
    71  			name:       "CreateChainTx pre ApricotPhase3",
    72  			chainTime:  preApricotPhase3Time,
    73  			unsignedTx: createChainTx,
    74  			expected:   feeTestsDefaultCfg.CreateAssetTxFee,
    75  		},
    76  		{
    77  			name:       "CreateChainTx pre EUpgrade",
    78  			chainTime:  preEUpgradeTime,
    79  			unsignedTx: createChainTx,
    80  			expected:   feeTestsDefaultCfg.CreateBlockchainTxFee,
    81  		},
    82  		{
    83  			name:       "CreateSubnetTx pre ApricotPhase3",
    84  			chainTime:  preApricotPhase3Time,
    85  			unsignedTx: createSubnetTx,
    86  			expected:   feeTestsDefaultCfg.CreateAssetTxFee,
    87  		},
    88  		{
    89  			name:       "CreateSubnetTx pre EUpgrade",
    90  			chainTime:  preEUpgradeTime,
    91  			unsignedTx: createSubnetTx,
    92  			expected:   feeTestsDefaultCfg.CreateSubnetTxFee,
    93  		},
    94  		{
    95  			name:       "RemoveSubnetValidatorTx pre EUpgrade",
    96  			chainTime:  preEUpgradeTime,
    97  			unsignedTx: removeSubnetValidatorTx,
    98  			expected:   feeTestsDefaultCfg.TxFee,
    99  		},
   100  		{
   101  			name:       "TransformSubnetTx pre EUpgrade",
   102  			chainTime:  preEUpgradeTime,
   103  			unsignedTx: transformSubnetTx,
   104  			expected:   feeTestsDefaultCfg.TransformSubnetTxFee,
   105  		},
   106  		{
   107  			name:       "TransferSubnetOwnershipTx pre EUpgrade",
   108  			chainTime:  preEUpgradeTime,
   109  			unsignedTx: transferSubnetOwnershipTx,
   110  			expected:   feeTestsDefaultCfg.TxFee,
   111  		},
   112  		{
   113  			name:      "AddPermissionlessValidatorTx Primary Network pre EUpgrade",
   114  			chainTime: upgrades.EUpgradeTime.Add(-1 * time.Second),
   115  			unsignedTx: func() txs.UnsignedTx {
   116  				return addPermissionlessValidatorTx(constants.PrimaryNetworkID)
   117  			},
   118  			expected: feeTestsDefaultCfg.AddPrimaryNetworkValidatorFee,
   119  		},
   120  		{
   121  			name:      "AddPermissionlessValidatorTx Subnet pre EUpgrade",
   122  			chainTime: upgrades.EUpgradeTime.Add(-1 * time.Second),
   123  			unsignedTx: func() txs.UnsignedTx {
   124  				subnetID := ids.GenerateTestID()
   125  				require.NotEqual(t, constants.PrimaryNetworkID, subnetID)
   126  				return addPermissionlessValidatorTx(subnetID)
   127  			},
   128  			expected: feeTestsDefaultCfg.AddSubnetValidatorFee,
   129  		},
   130  		{
   131  			name:      "AddPermissionlessDelegatorTx Primary Network pre EUpgrade",
   132  			chainTime: upgrades.EUpgradeTime.Add(-1 * time.Second),
   133  			unsignedTx: func() txs.UnsignedTx {
   134  				return addPermissionlessDelegatorTx(constants.PrimaryNetworkID)
   135  			},
   136  			expected: feeTestsDefaultCfg.AddPrimaryNetworkDelegatorFee,
   137  		},
   138  		{
   139  			name:      "AddPermissionlessDelegatorTx pre EUpgrade",
   140  			chainTime: upgrades.EUpgradeTime.Add(-1 * time.Second),
   141  			unsignedTx: func() txs.UnsignedTx {
   142  				subnetID := ids.GenerateTestID()
   143  				require.NotEqual(t, constants.PrimaryNetworkID, subnetID)
   144  				return addPermissionlessDelegatorTx(subnetID)
   145  			},
   146  			expected: feeTestsDefaultCfg.AddSubnetDelegatorFee,
   147  		},
   148  		{
   149  			name:       "BaseTx pre EUpgrade",
   150  			chainTime:  preEUpgradeTime,
   151  			unsignedTx: baseTx,
   152  			expected:   feeTestsDefaultCfg.TxFee,
   153  		},
   154  		{
   155  			name:       "ImportTx pre EUpgrade",
   156  			chainTime:  preEUpgradeTime,
   157  			unsignedTx: importTx,
   158  			expected:   feeTestsDefaultCfg.TxFee,
   159  		},
   160  		{
   161  			name:       "ExportTx pre EUpgrade",
   162  			chainTime:  preEUpgradeTime,
   163  			unsignedTx: exportTx,
   164  			expected:   feeTestsDefaultCfg.TxFee,
   165  		},
   166  		{
   167  			name:      "RewardValidatorTx pre EUpgrade",
   168  			chainTime: upgrades.EUpgradeTime.Add(-1 * time.Second),
   169  			unsignedTx: func() txs.UnsignedTx {
   170  				return &txs.RewardValidatorTx{
   171  					TxID: ids.GenerateTestID(),
   172  				}
   173  			},
   174  			expected: 0,
   175  		},
   176  		{
   177  			name:      "AdvanceTimeTx pre EUpgrade",
   178  			chainTime: upgrades.EUpgradeTime.Add(-1 * time.Second),
   179  			unsignedTx: func() txs.UnsignedTx {
   180  				return &txs.AdvanceTimeTx{
   181  					Time: uint64(time.Now().Unix()),
   182  				}
   183  			},
   184  			expected: 0,
   185  		},
   186  	}
   187  
   188  	for _, tt := range tests {
   189  		t.Run(tt.name, func(t *testing.T) {
   190  			uTx := tt.unsignedTx()
   191  			fc := NewStaticCalculator(feeTestsDefaultCfg, upgrades)
   192  			require.Equal(t, tt.expected, fc.CalculateFee(uTx, tt.chainTime))
   193  		})
   194  	}
   195  }
   196  
   197  func addValidatorTx() txs.UnsignedTx {
   198  	return &txs.AddValidatorTx{}
   199  }
   200  
   201  func addSubnetValidatorTx() txs.UnsignedTx {
   202  	return &txs.AddSubnetValidatorTx{}
   203  }
   204  
   205  func addDelegatorTx() txs.UnsignedTx {
   206  	return &txs.AddDelegatorTx{}
   207  }
   208  
   209  func createChainTx() txs.UnsignedTx {
   210  	return &txs.CreateChainTx{}
   211  }
   212  
   213  func createSubnetTx() txs.UnsignedTx {
   214  	return &txs.CreateSubnetTx{}
   215  }
   216  
   217  func removeSubnetValidatorTx() txs.UnsignedTx {
   218  	return &txs.RemoveSubnetValidatorTx{}
   219  }
   220  
   221  func transformSubnetTx() txs.UnsignedTx {
   222  	return &txs.TransformSubnetTx{}
   223  }
   224  
   225  func transferSubnetOwnershipTx() txs.UnsignedTx {
   226  	return &txs.TransferSubnetOwnershipTx{}
   227  }
   228  
   229  func addPermissionlessValidatorTx(subnetID ids.ID) txs.UnsignedTx {
   230  	return &txs.AddPermissionlessValidatorTx{
   231  		Subnet: subnetID,
   232  	}
   233  }
   234  
   235  func addPermissionlessDelegatorTx(subnetID ids.ID) txs.UnsignedTx {
   236  	return &txs.AddPermissionlessDelegatorTx{
   237  		Subnet: subnetID,
   238  	}
   239  }
   240  
   241  func baseTx() txs.UnsignedTx {
   242  	return &txs.BaseTx{}
   243  }
   244  
   245  func importTx() txs.UnsignedTx {
   246  	return &txs.ImportTx{}
   247  }
   248  
   249  func exportTx() txs.UnsignedTx {
   250  	return &txs.ExportTx{}
   251  }