From 37419238cadd13bcefc460d2c41531a34baf952b Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Sat, 10 Aug 2024 12:22:15 -0400 Subject: [PATCH 001/114] Add P-chain fee APIs --- vms/platformvm/client.go | 17 +++++++++++++++++ vms/platformvm/service.go | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/vms/platformvm/client.go b/vms/platformvm/client.go index 95377ce96758..4ea4aa21818e 100644 --- a/vms/platformvm/client.go +++ b/vms/platformvm/client.go @@ -16,6 +16,7 @@ import ( "github.com/ava-labs/avalanchego/utils/formatting/address" "github.com/ava-labs/avalanchego/utils/json" "github.com/ava-labs/avalanchego/utils/rpc" + "github.com/ava-labs/avalanchego/vms/components/fee" "github.com/ava-labs/avalanchego/vms/platformvm/status" ) @@ -121,6 +122,10 @@ type Client interface { GetBlock(ctx context.Context, blockID ids.ID, options ...rpc.Option) ([]byte, error) // GetBlockByHeight returns the block at the given [height]. GetBlockByHeight(ctx context.Context, height uint64, options ...rpc.Option) ([]byte, error) + // GetFeeConfig returns the dynamic fee config of the chain. + GetFeeConfig(ctx context.Context, options ...rpc.Option) (*fee.Config, error) + // GetFeeState returns the current fee state of the chain. + GetFeeState(ctx context.Context, options ...rpc.Option) (fee.State, fee.GasPrice, time.Time, error) } // Client implementation for interacting with the P Chain endpoint @@ -515,6 +520,18 @@ func (c *client) GetBlockByHeight(ctx context.Context, height uint64, options .. return formatting.Decode(res.Encoding, res.Block) } +func (c *client) GetFeeConfig(ctx context.Context, options ...rpc.Option) (*fee.Config, error) { + res := &fee.Config{} + err := c.requester.SendRequest(ctx, "platform.getFeeConfig", struct{}{}, res, options...) + return res, err +} + +func (c *client) GetFeeState(ctx context.Context, options ...rpc.Option) (fee.State, fee.GasPrice, time.Time, error) { + res := &GetFeeStateReply{} + err := c.requester.SendRequest(ctx, "platform.getFeeState", struct{}{}, res, options...) + return res.State, res.Price, res.Time, err +} + func AwaitTxAccepted( c Client, ctx context.Context, diff --git a/vms/platformvm/service.go b/vms/platformvm/service.go index 0299192b6677..6d7e856f89af 100644 --- a/vms/platformvm/service.go +++ b/vms/platformvm/service.go @@ -28,6 +28,7 @@ import ( "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/vms/components/avax" + "github.com/ava-labs/avalanchego/vms/components/fee" "github.com/ava-labs/avalanchego/vms/components/keystore" "github.com/ava-labs/avalanchego/vms/platformvm/fx" "github.com/ava-labs/avalanchego/vms/platformvm/reward" @@ -1828,6 +1829,42 @@ func (s *Service) GetBlockByHeight(_ *http.Request, args *api.GetBlockByHeightAr return err } +// GetFeeConfig returns the dynamic fee config of the chain. +func (s *Service) GetFeeConfig(_ *http.Request, _ *struct{}, reply *fee.Config) error { + s.vm.ctx.Log.Debug("API called", + zap.String("service", "platform"), + zap.String("method", "getFeeConfig"), + ) + + *reply = s.vm.DynamicFeeConfig + return nil +} + +type GetFeeStateReply struct { + fee.State + Price fee.GasPrice `json:"price"` + Time time.Time `json:"timestamp"` +} + +// GetFeeState returns the current fee state of the chain. +func (s *Service) GetFeeState(_ *http.Request, _ *struct{}, reply *GetFeeStateReply) error { + s.vm.ctx.Log.Debug("API called", + zap.String("service", "platform"), + zap.String("method", "getFeeState"), + ) + + s.vm.ctx.Lock.Lock() + defer s.vm.ctx.Lock.Unlock() + + reply.State = s.vm.state.GetFeeState() + reply.Price = s.vm.DynamicFeeConfig.MinGasPrice.MulExp( + reply.State.Excess, + s.vm.DynamicFeeConfig.ExcessConversionConstant, + ) + reply.Time = s.vm.state.GetTimestamp() + return nil +} + func (s *Service) getAPIUptime(staker *state.Staker) (*avajson.Float32, error) { // Only report uptimes that we have been actively tracking. if constants.PrimaryNetworkID != staker.SubnetID && !s.vm.TrackedSubnets.Contains(staker.SubnetID) { From 01aff13d436bfebe094ff7121d3f10202d7d90c4 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Sat, 10 Aug 2024 12:33:20 -0400 Subject: [PATCH 002/114] nit --- vms/platformvm/service.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/vms/platformvm/service.go b/vms/platformvm/service.go index 6d7e856f89af..285fd530cc16 100644 --- a/vms/platformvm/service.go +++ b/vms/platformvm/service.go @@ -1836,6 +1836,12 @@ func (s *Service) GetFeeConfig(_ *http.Request, _ *struct{}, reply *fee.Config) zap.String("method", "getFeeConfig"), ) + // TODO: Remove after Etna is activated. + now := time.Now() + if !s.vm.Config.UpgradeConfig.IsEtnaActivated(now) { + return nil + } + *reply = s.vm.DynamicFeeConfig return nil } From db2dff97ba55285841e63822e402d8884c5d9e2a Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 14:40:31 -0400 Subject: [PATCH 003/114] Add P-chain dynamic fees execution --- genesis/genesis_fuji.go | 2 +- genesis/genesis_local.go | 2 +- genesis/genesis_mainnet.go | 2 +- vms/platformvm/block/builder/builder.go | 230 ++++++++++++++---- vms/platformvm/block/executor/verifier.go | 56 ++++- .../block/executor/verifier_test.go | 6 + vms/platformvm/state/chain_time_helpers.go | 14 +- vms/platformvm/txs/executor/state_changes.go | 18 +- vms/platformvm/txs/fee/dynamic_calculator.go | 33 ++- wallet/chain/p/builder/context.go | 50 ---- wallet/chain/p/context.go | 79 ++++++ wallet/chain/p/wallet.go | 5 + wallet/subnet/primary/api.go | 3 +- 13 files changed, 385 insertions(+), 115 deletions(-) create mode 100644 wallet/chain/p/context.go diff --git a/genesis/genesis_fuji.go b/genesis/genesis_fuji.go index c47e691cc3f2..a267765e03ae 100644 --- a/genesis/genesis_fuji.go +++ b/genesis/genesis_fuji.go @@ -45,7 +45,7 @@ var ( MaxGasPerSecond: 1_000, TargetGasPerSecond: 500, MinGasPrice: 1, - ExcessConversionConstant: 1, + ExcessConversionConstant: 5_000, }, }, StakingConfig: StakingConfig{ diff --git a/genesis/genesis_local.go b/genesis/genesis_local.go index 095e664d249a..f5bbf5c4c7b7 100644 --- a/genesis/genesis_local.go +++ b/genesis/genesis_local.go @@ -63,7 +63,7 @@ var ( MaxGasPerSecond: 1_000, TargetGasPerSecond: 500, MinGasPrice: 1, - ExcessConversionConstant: 1, + ExcessConversionConstant: 5_000, }, }, StakingConfig: StakingConfig{ diff --git a/genesis/genesis_mainnet.go b/genesis/genesis_mainnet.go index e0e7228bb150..790a8e007630 100644 --- a/genesis/genesis_mainnet.go +++ b/genesis/genesis_mainnet.go @@ -45,7 +45,7 @@ var ( MaxGasPerSecond: 1_000, TargetGasPerSecond: 500, MinGasPrice: 1, - ExcessConversionConstant: 1, + ExcessConversionConstant: 5_000, }, }, StakingConfig: StakingConfig{ diff --git a/vms/platformvm/block/builder/builder.go b/vms/platformvm/block/builder/builder.go index 6cecad86184f..ffd9596228e6 100644 --- a/vms/platformvm/block/builder/builder.go +++ b/vms/platformvm/block/builder/builder.go @@ -25,8 +25,10 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/platformvm/txs/mempool" + feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) // targetBlockSize is maximum number of transaction bytes to place into a @@ -244,15 +246,33 @@ func (b *builder) PackAllBlockTxs() ([]*txs.Tx, error) { return nil, fmt.Errorf("%w: %s", errMissingPreferredState, preferredID) } - return packBlockTxs( - preferredID, - preferredState, - b.Mempool, - b.txExecutorBackend, - b.blkManager, - b.txExecutorBackend.Clk.Time(), - math.MaxInt, - ) + timestamp, _, err := state.NextBlockTime(preferredState, b.txExecutorBackend.Clk) + if err != nil { + return nil, fmt.Errorf("could not calculate next staker change time: %w", err) + } + + var blockTxs []*txs.Tx + if b.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) { + blockTxs, err = packEtnaBlockTxs( + preferredID, + preferredState, + b.Mempool, + b.txExecutorBackend, + b.blkManager, + timestamp, + ) + } else { + blockTxs, err = packDurangoBlockTxs( + preferredID, + preferredState, + b.Mempool, + b.txExecutorBackend, + b.blkManager, + timestamp, + math.MaxInt, + ) + } + return blockTxs, err } // [timestamp] is min(max(now, parent timestamp), next staker change time) @@ -264,15 +284,30 @@ func buildBlock( forceAdvanceTime bool, parentState state.Chain, ) (block.Block, error) { - blockTxs, err := packBlockTxs( - parentID, - parentState, - builder.Mempool, - builder.txExecutorBackend, - builder.blkManager, - timestamp, - targetBlockSize, + var ( + blockTxs []*txs.Tx + err error ) + if builder.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) { + blockTxs, err = packEtnaBlockTxs( + parentID, + parentState, + builder.Mempool, + builder.txExecutorBackend, + builder.blkManager, + timestamp, + ) + } else { + blockTxs, err = packDurangoBlockTxs( + parentID, + parentState, + builder.Mempool, + builder.txExecutorBackend, + builder.blkManager, + timestamp, + targetBlockSize, + ) + } if err != nil { return nil, fmt.Errorf("failed to pack block txs: %w", err) } @@ -314,7 +349,7 @@ func buildBlock( ) } -func packBlockTxs( +func packDurangoBlockTxs( parentID ids.ID, parentState state.Chain, mempool mempool.Mempool, @@ -346,55 +381,162 @@ func packBlockTxs( if txSize > remainingSize { break } - mempool.Remove(tx) - // Invariant: [tx] has already been syntactically verified. - - txDiff, err := state.NewDiffOn(stateDiff) + shouldAdd, err := executeTx( + parentID, + stateDiff, + mempool, + backend, + manager, + &inputs, + feeCalculator, + tx, + ) if err != nil { return nil, err } + if !shouldAdd { + continue + } + + remainingSize -= txSize + blockTxs = append(blockTxs, tx) + } + + return blockTxs, nil +} + +func packEtnaBlockTxs( + parentID ids.ID, + parentState state.Chain, + mempool mempool.Mempool, + backend *txexecutor.Backend, + manager blockexecutor.Manager, + timestamp time.Time, +) ([]*txs.Tx, error) { + stateDiff, err := state.NewDiffOn(parentState) + if err != nil { + return nil, err + } + + if _, err := txexecutor.AdvanceTimeTo(backend, stateDiff, timestamp); err != nil { + return nil, err + } + + feeState := stateDiff.GetFeeState() + return packEtnaBlockTxsOn(parentID, stateDiff, mempool, backend, manager, feeState.Capacity) +} - executor := &txexecutor.StandardTxExecutor{ - Backend: backend, - State: txDiff, - FeeCalculator: feeCalculator, - Tx: tx, +func packEtnaBlockTxsOn( + parentID ids.ID, + stateDiff state.Diff, + mempool mempool.Mempool, + backend *txexecutor.Backend, + manager blockexecutor.Manager, + capacity feecomponent.Gas, +) ([]*txs.Tx, error) { + var ( + blockTxs []*txs.Tx + inputs set.Set[ids.ID] + blockComplexity feecomponent.Dimensions + feeCalculator = state.PickFeeCalculator(backend.Config, stateDiff) + ) + for { + tx, exists := mempool.Peek() + if !exists { + break } - err = tx.Unsigned.Visit(executor) + txComplexity, err := txfee.TxComplexity(tx.Unsigned) if err != nil { - txID := tx.ID() - mempool.MarkDropped(txID, err) - continue + return nil, err } - - if inputs.Overlaps(executor.Inputs) { - txID := tx.ID() - mempool.MarkDropped(txID, blockexecutor.ErrConflictingBlockTxs) - continue + newBlockComplexity, err := blockComplexity.Add(&txComplexity) + if err != nil { + return nil, err } - err = manager.VerifyUniqueInputs(parentID, executor.Inputs) + newBlockGas, err := newBlockComplexity.ToGas(backend.Config.DynamicFeeConfig.Weights) if err != nil { - txID := tx.ID() - mempool.MarkDropped(txID, err) - continue + return nil, err + } + if newBlockGas > capacity { + break } - inputs.Union(executor.Inputs) - txDiff.AddTx(tx, status.Committed) - err = txDiff.Apply(stateDiff) + shouldAdd, err := executeTx( + parentID, + stateDiff, + mempool, + backend, + manager, + &inputs, + feeCalculator, + tx, + ) if err != nil { return nil, err } + if !shouldAdd { + continue + } - remainingSize -= txSize + blockComplexity = newBlockComplexity blockTxs = append(blockTxs, tx) } return blockTxs, nil } +func executeTx( + parentID ids.ID, + stateDiff state.Diff, + mempool mempool.Mempool, + backend *txexecutor.Backend, + manager blockexecutor.Manager, + inputs *set.Set[ids.ID], + feeCalculator txfee.Calculator, + tx *txs.Tx, +) (bool, error) { + mempool.Remove(tx) + + // Invariant: [tx] has already been syntactically verified. + + txDiff, err := state.NewDiffOn(stateDiff) + if err != nil { + return false, err + } + + executor := &txexecutor.StandardTxExecutor{ + Backend: backend, + State: txDiff, + FeeCalculator: feeCalculator, + Tx: tx, + } + + err = tx.Unsigned.Visit(executor) + if err != nil { + txID := tx.ID() + mempool.MarkDropped(txID, err) + return false, nil + } + + if inputs.Overlaps(executor.Inputs) { + txID := tx.ID() + mempool.MarkDropped(txID, blockexecutor.ErrConflictingBlockTxs) + return false, nil + } + err = manager.VerifyUniqueInputs(parentID, executor.Inputs) + if err != nil { + txID := tx.ID() + mempool.MarkDropped(txID, err) + return false, nil + } + inputs.Union(executor.Inputs) + + txDiff.AddTx(tx, status.Committed) + return true, txDiff.Apply(stateDiff) +} + // getNextStakerToReward returns the next staker txID to remove from the staking // set with a RewardValidatorTx rather than an AdvanceTimeTx. [chainTimestamp] // is the timestamp of the chain at the time this validator would be getting diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index e238a35c100e..c83741bd405d 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -15,7 +15,9 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" + + feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) var ( @@ -379,7 +381,7 @@ func (v *verifier) proposalBlock( onDecisionState state.Diff, onCommitState state.Diff, onAbortState state.Diff, - feeCalculator fee.Calculator, + feeCalculator txfee.Calculator, inputs set.Set[ids.ID], atomicRequests map[ids.ID]*atomic.Requests, onAcceptFunc func(), @@ -429,7 +431,7 @@ func (v *verifier) proposalBlock( // standardBlock populates the state of this block if [nil] is returned func (v *verifier) standardBlock( b *block.ApricotStandardBlock, - feeCalculator fee.Calculator, + feeCalculator txfee.Calculator, onAcceptState state.Diff, ) error { inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs(b.Transactions, feeCalculator, onAcceptState, b.Parent()) @@ -454,19 +456,42 @@ func (v *verifier) standardBlock( return nil } -func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculator, state state.Diff, parentID ids.ID) ( +func (v *verifier) processStandardTxs( + txs []*txs.Tx, + feeCalculator txfee.Calculator, + state state.Diff, + parentID ids.ID, +) ( set.Set[ids.ID], map[ids.ID]*atomic.Requests, func(), error, ) { + timestamp := state.GetTimestamp() + isEtnaActivated := v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) + var ( - onAcceptFunc func() - inputs set.Set[ids.ID] - funcs = make([]func(), 0, len(txs)) - atomicRequests = make(map[ids.ID]*atomic.Requests) + blockComplexity feecomponent.Dimensions + onAcceptFunc func() + inputs set.Set[ids.ID] + funcs = make([]func(), 0, len(txs)) + atomicRequests = make(map[ids.ID]*atomic.Requests) ) for _, tx := range txs { + if isEtnaActivated { + txComplexity, err := txfee.TxComplexity(tx.Unsigned) + if err != nil { + txID := tx.ID() + v.MarkDropped(txID, err) // cache tx as dropped + return nil, nil, nil, err + } + + blockComplexity, err = blockComplexity.Add(&txComplexity) + if err != nil { + return nil, nil, nil, err + } + } + txExecutor := executor.StandardTxExecutor{ Backend: v.txExecutorBackend, State: state, @@ -503,6 +528,21 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato } } + if isEtnaActivated { + blockGas, err := blockComplexity.ToGas(v.txExecutorBackend.Config.DynamicFeeConfig.Weights) + if err != nil { + return nil, nil, nil, err + } + + feeState := state.GetFeeState() + feeState, err = feeState.ConsumeGas(blockGas) + if err != nil { + return nil, nil, nil, err + } + + state.SetFeeState(feeState) + } + if err := v.verifyUniqueInputs(parentID, inputs); err != nil { return nil, nil, nil, err } diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index 5c058e7c69ee..0b245895879e 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -231,6 +231,9 @@ func TestVerifierVisitStandardBlock(t *testing.T) { UpgradeConfig: upgrade.Config{ ApricotPhase5Time: time.Now().Add(time.Hour), BanffTime: mockable.MaxTime, // banff is not activated + CortinaTime: mockable.MaxTime, + DurangoTime: mockable.MaxTime, + EtnaTime: mockable.MaxTime, }, }, Clk: &mockable.Clock{}, @@ -716,6 +719,9 @@ func TestVerifierVisitStandardBlockWithDuplicateInputs(t *testing.T) { UpgradeConfig: upgrade.Config{ ApricotPhase5Time: time.Now().Add(time.Hour), BanffTime: mockable.MaxTime, // banff is not activated + CortinaTime: mockable.MaxTime, + DurangoTime: mockable.MaxTime, + EtnaTime: mockable.MaxTime, }, }, Clk: &mockable.Clock{}, diff --git a/vms/platformvm/state/chain_time_helpers.go b/vms/platformvm/state/chain_time_helpers.go index 7b5dd6ebe10b..ee9d205d50a6 100644 --- a/vms/platformvm/state/chain_time_helpers.go +++ b/vms/platformvm/state/chain_time_helpers.go @@ -77,7 +77,19 @@ func GetNextStakerChangeTime(state Chain) (time.Time, error) { // PickFeeCalculator does not modify [state]. func PickFeeCalculator(cfg *config.Config, state Chain) fee.Calculator { timestamp := state.GetTimestamp() - return NewStaticFeeCalculator(cfg, timestamp) + if !cfg.UpgradeConfig.IsEtnaActivated(timestamp) { + return NewStaticFeeCalculator(cfg, timestamp) + } + + feeState := state.GetFeeState() + gasPrice := cfg.DynamicFeeConfig.MinGasPrice.MulExp( + feeState.Excess, + cfg.DynamicFeeConfig.ExcessConversionConstant, + ) + return fee.NewDynamicCalculator( + cfg.DynamicFeeConfig.Weights, + gasPrice, + ) } // NewStaticFeeCalculator creates a static fee calculator, with the config set diff --git a/vms/platformvm/txs/executor/state_changes.go b/vms/platformvm/txs/executor/state_changes.go index 3086358304a3..328391cec907 100644 --- a/vms/platformvm/txs/executor/state_changes.go +++ b/vms/platformvm/txs/executor/state_changes.go @@ -165,12 +165,22 @@ func AdvanceTimeTo( changed = true } - if err := changes.Apply(parentState); err != nil { - return false, err + if backend.Config.UpgradeConfig.IsEtnaActivated(newChainTime) { + previousChainTime := changes.GetTimestamp() + duration := uint64(newChainTime.Sub(previousChainTime) / time.Second) + + feeState := changes.GetFeeState() + feeState = feeState.AdvanceTime( + backend.Config.DynamicFeeConfig.MaxGasCapacity, + backend.Config.DynamicFeeConfig.MaxGasPerSecond, + backend.Config.DynamicFeeConfig.TargetGasPerSecond, + duration, + ) + changes.SetFeeState(feeState) } - parentState.SetTimestamp(newChainTime) - return changed, nil + changes.SetTimestamp(newChainTime) + return changed, changes.Apply(parentState) } func GetRewardsCalculator( diff --git a/vms/platformvm/txs/fee/dynamic_calculator.go b/vms/platformvm/txs/fee/dynamic_calculator.go index 1cd385dafb9b..a9cc335437ca 100644 --- a/vms/platformvm/txs/fee/dynamic_calculator.go +++ b/vms/platformvm/txs/fee/dynamic_calculator.go @@ -4,11 +4,20 @@ package fee import ( + "errors" + "fmt" + "github.com/ava-labs/avalanchego/vms/components/fee" "github.com/ava-labs/avalanchego/vms/platformvm/txs" ) -var _ Calculator = (*dynamicCalculator)(nil) +var ( + _ Calculator = (*dynamicCalculator)(nil) + + ErrCalculatingComplexity = errors.New("error calculating complexity") + ErrCalculatingGas = errors.New("error calculating gas") + ErrCalculatingFee = errors.New("error calculating fee") +) func NewDynamicCalculator( weights fee.Dimensions, @@ -28,11 +37,27 @@ type dynamicCalculator struct { func (c *dynamicCalculator) CalculateFee(tx txs.UnsignedTx) (uint64, error) { complexity, err := TxComplexity(tx) if err != nil { - return 0, err + return 0, fmt.Errorf("%w: %w", ErrCalculatingComplexity, err) } gas, err := complexity.ToGas(c.weights) if err != nil { - return 0, err + return 0, fmt.Errorf( + "%w with complexity (%v) and weights (%v): %w", + ErrCalculatingGas, + complexity, + c.weights, + err, + ) + } + fee, err := gas.Cost(c.price) + if err != nil { + return 0, fmt.Errorf( + "%w with gas (%d) and price (%d): %w", + ErrCalculatingFee, + gas, + c.price, + err, + ) } - return gas.Cost(c.price) + return fee, nil } diff --git a/wallet/chain/p/builder/context.go b/wallet/chain/p/builder/context.go index 3729edca2deb..d90c3eab92a8 100644 --- a/wallet/chain/p/builder/context.go +++ b/wallet/chain/p/builder/context.go @@ -4,14 +4,10 @@ package builder import ( - "context" - - "github.com/ava-labs/avalanchego/api/info" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/logging" - "github.com/ava-labs/avalanchego/vms/avm" feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" @@ -27,52 +23,6 @@ type Context struct { GasPrice feecomponent.GasPrice } -func NewContextFromURI(ctx context.Context, uri string) (*Context, error) { - infoClient := info.NewClient(uri) - xChainClient := avm.NewClient(uri, "X") - return NewContextFromClients(ctx, infoClient, xChainClient) -} - -func NewContextFromClients( - ctx context.Context, - infoClient info.Client, - xChainClient avm.Client, -) (*Context, error) { - networkID, err := infoClient.GetNetworkID(ctx) - if err != nil { - return nil, err - } - - asset, err := xChainClient.GetAssetDescription(ctx, "AVAX") - if err != nil { - return nil, err - } - - txFees, err := infoClient.GetTxFee(ctx) - if err != nil { - return nil, err - } - - return &Context{ - NetworkID: networkID, - AVAXAssetID: asset.AssetID, - StaticFeeConfig: txfee.StaticConfig{ - TxFee: uint64(txFees.TxFee), - CreateSubnetTxFee: uint64(txFees.CreateSubnetTxFee), - TransformSubnetTxFee: uint64(txFees.TransformSubnetTxFee), - CreateBlockchainTxFee: uint64(txFees.CreateBlockchainTxFee), - AddPrimaryNetworkValidatorFee: uint64(txFees.AddPrimaryNetworkValidatorFee), - AddPrimaryNetworkDelegatorFee: uint64(txFees.AddPrimaryNetworkDelegatorFee), - AddSubnetValidatorFee: uint64(txFees.AddSubnetValidatorFee), - AddSubnetDelegatorFee: uint64(txFees.AddSubnetDelegatorFee), - }, - - // TODO: Populate these fields once they are exposed by the API - ComplexityWeights: feecomponent.Dimensions{}, - GasPrice: 0, - }, nil -} - func NewSnowContext(networkID uint32, avaxAssetID ids.ID) (*snow.Context, error) { lookup := ids.NewAliaser() return &snow.Context{ diff --git a/wallet/chain/p/context.go b/wallet/chain/p/context.go new file mode 100644 index 000000000000..efd39eff532f --- /dev/null +++ b/wallet/chain/p/context.go @@ -0,0 +1,79 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package p + +import ( + "context" + + "github.com/ava-labs/avalanchego/api/info" + "github.com/ava-labs/avalanchego/vms/avm" + "github.com/ava-labs/avalanchego/vms/platformvm" + "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" +) + +func NewContextFromURI(ctx context.Context, uri string) (*builder.Context, error) { + infoClient := info.NewClient(uri) + xChainClient := avm.NewClient(uri, "X") + pChainClient := platformvm.NewClient(uri) + return NewContextFromClients(ctx, infoClient, xChainClient, pChainClient) +} + +func NewContextFromClients( + ctx context.Context, + infoClient info.Client, + xChainClient avm.Client, + pChainClient platformvm.Client, +) (*builder.Context, error) { + networkID, err := infoClient.GetNetworkID(ctx) + if err != nil { + return nil, err + } + + asset, err := xChainClient.GetAssetDescription(ctx, "AVAX") + if err != nil { + return nil, err + } + + dynamicFeeConfig, err := pChainClient.GetFeeConfig(ctx) + if err != nil { + return nil, err + } + + // TOOD: After Etna is activated, assume the gas price is always non-zero. + if dynamicFeeConfig.MinGasPrice != 0 { + _, gasPrice, _, err := pChainClient.GetFeeState(ctx) + if err != nil { + return nil, err + } + + return &builder.Context{ + NetworkID: networkID, + AVAXAssetID: asset.AssetID, + ComplexityWeights: dynamicFeeConfig.Weights, + GasPrice: gasPrice, + }, nil + } + + staticFeeConfig, err := infoClient.GetTxFee(ctx) + if err != nil { + return nil, err + } + + return &builder.Context{ + NetworkID: networkID, + AVAXAssetID: asset.AssetID, + StaticFeeConfig: txfee.StaticConfig{ + TxFee: uint64(staticFeeConfig.TxFee), + CreateSubnetTxFee: uint64(staticFeeConfig.CreateSubnetTxFee), + TransformSubnetTxFee: uint64(staticFeeConfig.TransformSubnetTxFee), + CreateBlockchainTxFee: uint64(staticFeeConfig.CreateBlockchainTxFee), + AddPrimaryNetworkValidatorFee: uint64(staticFeeConfig.AddPrimaryNetworkValidatorFee), + AddPrimaryNetworkDelegatorFee: uint64(staticFeeConfig.AddPrimaryNetworkDelegatorFee), + AddSubnetValidatorFee: uint64(staticFeeConfig.AddSubnetValidatorFee), + AddSubnetDelegatorFee: uint64(staticFeeConfig.AddSubnetDelegatorFee), + }, + }, nil +} diff --git a/wallet/chain/p/wallet.go b/wallet/chain/p/wallet.go index 631553431ef7..968600c08e48 100644 --- a/wallet/chain/p/wallet.go +++ b/wallet/chain/p/wallet.go @@ -4,7 +4,9 @@ package p import ( + "encoding/json" "errors" + "fmt" "time" "github.com/ava-labs/avalanchego/ids" @@ -508,6 +510,9 @@ func (w *wallet) IssueTx( ctx := ops.Context() txID, err := w.client.IssueTx(ctx, tx.Bytes()) if err != nil { + if txJSON, jsonErr := json.MarshalIndent(tx, "", "\t"); jsonErr == nil { + err = fmt.Errorf("failed to issue tx:\n%s\n%w", string(txJSON), err) + } return err } diff --git a/wallet/subnet/primary/api.go b/wallet/subnet/primary/api.go index 2aedc5c476c9..d9f9e5e0624a 100644 --- a/wallet/subnet/primary/api.go +++ b/wallet/subnet/primary/api.go @@ -21,6 +21,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/wallet/chain/c" + "github.com/ava-labs/avalanchego/wallet/chain/p" "github.com/ava-labs/avalanchego/wallet/chain/x" pbuilder "github.com/ava-labs/avalanchego/wallet/chain/p/builder" @@ -79,7 +80,7 @@ func FetchState( xClient := avm.NewClient(uri, "X") cClient := evm.NewCChainClient(uri) - pCTX, err := pbuilder.NewContextFromClients(ctx, infoClient, xClient) + pCTX, err := p.NewContextFromClients(ctx, infoClient, xClient, pClient) if err != nil { return nil, err } From f25e19906860c85ce289be12f600f00131b64251 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 14:46:27 -0400 Subject: [PATCH 004/114] Pack all etna txs --- vms/platformvm/block/builder/builder.go | 33 +++++++++++++++---------- 1 file changed, 20 insertions(+), 13 deletions(-) diff --git a/vms/platformvm/block/builder/builder.go b/vms/platformvm/block/builder/builder.go index ffd9596228e6..46e3102c7fad 100644 --- a/vms/platformvm/block/builder/builder.go +++ b/vms/platformvm/block/builder/builder.go @@ -251,18 +251,8 @@ func (b *builder) PackAllBlockTxs() ([]*txs.Tx, error) { return nil, fmt.Errorf("could not calculate next staker change time: %w", err) } - var blockTxs []*txs.Tx - if b.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) { - blockTxs, err = packEtnaBlockTxs( - preferredID, - preferredState, - b.Mempool, - b.txExecutorBackend, - b.blkManager, - timestamp, - ) - } else { - blockTxs, err = packDurangoBlockTxs( + if !b.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) { + return packDurangoBlockTxs( preferredID, preferredState, b.Mempool, @@ -272,7 +262,24 @@ func (b *builder) PackAllBlockTxs() ([]*txs.Tx, error) { math.MaxInt, ) } - return blockTxs, err + + stateDiff, err := state.NewDiffOn(preferredState) + if err != nil { + return nil, err + } + + if _, err := txexecutor.AdvanceTimeTo(b.txExecutorBackend, stateDiff, timestamp); err != nil { + return nil, err + } + + return packEtnaBlockTxsOn( + preferredID, + stateDiff, + b.Mempool, + b.txExecutorBackend, + b.blkManager, + math.MaxUint64, + ) } // [timestamp] is min(max(now, parent timestamp), next staker change time) From 350f65d9b2c9836b2aa8f6fd85c37aafba7e66b1 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 14:52:03 -0400 Subject: [PATCH 005/114] fix lint --- wallet/chain/p/context.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wallet/chain/p/context.go b/wallet/chain/p/context.go index efd39eff532f..7c2d0383ab92 100644 --- a/wallet/chain/p/context.go +++ b/wallet/chain/p/context.go @@ -42,7 +42,7 @@ func NewContextFromClients( return nil, err } - // TOOD: After Etna is activated, assume the gas price is always non-zero. + // TODO: After Etna is activated, assume the gas price is always non-zero. if dynamicFeeConfig.MinGasPrice != 0 { _, gasPrice, _, err := pChainClient.GetFeeState(ctx) if err != nil { From 423ae82de699427a94b851bfd4f5099dd58cf179 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 15:47:47 -0400 Subject: [PATCH 006/114] wip fix e2e --- tests/e2e/p/util.go | 16 +++ tests/e2e/p/workflow.go | 269 ++++++++++++++++++-------------------- wallet/chain/p/context.go | 6 +- 3 files changed, 147 insertions(+), 144 deletions(-) create mode 100644 tests/e2e/p/util.go diff --git a/tests/e2e/p/util.go b/tests/e2e/p/util.go new file mode 100644 index 000000000000..6d31201f8f09 --- /dev/null +++ b/tests/e2e/p/util.go @@ -0,0 +1,16 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package p + +import ( + "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" + "github.com/ava-labs/avalanchego/wallet/chain/p/builder" +) + +func feeCalculatorFromContext(context *builder.Context) fee.Calculator { + if context.GasPrice != 0 { + return fee.NewDynamicCalculator(context.ComplexityWeights, context.GasPrice) + } + return fee.NewStaticCalculator(context.StaticFeeConfig) +} diff --git a/tests/e2e/p/workflow.go b/tests/e2e/p/workflow.go index fc539010ed53..af69b5e4871f 100644 --- a/tests/e2e/p/workflow.go +++ b/tests/e2e/p/workflow.go @@ -8,7 +8,6 @@ import ( "github.com/stretchr/testify/require" - "github.com/ava-labs/avalanchego/api/info" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/tests/fixture/e2e" "github.com/ava-labs/avalanchego/utils" @@ -25,177 +24,161 @@ import ( ) // PChainWorkflow is an integration test for normal P-Chain operations -// - Issues an Add Validator and an Add Delegator using the funding address -// - Exports AVAX from the P-Chain funding address to the X-Chain created address -// - Exports AVAX from the X-Chain created address to the P-Chain created address -// - Checks the expected value of the funding address +// - Issues an AddPermissionlessValidatorTx +// - Issues an AddPermissionlessDelegatorTx +// - Issues an ExportTx on the P-chain and verifies the expected balances +// - Issues an ImportTx on the X-chain and verifies the expected balances var _ = e2e.DescribePChain("[Workflow]", func() { tc := e2e.NewTestContext() require := require.New(tc) - ginkgo.It("P-chain main operations", - func() { - env := e2e.GetEnv(tc) - - nodeURI := env.GetRandomNodeURI() - keychain := env.NewKeychain(2) - baseWallet := e2e.NewWallet(tc, keychain, nodeURI) - - pWallet := baseWallet.P() - pBuilder := pWallet.Builder() - pContext := pBuilder.Context() - avaxAssetID := pContext.AVAXAssetID - xWallet := baseWallet.X() - xBuilder := xWallet.Builder() - xContext := xBuilder.Context() - pChainClient := platformvm.NewClient(nodeURI.URI) - - tc.Outf("{{blue}} fetching minimal stake amounts {{/}}\n") - minValStake, minDelStake, err := pChainClient.GetMinStake(tc.DefaultContext(), constants.PlatformChainID) - require.NoError(err) - tc.Outf("{{green}} minimal validator stake: %d {{/}}\n", minValStake) - tc.Outf("{{green}} minimal delegator stake: %d {{/}}\n", minDelStake) + const ( + // amount to transfer from P to X chain + toTransfer = 1 * units.Avax + delegationFeeShares uint32 = 20000 // TODO: retrieve programmatically + ) - tc.Outf("{{blue}} fetching tx fee {{/}}\n") - infoClient := info.NewClient(nodeURI.URI) - fees, err := infoClient.GetTxFee(tc.DefaultContext()) - require.NoError(err) - txFees := uint64(fees.TxFee) - tc.Outf("{{green}} txFee: %d {{/}}\n", txFees) - - // amount to transfer from P to X chain - toTransfer := 1 * units.Avax - - pShortAddr := keychain.Keys[0].Address() - xTargetAddr := keychain.Keys[1].Address() - tc.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. - validatorID, err := ids.ToNodeID(utils.RandomBytes(ids.NodeIDLen)) - require.NoError(err) + ginkgo.It("P-chain main operations", func() { + env := e2e.GetEnv(tc) - vdr := &txs.SubnetValidator{ - Validator: txs.Validator{ - NodeID: validatorID, - End: uint64(time.Now().Add(72 * time.Hour).Unix()), - Wght: minValStake, - }, - Subnet: constants.PrimaryNetworkID, + var ( + nodeURI = env.GetRandomNodeURI() + keychain = env.NewKeychain(2) + + rewardAddr = keychain.Keys[0].Address() + rewardOwner = &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{rewardAddr}, } - rewardOwner := &secp256k1fx.OutputOwners{ + + transferAddr = keychain.Keys[1].Address() + transferOwner = secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{pShortAddr}, + Addrs: []ids.ShortID{transferAddr}, } - shares := uint32(20000) // TODO: retrieve programmatically + baseWallet = e2e.NewWallet(tc, keychain, nodeURI) + + pWallet = baseWallet.P() + pBuilder = pWallet.Builder() + pContext = pBuilder.Context() + avaxAssetID = pContext.AVAXAssetID + pChainFeeCalculator = feeCalculatorFromContext(pContext) + + xWallet = baseWallet.X() + xBuilder = xWallet.Builder() + xContext = xBuilder.Context() + ) + + tc.Outf("{{blue}} fetching minimal stake amounts {{/}}\n") + pChainClient := platformvm.NewClient(nodeURI.URI) + minValStake, minDelStake, err := pChainClient.GetMinStake( + tc.DefaultContext(), + constants.PlatformChainID, + ) + require.NoError(err) + tc.Outf("{{green}} minimal validator stake: %d {{/}}\n", minValStake) + tc.Outf("{{green}} minimal delegator stake: %d {{/}}\n", minDelStake) + + // Use a random node ID to ensure that repeated test runs will succeed + // against a network that persists across runs. + validatorID, err := ids.ToNodeID(utils.RandomBytes(ids.NodeIDLen)) + require.NoError(err) + + vdr := &txs.SubnetValidator{ + Validator: txs.Validator{ + NodeID: validatorID, + End: uint64(time.Now().Add(72 * time.Hour).Unix()), + Wght: minValStake, + }, + Subnet: constants.PrimaryNetworkID, + } + + tc.By("issue add validator tx", func() { sk, err := bls.NewSecretKey() require.NoError(err) pop := signer.NewProofOfPossession(sk) - tc.By("issue add validator tx", func() { - _, err := pWallet.IssueAddPermissionlessValidatorTx( - vdr, - pop, - avaxAssetID, - rewardOwner, - rewardOwner, - shares, - tc.WithDefaultContext(), - ) - require.NoError(err) - }) - - tc.By("issue add delegator tx", func() { - _, err := pWallet.IssueAddPermissionlessDelegatorTx( - vdr, - avaxAssetID, - rewardOwner, - tc.WithDefaultContext(), - ) - require.NoError(err) - }) - - // retrieve initial balances - pBalances, err := pWallet.Builder().GetBalance() + _, err = pWallet.IssueAddPermissionlessValidatorTx( + vdr, + pop, + avaxAssetID, + rewardOwner, + rewardOwner, + delegationFeeShares, + tc.WithDefaultContext(), + ) require.NoError(err) - pStartBalance := pBalances[avaxAssetID] - tc.Outf("{{blue}} P-chain balance before P->X export: %d {{/}}\n", pStartBalance) + }) - xBalances, err := xWallet.Builder().GetFTBalance() + tc.By("issue add delegator tx", func() { + _, err := pWallet.IssueAddPermissionlessDelegatorTx( + vdr, + avaxAssetID, + rewardOwner, + tc.WithDefaultContext(), + ) require.NoError(err) - xStartBalance := xBalances[avaxAssetID] - tc.Outf("{{blue}} X-chain balance before P->X export: %d {{/}}\n", xStartBalance) + }) - outputOwner := secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ - xTargetAddr, - }, - } - output := &secp256k1fx.TransferOutput{ - Amt: toTransfer, - OutputOwners: outputOwner, - } + tc.By("export avax from P to X chain", func() { + balances, err := pBuilder.GetBalance() + require.NoError(err) + + initialAVAXBalance := balances[avaxAssetID] + tc.Outf("{{blue}} P-chain balance before P->X export: %d {{/}}\n", initialAVAXBalance) - tc.By("export avax from P to X chain", func() { - _, err := pWallet.IssueExportTx( - xContext.BlockchainID, - []*avax.TransferableOutput{ - { - Asset: avax.Asset{ - ID: avaxAssetID, - }, - Out: output, + exportTx, err := pWallet.IssueExportTx( + xContext.BlockchainID, + []*avax.TransferableOutput{ + { + Asset: avax.Asset{ + ID: avaxAssetID, + }, + Out: &secp256k1fx.TransferOutput{ + Amt: toTransfer, + OutputOwners: transferOwner, }, }, - tc.WithDefaultContext(), - ) - require.NoError(err) - }) + }, + tc.WithDefaultContext(), + ) + require.NoError(err) - // check balances post export - pBalances, err = pWallet.Builder().GetBalance() + exportFee, err := pChainFeeCalculator.CalculateFee(exportTx.Unsigned) require.NoError(err) - pPreImportBalance := pBalances[avaxAssetID] - tc.Outf("{{blue}} P-chain balance after P->X export: %d {{/}}\n", pPreImportBalance) - xBalances, err = xWallet.Builder().GetFTBalance() + balances, err = pBuilder.GetBalance() require.NoError(err) - xPreImportBalance := xBalances[avaxAssetID] - tc.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) - - tc.By("import avax from P into X chain", func() { - _, err := xWallet.IssueImportTx( - constants.PlatformChainID, - &outputOwner, - tc.WithDefaultContext(), - ) - require.NoError(err) - }) - - // check balances post import - pBalances, err = pWallet.Builder().GetBalance() + + finalAVAXBalance := balances[avaxAssetID] + tc.Outf("{{blue}} P-chain balance after P->X export: %d {{/}}\n", finalAVAXBalance) + + require.Equal(initialAVAXBalance-toTransfer-exportFee, finalAVAXBalance) + }) + + tc.By("import avax from P into X chain", func() { + balances, err := xBuilder.GetFTBalance() + require.NoError(err) + + initialAVAXBalance := balances[avaxAssetID] + tc.Outf("{{blue}} X-chain balance before P->X import: %d {{/}}\n", initialAVAXBalance) + + _, err = xWallet.IssueImportTx( + constants.PlatformChainID, + &transferOwner, + tc.WithDefaultContext(), + ) require.NoError(err) - pFinalBalance := pBalances[avaxAssetID] - tc.Outf("{{blue}} P-chain balance after P->X import: %d {{/}}\n", pFinalBalance) - xBalances, err = xWallet.Builder().GetFTBalance() + balances, err = xBuilder.GetFTBalance() require.NoError(err) - xFinalBalance := xBalances[avaxAssetID] - tc.Outf("{{blue}} X-chain balance after P->X import: %d {{/}}\n", xFinalBalance) - require.Equal(xFinalBalance, xPreImportBalance+toTransfer-txFees) // import not performed yet - require.Equal(pFinalBalance, pPreImportBalance) + finalAVAXBalance := balances[avaxAssetID] + tc.Outf("{{blue}} X-chain balance after P->X import: %d {{/}}\n", finalAVAXBalance) + + require.Equal(initialAVAXBalance+toTransfer-xContext.BaseTxFee, finalAVAXBalance) }) + }) }) diff --git a/wallet/chain/p/context.go b/wallet/chain/p/context.go index 7c2d0383ab92..a1a801c13fde 100644 --- a/wallet/chain/p/context.go +++ b/wallet/chain/p/context.go @@ -53,7 +53,11 @@ func NewContextFromClients( NetworkID: networkID, AVAXAssetID: asset.AssetID, ComplexityWeights: dynamicFeeConfig.Weights, - GasPrice: gasPrice, + // The gas price is doubled to attempt to handle concurrent tx + // issuance. + // + // TODO: Handle this better. Either here or in the mempool. + GasPrice: 2 * gasPrice, }, nil } From 7bd5779d72069ec8c0bc2c45e3d14f8de0462a85 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 15:49:49 -0400 Subject: [PATCH 007/114] nit --- tests/e2e/p/workflow.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/e2e/p/workflow.go b/tests/e2e/p/workflow.go index af69b5e4871f..caa48dea5021 100644 --- a/tests/e2e/p/workflow.go +++ b/tests/e2e/p/workflow.go @@ -95,7 +95,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { Subnet: constants.PrimaryNetworkID, } - tc.By("issue add validator tx", func() { + tc.By("issue AddPermissionlessValidatorTx", func() { sk, err := bls.NewSecretKey() require.NoError(err) pop := signer.NewProofOfPossession(sk) @@ -112,7 +112,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { require.NoError(err) }) - tc.By("issue add delegator tx", func() { + tc.By("issue AddPermissionlessDelegatorTx", func() { _, err := pWallet.IssueAddPermissionlessDelegatorTx( vdr, avaxAssetID, @@ -122,7 +122,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { require.NoError(err) }) - tc.By("export avax from P to X chain", func() { + tc.By("issue ExportTx on the P-chain", func() { balances, err := pBuilder.GetBalance() require.NoError(err) @@ -158,7 +158,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { require.Equal(initialAVAXBalance-toTransfer-exportFee, finalAVAXBalance) }) - tc.By("import avax from P into X chain", func() { + tc.By("issue ImportTx on the X-Chain", func() { balances, err := xBuilder.GetFTBalance() require.NoError(err) From c971ef55da4a49efeb17fe71ce17c39096ff9e0f Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 15:54:06 -0400 Subject: [PATCH 008/114] nit --- tests/e2e/p/workflow.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/e2e/p/workflow.go b/tests/e2e/p/workflow.go index caa48dea5021..394071f79e3b 100644 --- a/tests/e2e/p/workflow.go +++ b/tests/e2e/p/workflow.go @@ -95,7 +95,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { Subnet: constants.PrimaryNetworkID, } - tc.By("issue AddPermissionlessValidatorTx", func() { + tc.By("issuing an AddPermissionlessValidatorTx", func() { sk, err := bls.NewSecretKey() require.NoError(err) pop := signer.NewProofOfPossession(sk) @@ -112,7 +112,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { require.NoError(err) }) - tc.By("issue AddPermissionlessDelegatorTx", func() { + tc.By("issuing an AddPermissionlessDelegatorTx", func() { _, err := pWallet.IssueAddPermissionlessDelegatorTx( vdr, avaxAssetID, @@ -122,7 +122,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { require.NoError(err) }) - tc.By("issue ExportTx on the P-chain", func() { + tc.By("issuing an ExportTx on the P-chain", func() { balances, err := pBuilder.GetBalance() require.NoError(err) @@ -158,7 +158,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { require.Equal(initialAVAXBalance-toTransfer-exportFee, finalAVAXBalance) }) - tc.By("issue ImportTx on the X-Chain", func() { + tc.By("issuing an ImportTx on the X-Chain", func() { balances, err := xBuilder.GetFTBalance() require.NoError(err) From f043cfac379924d231bf1ab40e74488dae119422 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 13 Aug 2024 16:01:40 -0400 Subject: [PATCH 009/114] nit --- tests/e2e/p/workflow.go | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/tests/e2e/p/workflow.go b/tests/e2e/p/workflow.go index 394071f79e3b..bf97d563adbb 100644 --- a/tests/e2e/p/workflow.go +++ b/tests/e2e/p/workflow.go @@ -60,15 +60,16 @@ var _ = e2e.DescribePChain("[Workflow]", func() { baseWallet = e2e.NewWallet(tc, keychain, nodeURI) - pWallet = baseWallet.P() - pBuilder = pWallet.Builder() - pContext = pBuilder.Context() - avaxAssetID = pContext.AVAXAssetID - pChainFeeCalculator = feeCalculatorFromContext(pContext) + pWallet = baseWallet.P() + pBuilder = pWallet.Builder() + pContext = pBuilder.Context() + pFeeCalculator = feeCalculatorFromContext(pContext) xWallet = baseWallet.X() xBuilder = xWallet.Builder() xContext = xBuilder.Context() + + avaxAssetID = pContext.AVAXAssetID ) tc.Outf("{{blue}} fetching minimal stake amounts {{/}}\n") @@ -146,7 +147,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() { ) require.NoError(err) - exportFee, err := pChainFeeCalculator.CalculateFee(exportTx.Unsigned) + exportFee, err := pFeeCalculator.CalculateFee(exportTx.Unsigned) require.NoError(err) balances, err = pBuilder.GetBalance() From 4265bde3cf86e85b1855758dcb0136d8041c6ba9 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 14 Aug 2024 14:41:06 -0400 Subject: [PATCH 010/114] wip --- tests/e2e/p/staking_rewards.go | 139 +++++++++++++++------------------ tests/e2e/p/util.go | 10 +++ tests/e2e/p/workflow.go | 11 +-- 3 files changed, 80 insertions(+), 80 deletions(-) diff --git a/tests/e2e/p/staking_rewards.go b/tests/e2e/p/staking_rewards.go index 2eff3f212a71..c0d2cc764c46 100644 --- a/tests/e2e/p/staking_rewards.go +++ b/tests/e2e/p/staking_rewards.go @@ -27,19 +27,25 @@ import ( ginkgo "github.com/onsi/ginkgo/v2" ) -const ( - targetDelegationPeriod = 15 * time.Second - targetValidationPeriod = 30 * time.Second -) - var _ = ginkgo.Describe("[Staking Rewards]", func() { - tc := e2e.NewTestContext() - require := require.New(tc) - + const ( + targetDelegationPeriod = 15 * time.Second + targetValidationPeriod = 30 * time.Second + + delegationPercent = 0.10 // 10% + delegationShare = reward.PercentDenominator * delegationPercent + weight = 2_000 * units.Avax + ) + + var ( + tc = e2e.NewTestContext() + require = require.New(tc) + ) ginkgo.It("should ensure that validator node uptime determines whether a staking reward is issued", func() { - env := e2e.GetEnv(tc) - - network := env.GetNetwork() + var ( + env = e2e.GetEnv(tc) + network = env.GetNetwork() + ) tc.By("checking that the network has a compatible minimum stake duration", func() { minStakeDuration := cast.ToDuration(network.DefaultFlags[config.MinStakeDurationKey]) @@ -68,68 +74,50 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { betaNodeID, betaPOP, err := betaInfoClient.GetNodeID(tc.DefaultContext()) require.NoError(err) - tc.By("generating reward keys") - - alphaValidationRewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - alphaDelegationRewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - - betaValidationRewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - betaDelegationRewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - - gammaDelegationRewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - - deltaDelegationRewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - - rewardKeys := []*secp256k1.PrivateKey{ - alphaValidationRewardKey, - alphaDelegationRewardKey, - betaValidationRewardKey, - betaDelegationRewardKey, - gammaDelegationRewardKey, - deltaDelegationRewardKey, - } - tc.By("creating keychain and P-Chain wallet") - keychain := secp256k1fx.NewKeychain(rewardKeys...) - fundedKey := env.AllocatePreFundedKey() - keychain.Add(fundedKey) - nodeURI := tmpnet.NodeURI{ - NodeID: alphaNodeID, - URI: alphaNode.URI, - } - baseWallet := e2e.NewWallet(tc, keychain, nodeURI) - pWallet := baseWallet.P() + var ( + alphaValidationRewardKey = newKey(tc) + alphaDelegationRewardKey = newKey(tc) + betaValidationRewardKey = newKey(tc) + betaDelegationRewardKey = newKey(tc) + gammaDelegationRewardKey = newKey(tc) + deltaDelegationRewardKey = newKey(tc) + + rewardKeys = []*secp256k1.PrivateKey{ + alphaValidationRewardKey, + alphaDelegationRewardKey, + betaValidationRewardKey, + betaDelegationRewardKey, + gammaDelegationRewardKey, + deltaDelegationRewardKey, + } - pBuilder := pWallet.Builder() - pContext := pBuilder.Context() + keychain = env.NewKeychain(1) + nodeURI = tmpnet.NodeURI{ + NodeID: alphaNodeID, + URI: alphaNode.URI, + } + baseWallet = e2e.NewWallet(tc, keychain, nodeURI) + pWallet = baseWallet.P() + pBuilder = pWallet.Builder() + pContext = pBuilder.Context() - const ( - delegationPercent = 0.10 // 10% - delegationShare = reward.PercentDenominator * delegationPercent - weight = 2_000 * units.Avax + pvmClient = platformvm.NewClient(alphaNode.URI) ) - pvmClient := platformvm.NewClient(alphaNode.URI) - - tc.By("retrieving supply before inserting validators") - supplyAtValidatorsStart, _, err := pvmClient.GetCurrentSupply(tc.DefaultContext(), constants.PrimaryNetworkID) + tc.By("retrieving supply before adding alpha node as a validator") + supplyAtAlphaNodeStart, _, err := pvmClient.GetCurrentSupply(tc.DefaultContext(), constants.PrimaryNetworkID) require.NoError(err) - alphaValidatorsEndTime := time.Now().Add(targetValidationPeriod) - tc.Outf("alpha node validation period ending at: %v\n", alphaValidatorsEndTime) - tc.By("adding alpha node as a validator", func() { + endTime := time.Now().Add(targetValidationPeriod) + tc.Outf("validation period ending at: %v\n", endTime) + _, err := pWallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: alphaNodeID, - End: uint64(alphaValidatorsEndTime.Unix()), + End: uint64(endTime.Unix()), Wght: weight, }, Subnet: constants.PrimaryNetworkID, @@ -179,19 +167,19 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { require.NoError(err) }) - tc.By("retrieving supply before inserting delegators") - supplyAtDelegatorsStart, _, err := pvmClient.GetCurrentSupply(tc.DefaultContext(), constants.PrimaryNetworkID) + tc.By("retrieving supply before adding gamma as a delegator") + supplyAtGammaDelegatorStart, _, err := pvmClient.GetCurrentSupply(tc.DefaultContext(), constants.PrimaryNetworkID) require.NoError(err) - gammaDelegatorEndTime := time.Now().Add(targetDelegationPeriod) - tc.Outf("gamma delegation period ending at: %v\n", gammaDelegatorEndTime) + tc.By("adding gamma as a delegator to the alpha node", func() { + endTime := time.Now().Add(targetDelegationPeriod) + tc.Outf("delegation period ending at: %v\n", endTime) - tc.By("adding gamma as delegator to the alpha node", func() { _, err := pWallet.IssueAddPermissionlessDelegatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: alphaNodeID, - End: uint64(gammaDelegatorEndTime.Unix()), + End: uint64(endTime.Unix()), Wght: weight, }, Subnet: constants.PrimaryNetworkID, @@ -206,15 +194,15 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { require.NoError(err) }) - deltaDelegatorEndTime := time.Now().Add(targetDelegationPeriod) - tc.Outf("delta delegation period ending at: %v\n", deltaDelegatorEndTime) - tc.By("adding delta as delegator to the beta node", func() { + endTime := time.Now().Add(targetDelegationPeriod) + tc.Outf("delegation period ending at: %v\n", endTime) + _, err := pWallet.IssueAddPermissionlessDelegatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: betaNodeID, - End: uint64(deltaDelegatorEndTime.Unix()), + End: uint64(endTime.Unix()), Wght: weight, }, Subnet: constants.PrimaryNetworkID, @@ -229,8 +217,9 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { require.NoError(err) }) - tc.By("stopping beta node to prevent it and its delegator from receiving a validation reward") - require.NoError(betaNode.Stop(tc.DefaultContext())) + tc.By("stopping beta node to prevent it and its delegator from receiving a validation reward", func() { + require.NoError(betaNode.Stop(tc.DefaultContext())) + }) tc.By("retrieving staking periods from the chain") data, err := pvmClient.GetCurrentValidators(tc.DefaultContext(), constants.PlatformChainID, []ids.NodeID{alphaNodeID}) @@ -287,8 +276,8 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { tc.By("determining expected validation and delegation rewards") calculator := reward.NewCalculator(rewardConfig) - expectedValidationReward := calculator.Calculate(actualAlphaValidationPeriod, weight, supplyAtValidatorsStart) - potentialDelegationReward := calculator.Calculate(actualGammaDelegationPeriod, weight, supplyAtDelegatorsStart) + expectedValidationReward := calculator.Calculate(actualAlphaValidationPeriod, weight, supplyAtAlphaNodeStart) + potentialDelegationReward := calculator.Calculate(actualGammaDelegationPeriod, weight, supplyAtGammaDelegatorStart) expectedDelegationFee, expectedDelegatorReward := reward.Split(potentialDelegationReward, delegationShare) tc.By("checking expected rewards against actual rewards") diff --git a/tests/e2e/p/util.go b/tests/e2e/p/util.go index 6d31201f8f09..f6425a0698a0 100644 --- a/tests/e2e/p/util.go +++ b/tests/e2e/p/util.go @@ -4,6 +4,10 @@ package p import ( + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/tests" + "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" ) @@ -14,3 +18,9 @@ func feeCalculatorFromContext(context *builder.Context) fee.Calculator { } return fee.NewStaticCalculator(context.StaticFeeConfig) } + +func newKey(tc tests.TestContext) *secp256k1.PrivateKey { + key, err := secp256k1.NewPrivateKey() + require.NoError(tc, err) + return key +} diff --git a/tests/e2e/p/workflow.go b/tests/e2e/p/workflow.go index bf97d563adbb..d22b8f98a45a 100644 --- a/tests/e2e/p/workflow.go +++ b/tests/e2e/p/workflow.go @@ -30,19 +30,20 @@ import ( // - Issues an ImportTx on the X-chain and verifies the expected balances var _ = e2e.DescribePChain("[Workflow]", func() { - tc := e2e.NewTestContext() - require := require.New(tc) - const ( // amount to transfer from P to X chain toTransfer = 1 * units.Avax delegationFeeShares uint32 = 20000 // TODO: retrieve programmatically ) + var ( + tc = e2e.NewTestContext() + require = require.New(tc) + ) ginkgo.It("P-chain main operations", func() { - env := e2e.GetEnv(tc) - var ( + env = e2e.GetEnv(tc) + nodeURI = env.GetRandomNodeURI() keychain = env.NewKeychain(2) From a1120957094256603bddb1b61db194103f0357ec Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 14 Aug 2024 15:00:08 -0400 Subject: [PATCH 011/114] fix staking rewards --- tests/e2e/p/staking_rewards.go | 139 ++++++++++++++++----------------- tests/e2e/p/util.go | 24 ++++++ 2 files changed, 92 insertions(+), 71 deletions(-) diff --git a/tests/e2e/p/staking_rewards.go b/tests/e2e/p/staking_rewards.go index c0d2cc764c46..8623a27c2c33 100644 --- a/tests/e2e/p/staking_rewards.go +++ b/tests/e2e/p/staking_rewards.go @@ -6,7 +6,6 @@ package p import ( "time" - "github.com/mitchellh/mapstructure" "github.com/spf13/cast" "github.com/stretchr/testify/require" @@ -222,79 +221,77 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { }) tc.By("retrieving staking periods from the chain") - data, err := pvmClient.GetCurrentValidators(tc.DefaultContext(), constants.PlatformChainID, []ids.NodeID{alphaNodeID}) + currentValidators, err := pvmClient.GetCurrentValidators(tc.DefaultContext(), constants.PlatformChainID, []ids.NodeID{alphaNodeID}) require.NoError(err) - require.Len(data, 1) - actualAlphaValidationPeriod := time.Duration(data[0].EndTime-data[0].StartTime) * time.Second - delegatorData := data[0].Delegators[0] - actualGammaDelegationPeriod := time.Duration(delegatorData.EndTime-delegatorData.StartTime) * time.Second - - tc.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. - time.Sleep(time.Until(betaValidatorEndTime)) - - tc.By("waiting until the alpha and beta nodes are no longer validators") - tc.Eventually(func() bool { - validators, err := pvmClient.GetCurrentValidators(tc.DefaultContext(), constants.PrimaryNetworkID, nil) - require.NoError(err) - for _, validator := range validators { - if validator.NodeID == alphaNodeID || validator.NodeID == betaNodeID { - return false + require.Len(currentValidators, 1) + alphaValidator := currentValidators[0] + require.Len(alphaValidator.Delegators, 1) + gammaDelegator := alphaValidator.Delegators[0] + actualAlphaValidationPeriod := time.Duration(alphaValidator.EndTime-alphaValidator.StartTime) * time.Second + actualGammaDelegationPeriod := time.Duration(gammaDelegator.EndTime-gammaDelegator.StartTime) * time.Second + + tc.By("waiting until the alpha and beta nodes are no longer validators", func() { + // The beta validator was the last added and so has the latest end + // time. The delegation periods are shorter than the validation + // periods. + time.Sleep(time.Until(betaValidatorEndTime)) + + // To avoid racy behavior, we confirm that the nodes are no longer + // validators before advancing. + tc.Eventually(func() bool { + validators, err := pvmClient.GetCurrentValidators(tc.DefaultContext(), constants.PrimaryNetworkID, nil) + require.NoError(err) + for _, validator := range validators { + if validator.NodeID == alphaNodeID || validator.NodeID == betaNodeID { + return false + } } + return true + }, e2e.DefaultTimeout, e2e.DefaultPollingInterval, "nodes failed to stop validating before timeout") + }) + + tc.By("checking expected rewards against actual rewards", func() { + var ( + adminClient = admin.NewClient(nodeURI.URI) + rewardConfig = getRewardConfig(tc, adminClient) + calculator = reward.NewCalculator(rewardConfig) + + expectedValidationReward = calculator.Calculate(actualAlphaValidationPeriod, weight, supplyAtAlphaNodeStart) + + potentialDelegationReward = calculator.Calculate(actualGammaDelegationPeriod, weight, supplyAtGammaDelegatorStart) + expectedDelegationFee, expectedDelegatorReward = reward.Split(potentialDelegationReward, delegationShare) + ) + + rewardBalances := make(map[ids.ShortID]uint64, len(rewardKeys)) + for _, rewardKey := range rewardKeys { + var ( + keychain = secp256k1fx.NewKeychain(rewardKey) + baseWallet = e2e.NewWallet(tc, keychain, nodeURI) + pWallet = baseWallet.P() + pBuilder = pWallet.Builder() + ) + + balances, err := pBuilder.GetBalance() + require.NoError(err) + rewardBalances[rewardKey.Address()] = balances[pContext.AVAXAssetID] } - return true - }, e2e.DefaultTimeout, e2e.DefaultPollingInterval, "nodes failed to stop validating before timeout ") - - tc.By("retrieving reward configuration for the network") - // TODO(marun) Enable GetConfig to return *node.Config - // directly. Currently, due to a circular dependency issue, a - // map-based equivalent is used for which manual unmarshaling - // is required. - adminClient := admin.NewClient(env.GetRandomNodeURI().URI) - rawNodeConfigMap, err := adminClient.GetConfig(tc.DefaultContext()) - require.NoError(err) - nodeConfigMap, ok := rawNodeConfigMap.(map[string]interface{}) - require.True(ok) - stakingConfigMap, ok := nodeConfigMap["stakingConfig"].(map[string]interface{}) - require.True(ok) - rawRewardConfig := stakingConfigMap["rewardConfig"] - rewardConfig := reward.Config{} - require.NoError(mapstructure.Decode(rawRewardConfig, &rewardConfig)) - - tc.By("retrieving reward address balances") - rewardBalances := make(map[ids.ShortID]uint64, len(rewardKeys)) - for _, rewardKey := range rewardKeys { - keychain := secp256k1fx.NewKeychain(rewardKey) - baseWallet := e2e.NewWallet(tc, keychain, nodeURI) - pWallet := baseWallet.P() - balances, err := pWallet.Builder().GetBalance() - require.NoError(err) - rewardBalances[rewardKey.Address()] = balances[pContext.AVAXAssetID] - } - require.Len(rewardBalances, len(rewardKeys)) - - tc.By("determining expected validation and delegation rewards") - calculator := reward.NewCalculator(rewardConfig) - expectedValidationReward := calculator.Calculate(actualAlphaValidationPeriod, weight, supplyAtAlphaNodeStart) - potentialDelegationReward := calculator.Calculate(actualGammaDelegationPeriod, weight, supplyAtGammaDelegatorStart) - expectedDelegationFee, expectedDelegatorReward := reward.Split(potentialDelegationReward, delegationShare) - - tc.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 - } - for address := range expectedRewardBalances { - require.Equal(expectedRewardBalances[address], rewardBalances[address]) - } - - tc.By("stopping alpha to free up resources for a bootstrap check") - require.NoError(alphaNode.Stop(tc.DefaultContext())) + + require.Equal( + 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 + }, + rewardBalances, + ) + }) + + tc.By("stopping alpha to free up resources for a bootstrap check", func() { + require.NoError(alphaNode.Stop(tc.DefaultContext())) + }) _ = e2e.CheckBootstrapIsPossible(tc, network) }) diff --git a/tests/e2e/p/util.go b/tests/e2e/p/util.go index f6425a0698a0..432151ae0c25 100644 --- a/tests/e2e/p/util.go +++ b/tests/e2e/p/util.go @@ -4,10 +4,13 @@ package p import ( + "github.com/mitchellh/mapstructure" "github.com/stretchr/testify/require" + "github.com/ava-labs/avalanchego/api/admin" "github.com/ava-labs/avalanchego/tests" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" + "github.com/ava-labs/avalanchego/vms/platformvm/reward" "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" ) @@ -24,3 +27,24 @@ func newKey(tc tests.TestContext) *secp256k1.PrivateKey { require.NoError(tc, err) return key } + +// TODO(marun) Enable GetConfig to return *node.Config directly. Currently, due +// to a circular dependency issue, a map-based equivalent is used for which +// manual unmarshaling is required. +func getRewardConfig(tc tests.TestContext, client admin.Client) reward.Config { + require := require.New(tc) + + rawNodeConfigMap, err := client.GetConfig(tc.DefaultContext()) + require.NoError(err) + nodeConfigMap, ok := rawNodeConfigMap.(map[string]interface{}) + require.True(ok) + stakingConfigMap, ok := nodeConfigMap["stakingConfig"].(map[string]interface{}) + require.True(ok) + + var rewardConfig reward.Config + require.NoError(mapstructure.Decode( + stakingConfigMap["rewardConfig"], + &rewardConfig, + )) + return rewardConfig +} From d678a9aecf66d810a5a0e5a78e92ecac04968f3d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 14 Aug 2024 15:24:01 -0400 Subject: [PATCH 012/114] nits --- tests/e2e/c/dynamic_fees.go | 8 ++-- tests/e2e/c/interchain_workflow.go | 12 ++--- tests/e2e/p/interchain_workflow.go | 70 +++++++++++++++++------------- tests/e2e/p/staking_rewards.go | 12 ++--- tests/e2e/p/util.go | 7 --- tests/e2e/p/validator_sets.go | 48 ++++++++++---------- tests/e2e/vms/xsvm.go | 6 +-- tests/e2e/x/interchain_workflow.go | 4 +- tests/fixture/e2e/helpers.go | 8 ++++ 9 files changed, 91 insertions(+), 84 deletions(-) diff --git a/tests/e2e/c/dynamic_fees.go b/tests/e2e/c/dynamic_fees.go index ea3921bcf5f0..0eb200b61432 100644 --- a/tests/e2e/c/dynamic_fees.go +++ b/tests/e2e/c/dynamic_fees.go @@ -16,7 +16,6 @@ import ( "github.com/ava-labs/avalanchego/tests/fixture/e2e" "github.com/ava-labs/avalanchego/tests/fixture/tmpnet" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" ginkgo "github.com/onsi/ginkgo/v2" ) @@ -142,9 +141,10 @@ var _ = e2e.DescribeCChain("[Dynamic Fees]", func() { tc.By("sending funds at the current gas price", func() { // Create a recipient address - recipientKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - recipientEthAddress := evm.GetEthAddress(recipientKey) + var ( + recipientKey = e2e.NewKey(tc) + recipientEthAddress = evm.GetEthAddress(recipientKey) + ) // Create transaction nonce, err := ethClient.AcceptedNonceAt(tc.DefaultContext(), ethAddress) diff --git a/tests/e2e/c/interchain_workflow.go b/tests/e2e/c/interchain_workflow.go index 3ec8b0b6e478..801ae6e7cc65 100644 --- a/tests/e2e/c/interchain_workflow.go +++ b/tests/e2e/c/interchain_workflow.go @@ -13,7 +13,6 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/tests/fixture/e2e" "github.com/ava-labs/avalanchego/utils/constants" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/secp256k1fx" @@ -39,11 +38,12 @@ var _ = e2e.DescribeCChain("[Interchain Workflow]", func() { ethClient := e2e.NewEthClient(tc, nodeURI) tc.By("allocating a pre-funded key to send from and a recipient key to deliver to") - senderKey := env.AllocatePreFundedKey() - senderEthAddress := evm.GetEthAddress(senderKey) - recipientKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - recipientEthAddress := evm.GetEthAddress(recipientKey) + var ( + senderKey = env.AllocatePreFundedKey() + senderEthAddress = evm.GetEthAddress(senderKey) + recipientKey = e2e.NewKey(tc) + recipientEthAddress = evm.GetEthAddress(recipientKey) + ) tc.By("sending funds from one address to another on the C-Chain", func() { // Create transaction diff --git a/tests/e2e/p/interchain_workflow.go b/tests/e2e/p/interchain_workflow.go index e0be6c45be4c..e64385d80a42 100644 --- a/tests/e2e/p/interchain_workflow.go +++ b/tests/e2e/p/interchain_workflow.go @@ -17,7 +17,6 @@ import ( "github.com/ava-labs/avalanchego/tests/fixture/e2e" "github.com/ava-labs/avalanchego/tests/fixture/tmpnet" "github.com/ava-labs/avalanchego/utils/constants" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/components/avax" @@ -30,18 +29,20 @@ import ( ) var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainLabel), func() { - tc := e2e.NewTestContext() - require := require.New(tc) - const ( transferAmount = 10 * units.Avax weight = 2_000 * units.Avax // Used for both validation and delegation ) + var ( + tc = e2e.NewTestContext() + require = require.New(tc) + ) ginkgo.It("should ensure that funds can be transferred from the P-Chain to the X-Chain and the C-Chain", func() { - env := e2e.GetEnv(tc) - - network := env.GetNetwork() + var ( + env = e2e.GetEnv(tc) + network = env.GetNetwork() + ) tc.By("checking that the network has a compatible minimum stake duration", func() { minStakeDuration := cast.ToDuration(network.DefaultFlags[config.MinStakeDurationKey]) @@ -49,26 +50,31 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL }) tc.By("creating wallet with a funded key to send from and recipient key to deliver to") - recipientKey, err := secp256k1.NewPrivateKey() - require.NoError(err) + recipientKey := e2e.NewKey(tc) keychain := env.NewKeychain(1) keychain.Add(recipientKey) - nodeURI := env.GetRandomNodeURI() - baseWallet := e2e.NewWallet(tc, keychain, nodeURI) - xWallet := baseWallet.X() - cWallet := baseWallet.C() - pWallet := baseWallet.P() - - xBuilder := xWallet.Builder() - xContext := xBuilder.Context() - pBuilder := pWallet.Builder() - pContext := pBuilder.Context() - cBuilder := cWallet.Builder() - cContext := cBuilder.Context() + + var ( + nodeURI = env.GetRandomNodeURI() + baseWallet = e2e.NewWallet(tc, keychain, nodeURI) + + xWallet = baseWallet.X() + xBuilder = xWallet.Builder() + xContext = xBuilder.Context() + + pWallet = baseWallet.P() + pBuilder = pWallet.Builder() + pContext = pBuilder.Context() + + cWallet = baseWallet.C() + cBuilder = cWallet.Builder() + cContext = cBuilder.Context() + + avaxAssetID = xContext.AVAXAssetID + ) tc.By("defining common configuration") recipientEthAddress := evm.GetEthAddress(recipientKey) - avaxAssetID := xContext.AVAXAssetID // Use the same owner for sending to X-Chain and importing funds to P-Chain recipientOwner := secp256k1fx.OutputOwners{ Threshold: 1, @@ -106,14 +112,16 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL // Adding a validator should not break interchain transfer. endTime := time.Now().Add(30 * time.Second) tc.By("adding the new node as a validator", func() { - rewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - const ( delegationPercent = 0.10 // 10% delegationShare = reward.PercentDenominator * delegationPercent ) + var ( + rewardKey = e2e.NewKey(tc) + rewardAddr = rewardKey.Address() + ) + _, err = pWallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ @@ -127,11 +135,11 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL pContext.AVAXAssetID, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{rewardKey.Address()}, + Addrs: []ids.ShortID{rewardAddr}, }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{rewardKey.Address()}, + Addrs: []ids.ShortID{rewardAddr}, }, delegationShare, tc.WithDefaultContext(), @@ -141,8 +149,10 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL // Adding a delegator should not break interchain transfer. tc.By("adding a delegator to the new node", func() { - rewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) + var ( + rewardKey = e2e.NewKey(tc) + rewardAddr = rewardKey.Address() + ) _, err = pWallet.IssueAddPermissionlessDelegatorTx( &txs.SubnetValidator{ @@ -156,7 +166,7 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL pContext.AVAXAssetID, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{rewardKey.Address()}, + Addrs: []ids.ShortID{rewardAddr}, }, tc.WithDefaultContext(), ) diff --git a/tests/e2e/p/staking_rewards.go b/tests/e2e/p/staking_rewards.go index 8623a27c2c33..e061a59a1475 100644 --- a/tests/e2e/p/staking_rewards.go +++ b/tests/e2e/p/staking_rewards.go @@ -75,12 +75,12 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() { tc.By("creating keychain and P-Chain wallet") var ( - alphaValidationRewardKey = newKey(tc) - alphaDelegationRewardKey = newKey(tc) - betaValidationRewardKey = newKey(tc) - betaDelegationRewardKey = newKey(tc) - gammaDelegationRewardKey = newKey(tc) - deltaDelegationRewardKey = newKey(tc) + alphaValidationRewardKey = e2e.NewKey(tc) + alphaDelegationRewardKey = e2e.NewKey(tc) + betaValidationRewardKey = e2e.NewKey(tc) + betaDelegationRewardKey = e2e.NewKey(tc) + gammaDelegationRewardKey = e2e.NewKey(tc) + deltaDelegationRewardKey = e2e.NewKey(tc) rewardKeys = []*secp256k1.PrivateKey{ alphaValidationRewardKey, diff --git a/tests/e2e/p/util.go b/tests/e2e/p/util.go index 432151ae0c25..8176472757fb 100644 --- a/tests/e2e/p/util.go +++ b/tests/e2e/p/util.go @@ -9,7 +9,6 @@ import ( "github.com/ava-labs/avalanchego/api/admin" "github.com/ava-labs/avalanchego/tests" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/platformvm/reward" "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" @@ -22,12 +21,6 @@ func feeCalculatorFromContext(context *builder.Context) fee.Calculator { return fee.NewStaticCalculator(context.StaticFeeConfig) } -func newKey(tc tests.TestContext) *secp256k1.PrivateKey { - key, err := secp256k1.NewPrivateKey() - require.NoError(tc, err) - return key -} - // TODO(marun) Enable GetConfig to return *node.Config directly. Currently, due // to a circular dependency issue, a map-based equivalent is used for which // manual unmarshaling is required. diff --git a/tests/e2e/p/validator_sets.go b/tests/e2e/p/validator_sets.go index d13e056929c2..f29574ec913f 100644 --- a/tests/e2e/p/validator_sets.go +++ b/tests/e2e/p/validator_sets.go @@ -13,9 +13,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/tests/fixture/e2e" - "github.com/ava-labs/avalanchego/tests/fixture/tmpnet" "github.com/ava-labs/avalanchego/utils/constants" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" @@ -24,39 +22,41 @@ import ( ) var _ = e2e.DescribePChain("[Validator Sets]", func() { - tc := e2e.NewTestContext() - require := require.New(tc) - + var ( + tc = e2e.NewTestContext() + require = require.New(tc) + ) ginkgo.It("should be identical for every height for all nodes in the network", func() { - env := e2e.GetEnv(tc) - - network := env.GetNetwork() + var ( + env = e2e.GetEnv(tc) + network = env.GetNetwork() + ) tc.By("creating wallet with a funded key to source delegated funds from") - keychain := env.NewKeychain(1) - nodeURI := env.GetRandomNodeURI() - baseWallet := e2e.NewWallet(tc, keychain, nodeURI) - pWallet := baseWallet.P() - - pBuilder := pWallet.Builder() - pContext := pBuilder.Context() + var ( + keychain = env.NewKeychain(1) + nodeURI = env.GetRandomNodeURI() + baseWallet = e2e.NewWallet(tc, keychain, nodeURI) + pWallet = baseWallet.P() + pBuilder = pWallet.Builder() + pContext = pBuilder.Context() + avaxAssetID = pContext.AVAXAssetID + ) const delegatorCount = 15 tc.By(fmt.Sprintf("adding %d delegators", delegatorCount), func() { - rewardKey, err := secp256k1.NewPrivateKey() - require.NoError(err) - avaxAssetID := pContext.AVAXAssetID - startTime := time.Now().Add(tmpnet.DefaultValidatorStartTimeDiff) - endTime := startTime.Add(time.Second * 360) - // This is the default flag value for MinDelegatorStake. - weight := genesis.LocalParams.StakingConfig.MinDelegatorStake + var ( + rewardKey = e2e.NewKey(tc) + endTime = time.Now().Add(time.Second * 360) + // This is the default flag value for MinDelegatorStake. + weight = genesis.LocalParams.StakingConfig.MinDelegatorStake + ) for i := 0; i < delegatorCount; i++ { - _, err = pWallet.IssueAddPermissionlessDelegatorTx( + _, err := pWallet.IssueAddPermissionlessDelegatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeURI.NodeID, - Start: uint64(startTime.Unix()), End: uint64(endTime.Unix()), Wght: weight, }, diff --git a/tests/e2e/vms/xsvm.go b/tests/e2e/vms/xsvm.go index 562df5edb014..dbbde80550ed 100644 --- a/tests/e2e/vms/xsvm.go +++ b/tests/e2e/vms/xsvm.go @@ -74,8 +74,7 @@ var _ = ginkgo.Describe("[XSVM]", func() { destinationAPINode := destinationValidators[0] tc.Outf(" issuing transactions for destination subnet on %s (%s)\n", destinationAPINode.NodeID, destinationAPINode.URI) - destinationKey, err := secp256k1.NewPrivateKey() - require.NoError(err) + destinationKey := e2e.NewKey(tc) tc.By("checking that the funded key has sufficient funds for the export") sourceClient := api.NewClient(sourceAPINode.URI, sourceChain.ChainID.String()) @@ -115,8 +114,7 @@ var _ = ginkgo.Describe("[XSVM]", func() { tc.By(fmt.Sprintf("issuing transaction on chain %s on subnet %s to activate snowman++ consensus", destinationChain.ChainID, destinationSubnet.SubnetID)) - recipientKey, err := secp256k1.NewPrivateKey() - require.NoError(err) + recipientKey := e2e.NewKey(tc) transferTxStatus, err := transfer.Transfer( tc.DefaultContext(), &transfer.Config{ diff --git a/tests/e2e/x/interchain_workflow.go b/tests/e2e/x/interchain_workflow.go index 3d5933ab54e7..08dca3abe5d9 100644 --- a/tests/e2e/x/interchain_workflow.go +++ b/tests/e2e/x/interchain_workflow.go @@ -12,7 +12,6 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/tests/fixture/e2e" "github.com/ava-labs/avalanchego/utils/constants" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/components/avax" @@ -34,8 +33,7 @@ var _ = e2e.DescribeXChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL nodeURI := env.GetRandomNodeURI() tc.By("creating wallet with a funded key to send from and recipient key to deliver to") - recipientKey, err := secp256k1.NewPrivateKey() - require.NoError(err) + recipientKey := e2e.NewKey(tc) keychain := env.NewKeychain(1) keychain.Add(recipientKey) baseWallet := e2e.NewWallet(tc, keychain, nodeURI) diff --git a/tests/fixture/e2e/helpers.go b/tests/fixture/e2e/helpers.go index 18de668fcbfa..801a88af63b1 100644 --- a/tests/fixture/e2e/helpers.go +++ b/tests/fixture/e2e/helpers.go @@ -21,6 +21,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/tests" "github.com/ava-labs/avalanchego/tests/fixture/tmpnet" + "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/subnet/primary" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" @@ -49,6 +50,13 @@ const ( PrivateNetworksDirName = "private_networks" ) +// Create a new key. +func NewKey(tc tests.TestContext) *secp256k1.PrivateKey { + key, err := secp256k1.NewPrivateKey() + require.NoError(tc, err) + return key +} + // Create a new wallet for the provided keychain against the specified node URI. func NewWallet(tc tests.TestContext, keychain *secp256k1fx.Keychain, nodeURI tmpnet.NodeURI) primary.Wallet { tc.Outf("{{blue}} initializing a new wallet for node %s with URI: %s {{/}}\n", nodeURI.NodeID, nodeURI.URI) From d63b26be028ca8663d734f516dcc4f66d4d37184 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 14 Aug 2024 15:24:22 -0400 Subject: [PATCH 013/114] nits --- tests/e2e/c/interchain_workflow.go | 2 +- tests/e2e/x/interchain_workflow.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/e2e/c/interchain_workflow.go b/tests/e2e/c/interchain_workflow.go index 801ae6e7cc65..9e88a64b46b9 100644 --- a/tests/e2e/c/interchain_workflow.go +++ b/tests/e2e/c/interchain_workflow.go @@ -150,7 +150,7 @@ var _ = e2e.DescribeCChain("[Interchain Workflow]", func() { }) tc.By("importing AVAX from the C-Chain to the P-Chain", func() { - _, err = pWallet.IssueImportTx( + _, err := pWallet.IssueImportTx( cContext.BlockchainID, &recipientOwner, tc.WithDefaultContext(), diff --git a/tests/e2e/x/interchain_workflow.go b/tests/e2e/x/interchain_workflow.go index 08dca3abe5d9..1f8b00f334dd 100644 --- a/tests/e2e/x/interchain_workflow.go +++ b/tests/e2e/x/interchain_workflow.go @@ -74,7 +74,7 @@ var _ = e2e.DescribeXChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL } tc.By("sending funds from one address to another on the X-Chain", func() { - _, err = xWallet.IssueBaseTx( + _, err := xWallet.IssueBaseTx( []*avax.TransferableOutput{{ Asset: avax.Asset{ ID: avaxAssetID, From 574d2656fb57436a8415dc5ae83b020a50c463a0 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 10:13:02 -0400 Subject: [PATCH 014/114] remove debug error --- wallet/chain/p/wallet.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/wallet/chain/p/wallet.go b/wallet/chain/p/wallet.go index 968600c08e48..631553431ef7 100644 --- a/wallet/chain/p/wallet.go +++ b/wallet/chain/p/wallet.go @@ -4,9 +4,7 @@ package p import ( - "encoding/json" "errors" - "fmt" "time" "github.com/ava-labs/avalanchego/ids" @@ -510,9 +508,6 @@ func (w *wallet) IssueTx( ctx := ops.Context() txID, err := w.client.IssueTx(ctx, tx.Bytes()) if err != nil { - if txJSON, jsonErr := json.MarshalIndent(tx, "", "\t"); jsonErr == nil { - err = fmt.Errorf("failed to issue tx:\n%s\n%w", string(txJSON), err) - } return err } From 75716b488c19c081c9a1fc4cd2cbd27f8370bcc5 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 10:43:47 -0400 Subject: [PATCH 015/114] add simple tests --- vms/platformvm/service_test.go | 63 ++++++++++++++++++++++++++++++++++ vms/platformvm/vm_test.go | 43 ++++++++++++++++------- 2 files changed, 93 insertions(+), 13 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index a3b2e743c9bc..1e3247d8650f 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -33,6 +33,7 @@ import ( "github.com/ava-labs/avalanchego/utils/formatting" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/vms/components/avax" + "github.com/ava-labs/avalanchego/vms/components/fee" "github.com/ava-labs/avalanchego/vms/platformvm/block" "github.com/ava-labs/avalanchego/vms/platformvm/signer" "github.com/ava-labs/avalanchego/vms/platformvm/state" @@ -1107,3 +1108,65 @@ func TestServiceGetSubnets(t *testing.T) { }, }, response.Subnets) } + +func TestGetFeeConfig(t *testing.T) { + tests := []struct { + name string + etnaTime time.Time + expected fee.Config + }{ + { + name: "pre-etna", + etnaTime: time.Now().Add(time.Hour), + expected: fee.Config{}, + }, + { + name: "post-etna", + etnaTime: time.Now().Add(-time.Hour), + expected: defaultDynamicFeeConfig, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require := require.New(t) + + service, _, _ := defaultService(t) + service.vm.Config.UpgradeConfig.EtnaTime = test.etnaTime + + var reply fee.Config + require.NoError(service.GetFeeConfig(nil, nil, &reply)) + require.Equal(test.expected, reply) + }) + } +} + +func TestGetFeeState(t *testing.T) { + require := require.New(t) + + seed := time.Now().UnixNano() + t.Logf("Seed: %d", seed) + random := rand.New(rand.NewSource(seed)) + + service, _, _ := defaultService(t) + + expectedState := fee.State{ + Capacity: fee.Gas(random.Uint64()), + Excess: fee.Gas(random.Uint64()), + } + service.vm.state.SetFeeState(expectedState) + timestamp := time.Now() + service.vm.state.SetTimestamp(timestamp) + + expectedReply := GetFeeStateReply{ + State: expectedState, + Price: defaultDynamicFeeConfig.MinGasPrice.MulExp( + expectedState.Excess, + defaultDynamicFeeConfig.ExcessConversionConstant, + ), + Time: timestamp, + } + + var reply GetFeeStateReply + require.NoError(service.GetFeeState(nil, nil, &reply)) + require.Equal(expectedReply, reply) +} diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 08d51ce4f135..939112c03242 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -59,7 +59,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/signer" "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/secp256k1fx" @@ -68,9 +67,11 @@ import ( smeng "github.com/ava-labs/avalanchego/snow/engine/snowman" snowgetter "github.com/ava-labs/avalanchego/snow/engine/snowman/getter" timetracker "github.com/ava-labs/avalanchego/snow/networking/tracker" + feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" blockbuilder "github.com/ava-labs/avalanchego/vms/platformvm/block/builder" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" walletbuilder "github.com/ava-labs/avalanchego/wallet/chain/p/builder" walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" @@ -123,6 +124,26 @@ var ( defaultMaxValidatorStake = 100 * defaultMinValidatorStake defaultBalance = 2 * defaultMaxValidatorStake // amount all genesis validators have in defaultVM + defaultStaticFeeConfig = txfee.StaticConfig{ + TxFee: defaultTxFee, + CreateSubnetTxFee: 100 * defaultTxFee, + TransformSubnetTxFee: 100 * defaultTxFee, + CreateBlockchainTxFee: 100 * defaultTxFee, + } + defaultDynamicFeeConfig = feecomponent.Config{ + Weights: feecomponent.Dimensions{ + feecomponent.Bandwidth: 1, + feecomponent.DBRead: 1, + feecomponent.DBWrite: 1, + feecomponent.Compute: 1, + }, + MaxGasCapacity: 10_000, + MaxGasPerSecond: 1_000, + TargetGasPerSecond: 500, + MinGasPrice: 1, + ExcessConversionConstant: 5_000, + } + // subnet that exists at genesis in defaultVM // Its controlKeys are keys[0], keys[1], keys[2] // Its threshold is 2 @@ -248,18 +269,14 @@ func defaultVM(t *testing.T, f fork) (*VM, *txstest.WalletFactory, database.Data UptimeLockedCalculator: uptime.NewLockedCalculator(), SybilProtectionEnabled: true, Validators: validators.NewManager(), - StaticFeeConfig: fee.StaticConfig{ - TxFee: defaultTxFee, - CreateSubnetTxFee: 100 * defaultTxFee, - TransformSubnetTxFee: 100 * defaultTxFee, - CreateBlockchainTxFee: 100 * defaultTxFee, - }, - MinValidatorStake: defaultMinValidatorStake, - MaxValidatorStake: defaultMaxValidatorStake, - MinDelegatorStake: defaultMinDelegatorStake, - MinStakeDuration: defaultMinStakingDuration, - MaxStakeDuration: defaultMaxStakingDuration, - RewardConfig: defaultRewardConfig, + StaticFeeConfig: defaultStaticFeeConfig, + DynamicFeeConfig: defaultDynamicFeeConfig, + MinValidatorStake: defaultMinValidatorStake, + MaxValidatorStake: defaultMaxValidatorStake, + MinDelegatorStake: defaultMinDelegatorStake, + MinStakeDuration: defaultMinStakingDuration, + MaxStakeDuration: defaultMaxStakingDuration, + RewardConfig: defaultRewardConfig, UpgradeConfig: upgrade.Config{ ApricotPhase3Time: apricotPhase3Time, ApricotPhase5Time: apricotPhase5Time, From e578bdcd3b6964b5db93058a8708821ae9de9314 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 10:48:17 -0400 Subject: [PATCH 016/114] nit --- vms/platformvm/service_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 1e3247d8650f..828f65b86530 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -1145,7 +1145,7 @@ func TestGetFeeState(t *testing.T) { seed := time.Now().UnixNano() t.Logf("Seed: %d", seed) - random := rand.New(rand.NewSource(seed)) + random := rand.New(rand.NewSource(seed)) // #nosec G404 service, _, _ := defaultService(t) From d60d97f48fec3d048283ec912fb0913d481ebe08 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 11:43:27 -0400 Subject: [PATCH 017/114] nits --- vms/platformvm/service_test.go | 51 +++++++++++++++++----------------- 1 file changed, 26 insertions(+), 25 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 828f65b86530..c8e924a6fcaa 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -1140,33 +1140,34 @@ func TestGetFeeConfig(t *testing.T) { } } -func TestGetFeeState(t *testing.T) { - require := require.New(t) +func FuzzGetFeeState(f *testing.F) { + f.Fuzz(func(t *testing.T, capacity, excess uint64) { + require := require.New(t) - seed := time.Now().UnixNano() - t.Logf("Seed: %d", seed) - random := rand.New(rand.NewSource(seed)) // #nosec G404 + service, _, _ := defaultService(t) - service, _, _ := defaultService(t) + expectedState := fee.State{ + Capacity: fee.Gas(capacity), + Excess: fee.Gas(excess), + } - expectedState := fee.State{ - Capacity: fee.Gas(random.Uint64()), - Excess: fee.Gas(random.Uint64()), - } - service.vm.state.SetFeeState(expectedState) - timestamp := time.Now() - service.vm.state.SetTimestamp(timestamp) - - expectedReply := GetFeeStateReply{ - State: expectedState, - Price: defaultDynamicFeeConfig.MinGasPrice.MulExp( - expectedState.Excess, - defaultDynamicFeeConfig.ExcessConversionConstant, - ), - Time: timestamp, - } + service.vm.ctx.Lock.Lock() + service.vm.state.SetFeeState(expectedState) + timestamp := time.Now() + service.vm.state.SetTimestamp(timestamp) + service.vm.ctx.Lock.Unlock() + + expectedReply := GetFeeStateReply{ + State: expectedState, + Price: defaultDynamicFeeConfig.MinGasPrice.MulExp( + expectedState.Excess, + defaultDynamicFeeConfig.ExcessConversionConstant, + ), + Time: timestamp, + } - var reply GetFeeStateReply - require.NoError(service.GetFeeState(nil, nil, &reply)) - require.Equal(expectedReply, reply) + var reply GetFeeStateReply + require.NoError(service.GetFeeState(nil, nil, &reply)) + require.Equal(expectedReply, reply) + }) } From 7ddc52d7143637c9352d1c1ef37b36a17fffd542 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 11:48:58 -0400 Subject: [PATCH 018/114] nit --- vms/platformvm/service_test.go | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index c8e924a6fcaa..41018647d98e 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -1146,14 +1146,16 @@ func FuzzGetFeeState(f *testing.F) { service, _, _ := defaultService(t) - expectedState := fee.State{ - Capacity: fee.Gas(capacity), - Excess: fee.Gas(excess), - } + var ( + expectedState = fee.State{ + Capacity: fee.Gas(capacity), + Excess: fee.Gas(excess), + } + timestamp = time.Now() + ) service.vm.ctx.Lock.Lock() service.vm.state.SetFeeState(expectedState) - timestamp := time.Now() service.vm.state.SetTimestamp(timestamp) service.vm.ctx.Lock.Unlock() From dcac5fc505b29d474a31cd2651311eadb3d04cb4 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 11:49:31 -0400 Subject: [PATCH 019/114] nit --- vms/platformvm/service_test.go | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 41018647d98e..1ff76991f5a3 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -1151,7 +1151,15 @@ func FuzzGetFeeState(f *testing.F) { Capacity: fee.Gas(capacity), Excess: fee.Gas(excess), } - timestamp = time.Now() + timestamp = time.Now() + expectedReply = GetFeeStateReply{ + State: expectedState, + Price: defaultDynamicFeeConfig.MinGasPrice.MulExp( + expectedState.Excess, + defaultDynamicFeeConfig.ExcessConversionConstant, + ), + Time: timestamp, + } ) service.vm.ctx.Lock.Lock() @@ -1159,15 +1167,6 @@ func FuzzGetFeeState(f *testing.F) { service.vm.state.SetTimestamp(timestamp) service.vm.ctx.Lock.Unlock() - expectedReply := GetFeeStateReply{ - State: expectedState, - Price: defaultDynamicFeeConfig.MinGasPrice.MulExp( - expectedState.Excess, - defaultDynamicFeeConfig.ExcessConversionConstant, - ), - Time: timestamp, - } - var reply GetFeeStateReply require.NoError(service.GetFeeState(nil, nil, &reply)) require.Equal(expectedReply, reply) From d256171639215a2a925616f0d3ba72286705957d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 11:50:15 -0400 Subject: [PATCH 020/114] nit --- vms/platformvm/service_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 1ff76991f5a3..a1f429510538 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -1151,20 +1151,20 @@ func FuzzGetFeeState(f *testing.F) { Capacity: fee.Gas(capacity), Excess: fee.Gas(excess), } - timestamp = time.Now() + expectedTime = time.Now() expectedReply = GetFeeStateReply{ State: expectedState, Price: defaultDynamicFeeConfig.MinGasPrice.MulExp( expectedState.Excess, defaultDynamicFeeConfig.ExcessConversionConstant, ), - Time: timestamp, + Time: expectedTime, } ) service.vm.ctx.Lock.Lock() service.vm.state.SetFeeState(expectedState) - service.vm.state.SetTimestamp(timestamp) + service.vm.state.SetTimestamp(expectedTime) service.vm.ctx.Lock.Unlock() var reply GetFeeStateReply From 6a00c00a4b43d035b1de208754ff3af3ec207138 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 17:03:13 -0400 Subject: [PATCH 021/114] nit --- wallet/chain/p/context.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/wallet/chain/p/context.go b/wallet/chain/p/context.go index a1a801c13fde..1ae8f0371c17 100644 --- a/wallet/chain/p/context.go +++ b/wallet/chain/p/context.go @@ -9,9 +9,8 @@ import ( "github.com/ava-labs/avalanchego/api/info" "github.com/ava-labs/avalanchego/vms/avm" "github.com/ava-labs/avalanchego/vms/platformvm" + "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - - txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) func NewContextFromURI(ctx context.Context, uri string) (*builder.Context, error) { @@ -69,7 +68,7 @@ func NewContextFromClients( return &builder.Context{ NetworkID: networkID, AVAXAssetID: asset.AssetID, - StaticFeeConfig: txfee.StaticConfig{ + StaticFeeConfig: fee.StaticConfig{ TxFee: uint64(staticFeeConfig.TxFee), CreateSubnetTxFee: uint64(staticFeeConfig.CreateSubnetTxFee), TransformSubnetTxFee: uint64(staticFeeConfig.TransformSubnetTxFee), From fdbd5d302a9496919fec215923ad1e5a092040c9 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 17:34:08 -0400 Subject: [PATCH 022/114] merged --- vms/platformvm/state/chain_time_helpers.go | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/vms/platformvm/state/chain_time_helpers.go b/vms/platformvm/state/chain_time_helpers.go index ee9d205d50a6..427216372e47 100644 --- a/vms/platformvm/state/chain_time_helpers.go +++ b/vms/platformvm/state/chain_time_helpers.go @@ -10,7 +10,9 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/vms/platformvm/config" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" + + feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) func NextBlockTime(state Chain, clk *mockable.Clock) (time.Time, bool, error) { @@ -75,18 +77,19 @@ func GetNextStakerChangeTime(state Chain) (time.Time, error) { // depending on the active upgrade. // // PickFeeCalculator does not modify [state]. -func PickFeeCalculator(cfg *config.Config, state Chain) fee.Calculator { +func PickFeeCalculator(cfg *config.Config, state Chain) txfee.Calculator { timestamp := state.GetTimestamp() if !cfg.UpgradeConfig.IsEtnaActivated(timestamp) { return NewStaticFeeCalculator(cfg, timestamp) } feeState := state.GetFeeState() - gasPrice := cfg.DynamicFeeConfig.MinGasPrice.MulExp( + gasPrice := feecomponent.CalculateGasPrice( + cfg.DynamicFeeConfig.MinGasPrice, feeState.Excess, cfg.DynamicFeeConfig.ExcessConversionConstant, ) - return fee.NewDynamicCalculator( + return txfee.NewDynamicCalculator( cfg.DynamicFeeConfig.Weights, gasPrice, ) @@ -94,11 +97,11 @@ func PickFeeCalculator(cfg *config.Config, state Chain) fee.Calculator { // NewStaticFeeCalculator creates a static fee calculator, with the config set // to either the pre-AP3 or post-AP3 config. -func NewStaticFeeCalculator(cfg *config.Config, timestamp time.Time) fee.Calculator { +func NewStaticFeeCalculator(cfg *config.Config, timestamp time.Time) txfee.Calculator { config := cfg.StaticFeeConfig if !cfg.UpgradeConfig.IsApricotPhase3Activated(timestamp) { config.CreateSubnetTxFee = cfg.CreateAssetTxFee config.CreateBlockchainTxFee = cfg.CreateAssetTxFee } - return fee.NewStaticCalculator(config) + return txfee.NewStaticCalculator(config) } From edfddbc7bb99ef037f28c73967da6f95be4898dc Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 19:01:20 -0400 Subject: [PATCH 023/114] Remove duplicate fork definitions --- upgrade/upgradetest/config.go | 67 ++++++++++++++++++ upgrade/upgradetest/fork.go | 24 +++++++ vms/avm/environment_test.go | 39 ++--------- vms/avm/index_test.go | 9 +-- vms/avm/service_test.go | 50 ++++++++------ vms/avm/state_test.go | 7 +- vms/avm/vm_benchmark_test.go | 5 +- vms/avm/vm_regression_test.go | 3 +- vms/avm/vm_test.go | 23 ++++--- vms/avm/wallet_service_test.go | 3 +- vms/platformvm/block/builder/builder_test.go | 17 ++--- vms/platformvm/block/builder/helpers_test.go | 28 +++----- .../block/builder/standard_block_test.go | 3 +- vms/platformvm/block/executor/helpers_test.go | 26 +++---- .../block/executor/proposal_block_test.go | 17 ++--- .../block/executor/standard_block_test.go | 15 ++-- vms/platformvm/service_test.go | 3 +- .../txs/executor/advance_time_test.go | 23 ++++--- .../txs/executor/create_chain_test.go | 11 +-- .../txs/executor/create_subnet_test.go | 3 +- vms/platformvm/txs/executor/export_test.go | 3 +- vms/platformvm/txs/executor/helpers_test.go | 30 +++----- vms/platformvm/txs/executor/import_test.go | 3 +- .../txs/executor/proposal_tx_executor_test.go | 9 +-- .../txs/executor/reward_validator_test.go | 13 ++-- .../executor/staker_tx_verification_test.go | 27 ++++---- .../txs/executor/standard_tx_executor_test.go | 57 ++++++++-------- vms/platformvm/vm_regression_test.go | 27 ++++---- vms/platformvm/vm_test.go | 68 ++++++++----------- 29 files changed, 336 insertions(+), 277 deletions(-) create mode 100644 upgrade/upgradetest/config.go create mode 100644 upgrade/upgradetest/fork.go diff --git a/upgrade/upgradetest/config.go b/upgrade/upgradetest/config.go new file mode 100644 index 000000000000..3eb86363740d --- /dev/null +++ b/upgrade/upgradetest/config.go @@ -0,0 +1,67 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package upgradetest + +import ( + "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade" +) + +func GetConfig(fork Fork) upgrade.Config { + c := upgrade.Config{ + ApricotPhase1Time: upgrade.UnscheduledActivationTime, + ApricotPhase2Time: upgrade.UnscheduledActivationTime, + ApricotPhase3Time: upgrade.UnscheduledActivationTime, + ApricotPhase4Time: upgrade.UnscheduledActivationTime, + ApricotPhase4MinPChainHeight: 0, + ApricotPhase5Time: upgrade.UnscheduledActivationTime, + ApricotPhasePre6Time: upgrade.UnscheduledActivationTime, + ApricotPhase6Time: upgrade.UnscheduledActivationTime, + ApricotPhasePost6Time: upgrade.UnscheduledActivationTime, + BanffTime: upgrade.UnscheduledActivationTime, + CortinaTime: upgrade.UnscheduledActivationTime, + CortinaXChainStopVertexID: ids.Empty, + DurangoTime: upgrade.UnscheduledActivationTime, + EtnaTime: upgrade.UnscheduledActivationTime, + } + + switch fork { + case Etna: + c.EtnaTime = upgrade.InitiallyActiveTime + fallthrough + case Durango: + c.DurangoTime = upgrade.InitiallyActiveTime + fallthrough + case Cortina: + c.CortinaTime = upgrade.InitiallyActiveTime + fallthrough + case Banff: + c.BanffTime = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhasePost6: + c.ApricotPhasePost6Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhase6: + c.ApricotPhase6Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhasePre6: + c.ApricotPhasePre6Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhase5: + c.ApricotPhase5Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhase4: + c.ApricotPhase4Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhase3: + c.ApricotPhase3Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhase2: + c.ApricotPhase2Time = upgrade.InitiallyActiveTime + fallthrough + case ApricotPhase1: + c.ApricotPhase1Time = upgrade.InitiallyActiveTime + } + return c +} diff --git a/upgrade/upgradetest/fork.go b/upgrade/upgradetest/fork.go new file mode 100644 index 000000000000..12f7f9899550 --- /dev/null +++ b/upgrade/upgradetest/fork.go @@ -0,0 +1,24 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package upgradetest + +const ( + NoUpgrades Fork = iota + ApricotPhase1 + ApricotPhase2 + ApricotPhase3 + ApricotPhase4 + ApricotPhase5 + ApricotPhasePre6 + ApricotPhase6 + ApricotPhasePost6 + Banff + Cortina + Durango + Etna + + Latest = Etna +) + +type Fork int diff --git a/vms/avm/environment_test.go b/vms/avm/environment_test.go index 75cae23f347a..2dcfd077f234 100644 --- a/vms/avm/environment_test.go +++ b/vms/avm/environment_test.go @@ -8,7 +8,6 @@ import ( "encoding/json" "math/rand" "testing" - "time" "github.com/stretchr/testify/require" @@ -21,14 +20,13 @@ import ( "github.com/ava-labs/avalanchego/snow/engine/common" "github.com/ava-labs/avalanchego/snow/engine/enginetest" "github.com/ava-labs/avalanchego/snow/snowtest" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/formatting" "github.com/ava-labs/avalanchego/utils/formatting/address" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/sampler" - "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/vms/avm/block/executor" "github.com/ava-labs/avalanchego/vms/avm/config" "github.com/ava-labs/avalanchego/vms/avm/fxs" @@ -42,14 +40,7 @@ import ( keystoreutils "github.com/ava-labs/avalanchego/vms/components/keystore" ) -type fork uint8 - const ( - durango fork = iota - etna - - latest = durango - testTxFee uint64 = 1000 startBalance uint64 = 50000 @@ -95,7 +86,7 @@ type user struct { } type envConfig struct { - fork fork + fork upgradetest.Fork isCustomFeeAsset bool keystoreUsers []*user vmStaticConfig *config.Config @@ -155,7 +146,11 @@ func setup(tb testing.TB, c *envConfig) *environment { require.NoError(keystoreUser.Close()) } - vmStaticConfig := staticConfig(tb, c.fork) + vmStaticConfig := config.Config{ + Upgrades: upgradetest.GetConfig(c.fork), + TxFee: testTxFee, + CreateAssetTxFee: testTxFee, + } if c.vmStaticConfig != nil { vmStaticConfig = *c.vmStaticConfig } @@ -230,26 +225,6 @@ func setup(tb testing.TB, c *envConfig) *environment { return env } -func staticConfig(tb testing.TB, f fork) config.Config { - c := config.Config{ - Upgrades: upgrade.Config{ - EtnaTime: mockable.MaxTime, - }, - TxFee: testTxFee, - CreateAssetTxFee: testTxFee, - } - - switch f { - case etna: - c.Upgrades.EtnaTime = time.Time{} - case durango: - default: - require.FailNow(tb, "unhandled fork", f) - } - - return c -} - // Returns: // // 1. tx in genesis that creates asset diff --git a/vms/avm/index_test.go b/vms/avm/index_test.go index 3d8614d5ee6d..dfd62198c312 100644 --- a/vms/avm/index_test.go +++ b/vms/avm/index_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/avalanchego/database/prefixdb" "github.com/ava-labs/avalanchego/database/versiondb" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -27,7 +28,7 @@ import ( func TestIndexTransaction_Ordered(t *testing.T) { require := require.New(t) - env := setup(t, &envConfig{fork: durango}) + env := setup(t, &envConfig{fork: upgradetest.Durango}) defer env.vm.ctx.Lock.Unlock() key := keys[0] @@ -66,7 +67,7 @@ func TestIndexTransaction_Ordered(t *testing.T) { func TestIndexTransaction_MultipleTransactions(t *testing.T) { require := require.New(t) - env := setup(t, &envConfig{fork: durango}) + env := setup(t, &envConfig{fork: upgradetest.Durango}) defer env.vm.ctx.Lock.Unlock() addressTxMap := map[ids.ShortID]*txs.Tx{} @@ -109,7 +110,7 @@ func TestIndexTransaction_MultipleTransactions(t *testing.T) { func TestIndexTransaction_MultipleAddresses(t *testing.T) { require := require.New(t) - env := setup(t, &envConfig{fork: durango}) + env := setup(t, &envConfig{fork: upgradetest.Durango}) defer env.vm.ctx.Lock.Unlock() addrs := make([]ids.ShortID, len(keys)) @@ -147,7 +148,7 @@ func TestIndexTransaction_MultipleAddresses(t *testing.T) { func TestIndexer_Read(t *testing.T) { require := require.New(t) - env := setup(t, &envConfig{fork: durango}) + env := setup(t, &envConfig{fork: upgradetest.Durango}) defer env.vm.ctx.Lock.Unlock() // generate test address and asset IDs diff --git a/vms/avm/service_test.go b/vms/avm/service_test.go index 534424c63b0e..3de4102841d2 100644 --- a/vms/avm/service_test.go +++ b/vms/avm/service_test.go @@ -23,6 +23,7 @@ import ( "github.com/ava-labs/avalanchego/snow/choices" "github.com/ava-labs/avalanchego/snow/engine/common" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/formatting" @@ -49,7 +50,7 @@ func TestServiceIssueTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -72,7 +73,7 @@ func TestServiceGetTxStatus(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -104,7 +105,7 @@ func TestServiceGetBalanceStrict(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} @@ -258,7 +259,7 @@ func TestServiceGetBalanceStrict(t *testing.T) { func TestServiceGetTxs(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} @@ -299,7 +300,7 @@ func TestServiceGetAllBalances(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} @@ -495,7 +496,7 @@ func TestServiceGetTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -520,7 +521,7 @@ func TestServiceGetTxJSON_BaseTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -608,7 +609,7 @@ func TestServiceGetTxJSON_ExportTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -698,7 +699,7 @@ func TestServiceGetTxJSON_CreateAssetTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -891,7 +892,7 @@ func TestServiceGetTxJSON_OperationTxWithNftxMintOp(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -1033,7 +1034,7 @@ func TestServiceGetTxJSON_OperationTxWithMultipleNftxMintOp(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -1214,7 +1215,7 @@ func TestServiceGetTxJSON_OperationTxWithSecpMintOp(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -1357,7 +1358,7 @@ func TestServiceGetTxJSON_OperationTxWithMultipleSecpMintOp(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: durango, + fork: upgradetest.Durango, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -1544,7 +1545,7 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOp(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -1679,7 +1680,7 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOpMultiple(t *testing.T) require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -2010,7 +2011,7 @@ func TestServiceGetNilTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -2024,7 +2025,7 @@ func TestServiceGetUnknownTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -2036,7 +2037,7 @@ func TestServiceGetUnknownTx(t *testing.T) { func TestServiceGetUTXOs(t *testing.T) { env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -2288,7 +2289,7 @@ func TestGetAssetDescription(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -2308,7 +2309,7 @@ func TestGetBalance(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) service := &Service{vm: env.vm} env.vm.ctx.Lock.Unlock() @@ -2332,6 +2333,7 @@ func TestCreateFixedCapAsset(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, @@ -2378,6 +2380,7 @@ func TestCreateVariableCapAsset(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, @@ -2466,6 +2469,7 @@ func TestNFTWorkflow(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, @@ -2584,6 +2588,7 @@ func TestImportExportKey(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, keystoreUsers: []*user{{ username: username, password: password, @@ -2623,6 +2628,7 @@ func TestImportAVMKeyNoDuplicates(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, keystoreUsers: []*user{{ username: username, password: password, @@ -2668,6 +2674,7 @@ func TestSend(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, keystoreUsers: []*user{{ username: username, password: password, @@ -2714,6 +2721,7 @@ func TestSendMultiple(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, @@ -2773,6 +2781,7 @@ func TestCreateAndListAddresses(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, keystoreUsers: []*user{{ username: username, password: password, @@ -2807,6 +2816,7 @@ func TestImport(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ + fork: upgradetest.Durango, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, diff --git a/vms/avm/state_test.go b/vms/avm/state_test.go index 35744fdc63e8..948ca37a8e18 100644 --- a/vms/avm/state_test.go +++ b/vms/avm/state_test.go @@ -11,6 +11,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/engine/common" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/units" @@ -23,7 +24,7 @@ func TestSetsAndGets(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: ids.GenerateTestID(), Fx: &FxTest{ @@ -83,7 +84,7 @@ func TestSetsAndGets(t *testing.T) { func TestFundingNoAddresses(t *testing.T) { env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: ids.GenerateTestID(), Fx: &FxTest{ @@ -113,7 +114,7 @@ func TestFundingAddresses(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: ids.GenerateTestID(), Fx: &FxTest{ diff --git a/vms/avm/vm_benchmark_test.go b/vms/avm/vm_benchmark_test.go index 8a342cfa2477..48725d72da2a 100644 --- a/vms/avm/vm_benchmark_test.go +++ b/vms/avm/vm_benchmark_test.go @@ -11,6 +11,7 @@ import ( "github.com/stretchr/testify/require" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/components/keystore" @@ -22,7 +23,7 @@ func BenchmarkLoadUser(b *testing.B) { require := require.New(b) env := setup(b, &envConfig{ - fork: latest, + fork: upgradetest.Latest, keystoreUsers: []*user{{ username: username, password: password, @@ -64,7 +65,7 @@ func BenchmarkLoadUser(b *testing.B) { func getAllUTXOsBenchmark(b *testing.B, utxoCount int, randSrc rand.Source) { require := require.New(b) - env := setup(b, &envConfig{fork: latest}) + env := setup(b, &envConfig{fork: upgradetest.Latest}) defer env.vm.ctx.Lock.Unlock() addr := ids.GenerateTestShortID() diff --git a/vms/avm/vm_regression_test.go b/vms/avm/vm_regression_test.go index 9e684e756d5c..5edfdb083851 100644 --- a/vms/avm/vm_regression_test.go +++ b/vms/avm/vm_regression_test.go @@ -9,6 +9,7 @@ import ( "github.com/stretchr/testify/require" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/components/verify" "github.com/ava-labs/avalanchego/vms/nftfx" @@ -18,7 +19,7 @@ import ( func TestVerifyFxUsage(t *testing.T) { require := require.New(t) - env := setup(t, &envConfig{fork: latest}) + env := setup(t, &envConfig{fork: upgradetest.Latest}) env.vm.ctx.Lock.Unlock() var ( diff --git a/vms/avm/vm_test.go b/vms/avm/vm_test.go index 33af48c483f8..011d9e00eb1d 100644 --- a/vms/avm/vm_test.go +++ b/vms/avm/vm_test.go @@ -17,6 +17,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/engine/common" "github.com/ava-labs/avalanchego/snow/snowtest" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/avm/txs" @@ -114,7 +115,7 @@ func TestIssueTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) env.vm.ctx.Lock.Unlock() @@ -127,7 +128,7 @@ func TestIssueNFT(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) env.vm.ctx.Lock.Unlock() @@ -200,7 +201,7 @@ func TestIssueProperty(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, additionalFxs: []*common.Fx{{ ID: propertyfx.ID, Fx: &propertyfx.Fx{}, @@ -288,7 +289,7 @@ func TestIssueTxWithFeeAsset(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, isCustomFeeAsset: true, }) env.vm.ctx.Lock.Unlock() @@ -302,7 +303,7 @@ func TestIssueTxWithAnotherAsset(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, isCustomFeeAsset: true, }) env.vm.ctx.Lock.Unlock() @@ -349,7 +350,7 @@ func TestIssueTxWithAnotherAsset(t *testing.T) { func TestVMFormat(t *testing.T) { env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) defer env.vm.ctx.Lock.Unlock() @@ -376,7 +377,7 @@ func TestTxAcceptAfterParseTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, notLinearized: true, }) defer env.vm.ctx.Lock.Unlock() @@ -451,7 +452,7 @@ func TestIssueImportTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: durango, + fork: upgradetest.Durango, }) defer env.vm.ctx.Lock.Unlock() @@ -529,7 +530,7 @@ func TestForceAcceptImportTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: durango, + fork: upgradetest.Durango, notLinearized: true, }) defer env.vm.ctx.Lock.Unlock() @@ -603,7 +604,7 @@ func TestImportTxNotState(t *testing.T) { func TestIssueExportTx(t *testing.T) { require := require.New(t) - env := setup(t, &envConfig{fork: durango}) + env := setup(t, &envConfig{fork: upgradetest.Durango}) defer env.vm.ctx.Lock.Unlock() genesisTx := getCreateTxFromGenesisTest(t, env.genesisBytes, "AVAX") @@ -662,7 +663,7 @@ func TestClearForceAcceptedExportTx(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, }) defer env.vm.ctx.Lock.Unlock() diff --git a/vms/avm/wallet_service_test.go b/vms/avm/wallet_service_test.go index d4423bd31c7d..5bada667fb8c 100644 --- a/vms/avm/wallet_service_test.go +++ b/vms/avm/wallet_service_test.go @@ -10,6 +10,7 @@ import ( "github.com/ava-labs/avalanchego/api" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/linked" "github.com/ava-labs/avalanchego/vms/avm/txs" ) @@ -20,7 +21,7 @@ func TestWalletService_SendMultiple(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { env := setup(t, &envConfig{ - fork: latest, + fork: upgradetest.Latest, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, diff --git a/vms/platformvm/block/builder/builder_test.go b/vms/platformvm/block/builder/builder_test.go index eeddc5bc7f9b..33574b384582 100644 --- a/vms/platformvm/block/builder/builder_test.go +++ b/vms/platformvm/block/builder/builder_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/consensus/snowman" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/timer/mockable" @@ -34,7 +35,7 @@ import ( func TestBuildBlockBasic(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -77,7 +78,7 @@ func TestBuildBlockBasic(t *testing.T) { func TestBuildBlockDoesNotBuildWithEmptyMempool(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -94,7 +95,7 @@ func TestBuildBlockDoesNotBuildWithEmptyMempool(t *testing.T) { func TestBuildBlockShouldReward(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -213,7 +214,7 @@ func TestBuildBlockShouldReward(t *testing.T) { func TestBuildBlockAdvanceTime(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -246,7 +247,7 @@ func TestBuildBlockAdvanceTime(t *testing.T) { func TestBuildBlockForceAdvanceTime(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -301,7 +302,7 @@ func TestBuildBlockForceAdvanceTime(t *testing.T) { func TestBuildBlockInvalidStakingDurations(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -421,7 +422,7 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { func TestPreviouslyDroppedTxsCannotBeReAddedToMempool(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -465,7 +466,7 @@ func TestPreviouslyDroppedTxsCannotBeReAddedToMempool(t *testing.T) { func TestNoErrorOnUnexpectedSetPreferenceDuringBootstrapping(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() diff --git a/vms/platformvm/block/builder/helpers_test.go b/vms/platformvm/block/builder/helpers_test.go index 28220e60a1e7..6666ff89c68c 100644 --- a/vms/platformvm/block/builder/helpers_test.go +++ b/vms/platformvm/block/builder/helpers_test.go @@ -27,6 +27,7 @@ import ( "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -61,15 +62,6 @@ import ( const ( defaultWeight = 10000 trackChecksum = false - - apricotPhase3 fork = iota - apricotPhase5 - banff - cortina - durango - etna - - latestFork = durango ) var ( @@ -97,8 +89,6 @@ func init() { } } -type fork uint8 - type mutableSharedMemory struct { atomic.SharedMemory } @@ -124,7 +114,7 @@ type environment struct { backend txexecutor.Backend } -func newEnvironment(t *testing.T, f fork) *environment { //nolint:unparam +func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { //nolint:unparam require := require.New(t) res := &environment{ @@ -303,7 +293,7 @@ func defaultState( return state } -func defaultConfig(t *testing.T, f fork) *config.Config { +func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { c := &config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), @@ -335,22 +325,22 @@ func defaultConfig(t *testing.T, f fork) *config.Config { } switch f { - case etna: + case upgradetest.Etna: c.UpgradeConfig.EtnaTime = time.Time{} // neglecting fork ordering this for package tests fallthrough - case durango: + case upgradetest.Durango: c.UpgradeConfig.DurangoTime = time.Time{} // neglecting fork ordering for this package's tests fallthrough - case cortina: + case upgradetest.Cortina: c.UpgradeConfig.CortinaTime = time.Time{} // neglecting fork ordering for this package's tests fallthrough - case banff: + case upgradetest.Banff: c.UpgradeConfig.BanffTime = time.Time{} // neglecting fork ordering for this package's tests fallthrough - case apricotPhase5: + case upgradetest.ApricotPhase5: c.UpgradeConfig.ApricotPhase5Time = defaultValidateEndTime fallthrough - case apricotPhase3: + case upgradetest.ApricotPhase3: c.UpgradeConfig.ApricotPhase3Time = defaultValidateEndTime default: require.FailNow(t, "unhandled fork", f) diff --git a/vms/platformvm/block/builder/standard_block_test.go b/vms/platformvm/block/builder/standard_block_test.go index 18ca5bdb3582..6909c0efd794 100644 --- a/vms/platformvm/block/builder/standard_block_test.go +++ b/vms/platformvm/block/builder/standard_block_test.go @@ -12,6 +12,7 @@ import ( "github.com/ava-labs/avalanchego/chains/atomic" "github.com/ava-labs/avalanchego/database/prefixdb" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" @@ -23,7 +24,7 @@ import ( func TestAtomicTxImports(t *testing.T) { require := require.New(t) - env := newEnvironment(t, latestFork) + env := newEnvironment(t, upgradetest.Latest) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index 79f2e78eb19e..4a1ceccce48f 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -28,6 +28,7 @@ import ( "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -63,13 +64,6 @@ const ( defaultWeight = 10000 trackChecksum = false - - apricotPhase3 fork = iota - apricotPhase5 - banff - cortina - durango - etna ) var ( @@ -100,8 +94,6 @@ func init() { type stakerStatus uint -type fork uint8 - type staker struct { nodeID ids.NodeID rewardAddress ids.ShortID @@ -136,7 +128,7 @@ type environment struct { backend *executor.Backend } -func newEnvironment(t *testing.T, ctrl *gomock.Controller, f fork) *environment { +func newEnvironment(t *testing.T, ctrl *gomock.Controller, f upgradetest.Fork) *environment { res := &environment{ isBootstrapped: &utils.Atomic[bool]{}, config: defaultConfig(t, f), @@ -332,7 +324,7 @@ func defaultState( return state } -func defaultConfig(t *testing.T, f fork) *config.Config { +func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { c := &config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), @@ -364,22 +356,22 @@ func defaultConfig(t *testing.T, f fork) *config.Config { } switch f { - case etna: + case upgradetest.Etna: c.UpgradeConfig.EtnaTime = time.Time{} // neglecting fork ordering this for package tests fallthrough - case durango: + case upgradetest.Durango: c.UpgradeConfig.DurangoTime = time.Time{} // neglecting fork ordering for this package's tests fallthrough - case cortina: + case upgradetest.Cortina: c.UpgradeConfig.CortinaTime = time.Time{} // neglecting fork ordering for this package's tests fallthrough - case banff: + case upgradetest.Banff: c.UpgradeConfig.BanffTime = time.Time{} // neglecting fork ordering for this package's tests fallthrough - case apricotPhase5: + case upgradetest.ApricotPhase5: c.UpgradeConfig.ApricotPhase5Time = defaultValidateEndTime fallthrough - case apricotPhase3: + case upgradetest.ApricotPhase3: c.UpgradeConfig.ApricotPhase3Time = defaultValidateEndTime default: require.FailNow(t, "unhandled fork", f) diff --git a/vms/platformvm/block/executor/proposal_block_test.go b/vms/platformvm/block/executor/proposal_block_test.go index 1f6e1123ab8e..0dbcb74c11d5 100644 --- a/vms/platformvm/block/executor/proposal_block_test.go +++ b/vms/platformvm/block/executor/proposal_block_test.go @@ -16,6 +16,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/consensus/snowman" "github.com/ava-labs/avalanchego/snow/snowtest" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -38,7 +39,7 @@ func TestApricotProposalBlockTimeVerification(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - env := newEnvironment(t, ctrl, apricotPhase5) + env := newEnvironment(t, ctrl, upgradetest.ApricotPhase5) // create apricotParentBlk. It's a standard one for simplicity parentHeight := uint64(2022) @@ -140,7 +141,7 @@ func TestBanffProposalBlockTimeVerification(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - env := newEnvironment(t, ctrl, banff) + env := newEnvironment(t, ctrl, upgradetest.Banff) // create parentBlock. It's a standard one for simplicity parentTime := defaultGenesisTime @@ -531,7 +532,7 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { for _, test := range tests { t.Run(test.description, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() env.config.TrackedSubnets.Add(subnetID) @@ -709,7 +710,7 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() env.config.TrackedSubnets.Add(subnetID) @@ -866,7 +867,7 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { for _, tracked := range []bool{true, false} { t.Run(fmt.Sprintf("tracked %t", tracked), func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() if tracked { @@ -980,7 +981,7 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) // Case: Timestamp is after next validator start time // Add a pending validator @@ -1175,7 +1176,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { func TestBanffProposalBlockDelegatorStakers(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) // Case: Timestamp is after next validator start time // Add a pending validator @@ -1370,7 +1371,7 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { func TestAddValidatorProposalBlock(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, durango) + env := newEnvironment(t, nil, upgradetest.Durango) now := env.clk.Time() diff --git a/vms/platformvm/block/executor/standard_block_test.go b/vms/platformvm/block/executor/standard_block_test.go index 3d30030518f9..3dc1f999e789 100644 --- a/vms/platformvm/block/executor/standard_block_test.go +++ b/vms/platformvm/block/executor/standard_block_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/components/avax" @@ -32,7 +33,7 @@ func TestApricotStandardBlockTimeVerification(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - env := newEnvironment(t, ctrl, apricotPhase5) + env := newEnvironment(t, ctrl, upgradetest.ApricotPhase5) // setup and store parent block // it's a standard block for simplicity @@ -84,7 +85,7 @@ func TestBanffStandardBlockTimeVerification(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - env := newEnvironment(t, ctrl, banff) + env := newEnvironment(t, ctrl, upgradetest.Banff) now := env.clk.Time() env.clk.Set(now) @@ -290,7 +291,7 @@ func TestBanffStandardBlockTimeVerification(t *testing.T) { func TestBanffStandardBlockUpdatePrimaryNetworkStakers(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) // Case: Timestamp is after next validator start time // Add a pending validator @@ -491,7 +492,7 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) { for _, test := range tests { t.Run(test.description, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() env.config.TrackedSubnets.Add(subnetID) @@ -594,7 +595,7 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) { // is after the new timestamp func TestBanffStandardBlockRemoveSubnetValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() env.config.TrackedSubnets.Add(subnetID) @@ -698,7 +699,7 @@ func TestBanffStandardBlockTrackedSubnet(t *testing.T) { for _, tracked := range []bool{true, false} { t.Run(fmt.Sprintf("tracked %t", tracked), func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() if tracked { @@ -762,7 +763,7 @@ func TestBanffStandardBlockTrackedSubnet(t *testing.T) { func TestBanffStandardBlockDelegatorStakerWeight(t *testing.T) { require := require.New(t) - env := newEnvironment(t, nil, banff) + env := newEnvironment(t, nil, upgradetest.Banff) // Case: Timestamp is after next validator start time // Add a pending validator diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index f8335a621e07..3c89f712adf7 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -27,6 +27,7 @@ import ( "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/snow/consensus/snowman" "github.com/ava-labs/avalanchego/snow/validators" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -77,7 +78,7 @@ var ( ) func defaultService(t *testing.T) (*Service, *mutableSharedMemory, *txstest.WalletFactory) { - vm, factory, _, mutableSharedMemory := defaultVM(t, latestFork) + vm, factory, _, mutableSharedMemory := defaultVM(t, upgradetest.Latest) return &Service{ vm: vm, diff --git a/vms/platformvm/txs/executor/advance_time_test.go b/vms/platformvm/txs/executor/advance_time_test.go index ed7e80ad195f..e9e54ad8a3e6 100644 --- a/vms/platformvm/txs/executor/advance_time_test.go +++ b/vms/platformvm/txs/executor/advance_time_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/snowtest" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/platformvm/reward" @@ -38,7 +39,7 @@ func newAdvanceTimeTx(t testing.TB, timestamp time.Time) (*txs.Tx, error) { // for the primary network func TestAdvanceTimeTxUpdatePrimaryNetworkStakers(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() dummyHeight := uint64(1) @@ -103,7 +104,7 @@ func TestAdvanceTimeTxUpdatePrimaryNetworkStakers(t *testing.T) { // Ensure semantic verification fails when proposed timestamp is at or before current timestamp func TestAdvanceTimeTxTimestampTooEarly(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) tx, err := newAdvanceTimeTx(t, env.state.GetTimestamp()) require.NoError(err) @@ -129,7 +130,7 @@ func TestAdvanceTimeTxTimestampTooEarly(t *testing.T) { // Ensure semantic verification fails when proposed timestamp is after next validator set change time func TestAdvanceTimeTxTimestampTooLate(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -164,7 +165,7 @@ func TestAdvanceTimeTxTimestampTooLate(t *testing.T) { } // Case: Timestamp is after next validator end time - env = newEnvironment(t, apricotPhase5) + env = newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -366,7 +367,7 @@ func TestAdvanceTimeTxUpdateStakers(t *testing.T) { for _, test := range tests { t.Run(test.description, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -476,7 +477,7 @@ func TestAdvanceTimeTxUpdateStakers(t *testing.T) { // is after the new timestamp func TestAdvanceTimeTxRemoveSubnetValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -590,7 +591,7 @@ func TestTrackedSubnet(t *testing.T) { for _, tracked := range []bool{true, false} { t.Run(fmt.Sprintf("tracked %t", tracked), func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() dummyHeight := uint64(1) @@ -665,7 +666,7 @@ func TestTrackedSubnet(t *testing.T) { func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() dummyHeight := uint64(1) @@ -775,7 +776,7 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) { func TestAdvanceTimeTxDelegatorStakers(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() dummyHeight := uint64(1) @@ -878,7 +879,7 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) { func TestAdvanceTimeTxAfterBanff(t *testing.T) { require := require.New(t) - env := newEnvironment(t, durango) + env := newEnvironment(t, upgradetest.Durango) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() env.clk.Set(defaultGenesisTime) // VM's clock reads the genesis time @@ -912,7 +913,7 @@ func TestAdvanceTimeTxAfterBanff(t *testing.T) { // Ensure marshaling/unmarshaling works func TestAdvanceTimeTxUnmarshal(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go index 1f5e4be4f97a..f8b29b9c275d 100644 --- a/vms/platformvm/txs/executor/create_chain_test.go +++ b/vms/platformvm/txs/executor/create_chain_test.go @@ -12,6 +12,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/hashing" @@ -29,7 +30,7 @@ import ( // Ensure Execute fails when there are not enough control sigs func TestCreateChainTxInsufficientControlSigs(t *testing.T) { require := require.New(t) - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -65,7 +66,7 @@ func TestCreateChainTxInsufficientControlSigs(t *testing.T) { // Ensure Execute fails when an incorrect control signature is given func TestCreateChainTxWrongControlSig(t *testing.T) { require := require.New(t) - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -108,7 +109,7 @@ func TestCreateChainTxWrongControlSig(t *testing.T) { // its validator set doesn't exist func TestCreateChainTxNoSuchSubnet(t *testing.T) { require := require.New(t) - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -146,7 +147,7 @@ func TestCreateChainTxNoSuchSubnet(t *testing.T) { // Ensure valid tx passes semanticVerify func TestCreateChainTxValid(t *testing.T) { require := require.New(t) - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -209,7 +210,7 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.config.UpgradeConfig.ApricotPhase3Time = ap3Time addrs := set.NewSet[ids.ShortID](len(preFundedKeys)) diff --git a/vms/platformvm/txs/executor/create_subnet_test.go b/vms/platformvm/txs/executor/create_subnet_test.go index e88bc05c6745..a991bda7de0e 100644 --- a/vms/platformvm/txs/executor/create_subnet_test.go +++ b/vms/platformvm/txs/executor/create_subnet_test.go @@ -11,6 +11,7 @@ import ( "github.com/stretchr/testify/require" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/platformvm/state" @@ -52,7 +53,7 @@ func TestCreateSubnetTxAP3FeeChange(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase3) + env := newEnvironment(t, upgradetest.ApricotPhase3) env.config.UpgradeConfig.ApricotPhase3Time = ap3Time env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() diff --git a/vms/platformvm/txs/executor/export_test.go b/vms/platformvm/txs/executor/export_test.go index 18e337a82465..d392f0bc9618 100644 --- a/vms/platformvm/txs/executor/export_test.go +++ b/vms/platformvm/txs/executor/export_test.go @@ -11,6 +11,7 @@ import ( "github.com/stretchr/testify/require" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/state" @@ -20,7 +21,7 @@ import ( ) func TestNewExportTx(t *testing.T) { - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() diff --git a/vms/platformvm/txs/executor/helpers_test.go b/vms/platformvm/txs/executor/helpers_test.go index 8aea45ee3317..030ec40697cd 100644 --- a/vms/platformvm/txs/executor/helpers_test.go +++ b/vms/platformvm/txs/executor/helpers_test.go @@ -26,6 +26,7 @@ import ( "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -55,13 +56,6 @@ import ( const ( defaultWeight = 5 * units.MilliAvax trackChecksum = false - - apricotPhase3 fork = iota - apricotPhase5 - banff - cortina - durango - etna ) var ( @@ -90,8 +84,6 @@ func init() { } } -type fork uint8 - type mutableSharedMemory struct { atomic.SharedMemory } @@ -124,7 +116,7 @@ func (e *environment) SetState(blkID ids.ID, chainState state.Chain) { e.states[blkID] = chainState } -func newEnvironment(t *testing.T, f fork) *environment { +func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { var isBootstrapped utils.Atomic[bool] isBootstrapped.Set(true) @@ -275,7 +267,7 @@ func defaultState( return state } -func defaultConfig(t *testing.T, f fork) *config.Config { +func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { c := &config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), @@ -307,22 +299,22 @@ func defaultConfig(t *testing.T, f fork) *config.Config { } switch f { - case etna: + case upgradetest.Etna: c.UpgradeConfig.EtnaTime = defaultValidateStartTime.Add(-2 * time.Second) fallthrough - case durango: + case upgradetest.Durango: c.UpgradeConfig.DurangoTime = defaultValidateStartTime.Add(-2 * time.Second) fallthrough - case cortina: + case upgradetest.Cortina: c.UpgradeConfig.CortinaTime = defaultValidateStartTime.Add(-2 * time.Second) fallthrough - case banff: + case upgradetest.Banff: c.UpgradeConfig.BanffTime = defaultValidateStartTime.Add(-2 * time.Second) fallthrough - case apricotPhase5: + case upgradetest.ApricotPhase5: c.UpgradeConfig.ApricotPhase5Time = defaultValidateEndTime fallthrough - case apricotPhase3: + case upgradetest.ApricotPhase3: c.UpgradeConfig.ApricotPhase3Time = defaultValidateEndTime default: require.FailNow(t, "unhandled fork", f) @@ -331,9 +323,9 @@ func defaultConfig(t *testing.T, f fork) *config.Config { return c } -func defaultClock(f fork) *mockable.Clock { +func defaultClock(f upgradetest.Fork) *mockable.Clock { now := defaultGenesisTime - if f >= banff { + if f >= upgradetest.Banff { // 1 second after active fork now = defaultValidateEndTime.Add(-2 * time.Second) } diff --git a/vms/platformvm/txs/executor/import_test.go b/vms/platformvm/txs/executor/import_test.go index 2aa97c7fee91..ed9ff97375af 100644 --- a/vms/platformvm/txs/executor/import_test.go +++ b/vms/platformvm/txs/executor/import_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/avalanchego/chains/atomic" "github.com/ava-labs/avalanchego/database/prefixdb" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/state" @@ -27,7 +28,7 @@ import ( var fundedSharedMemoryCalls byte func TestNewImportTx(t *testing.T) { - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) type test struct { description string diff --git a/vms/platformvm/txs/executor/proposal_tx_executor_test.go b/vms/platformvm/txs/executor/proposal_tx_executor_test.go index ef80a06365f6..0efbae5e65ba 100644 --- a/vms/platformvm/txs/executor/proposal_tx_executor_test.go +++ b/vms/platformvm/txs/executor/proposal_tx_executor_test.go @@ -13,6 +13,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/hashing" "github.com/ava-labs/avalanchego/vms/platformvm/reward" @@ -109,7 +110,7 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) { require.NoError(env.state.Commit()) } - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) currentTimestamp := env.state.GetTimestamp() type test struct { @@ -241,7 +242,7 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.config.UpgradeConfig.ApricotPhase3Time = tt.AP3Time builder, signer := env.factory.NewWallet(tt.feeKeys...) @@ -287,7 +288,7 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) { func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -808,7 +809,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { func TestProposalTxExecuteAddValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() diff --git a/vms/platformvm/txs/executor/reward_validator_test.go b/vms/platformvm/txs/executor/reward_validator_test.go index 501d31fe4959..04dc3c27af9a 100644 --- a/vms/platformvm/txs/executor/reward_validator_test.go +++ b/vms/platformvm/txs/executor/reward_validator_test.go @@ -13,6 +13,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/snowtest" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/math" "github.com/ava-labs/avalanchego/utils/set" @@ -37,7 +38,7 @@ func newRewardValidatorTx(t testing.TB, txID ids.ID) (*txs.Tx, error) { func TestRewardValidatorTxExecuteOnCommit(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) dummyHeight := uint64(1) currentStakerIterator, err := env.state.GetCurrentStakerIterator() @@ -141,7 +142,7 @@ func TestRewardValidatorTxExecuteOnCommit(t *testing.T) { func TestRewardValidatorTxExecuteOnAbort(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) dummyHeight := uint64(1) currentStakerIterator, err := env.state.GetCurrentStakerIterator() @@ -239,7 +240,7 @@ func TestRewardValidatorTxExecuteOnAbort(t *testing.T) { func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) dummyHeight := uint64(1) vdrRewardAddress := ids.GenerateTestShortID() @@ -373,7 +374,7 @@ func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) { func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { require := require.New(t) - env := newEnvironment(t, cortina) + env := newEnvironment(t, upgradetest.Cortina) dummyHeight := uint64(1) vdrRewardAddress := ids.GenerateTestShortID() @@ -603,7 +604,7 @@ func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { func TestRewardDelegatorTxAndValidatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { require := require.New(t) - env := newEnvironment(t, cortina) + env := newEnvironment(t, upgradetest.Cortina) dummyHeight := uint64(1) vdrRewardAddress := ids.GenerateTestShortID() @@ -776,7 +777,7 @@ func TestRewardDelegatorTxAndValidatorTxExecuteOnCommitPostDelegateeDeferral(t * func TestRewardDelegatorTxExecuteOnAbort(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) dummyHeight := uint64(1) initialSupply, err := env.state.GetCurrentSupply(constants.PrimaryNetworkID) diff --git a/vms/platformvm/txs/executor/staker_tx_verification_test.go b/vms/platformvm/txs/executor/staker_tx_verification_test.go index ee8ead112f93..75f84657bcd7 100644 --- a/vms/platformvm/txs/executor/staker_tx_verification_test.go +++ b/vms/platformvm/txs/executor/staker_tx_verification_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/snow/snowtest" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/timer/mockable" @@ -110,7 +111,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { backendF: func(*gomock.Controller) *Backend { return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), } }, stateF: func(ctrl *gomock.Controller) state.Chain { @@ -131,7 +132,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { backendF: func(*gomock.Controller) *Backend { return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: &utils.Atomic[bool]{}, } }, @@ -155,7 +156,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, cortina, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Cortina, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -179,7 +180,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -206,7 +207,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -233,7 +234,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -261,7 +262,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -292,7 +293,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -323,7 +324,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -356,7 +357,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -383,7 +384,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped.Set(true) return &Backend{ Ctx: ctx, - Config: defaultTestConfig(t, durango, activeForkTime), + Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), Bootstrapped: bootstrapped, } }, @@ -424,7 +425,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { gomock.Any(), ).Return(ErrFlowCheckFailed) - cfg := defaultTestConfig(t, durango, activeForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, activeForkTime) cfg.StaticFeeConfig.AddSubnetValidatorFee = 1 return &Backend{ @@ -470,7 +471,7 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { gomock.Any(), ).Return(nil) - cfg := defaultTestConfig(t, durango, activeForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, activeForkTime) cfg.StaticFeeConfig.AddSubnetValidatorFee = 1 return &Backend{ diff --git a/vms/platformvm/txs/executor/standard_tx_executor_test.go b/vms/platformvm/txs/executor/standard_tx_executor_test.go index d57955c08b39..6600735549ce 100644 --- a/vms/platformvm/txs/executor/standard_tx_executor_test.go +++ b/vms/platformvm/txs/executor/standard_tx_executor_test.go @@ -18,6 +18,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" @@ -49,7 +50,7 @@ var errTest = errors.New("non-nil error") func TestStandardTxExecutorAddValidatorTxEmptyID(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -195,7 +196,7 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) { require.NoError(env.state.Commit()) } - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) currentTimestamp := env.state.GetTimestamp() type test struct { @@ -327,7 +328,7 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.config.UpgradeConfig.ApricotPhase3Time = tt.AP3Time builder, signer := env.factory.NewWallet(tt.feeKeys...) @@ -371,7 +372,7 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) { func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, apricotPhase5) + env := newEnvironment(t, upgradetest.ApricotPhase5) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -894,7 +895,7 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { func TestBanffStandardTxExecutorAddValidator(t *testing.T) { require := require.New(t) - env := newEnvironment(t, banff) + env := newEnvironment(t, upgradetest.Banff) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -1152,7 +1153,7 @@ func TestDurangoDisabledTransactions(t *testing.T) { t.Run(tt.name, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, durango) + env := newEnvironment(t, upgradetest.Durango) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -1569,7 +1570,7 @@ func TestDurangoMemoField(t *testing.T) { t.Run(tt.name, func(t *testing.T) { require := require.New(t) - env := newEnvironment(t, durango) + env := newEnvironment(t, upgradetest.Durango) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -1601,7 +1602,7 @@ func TestDurangoMemoField(t *testing.T) { func TestEtnaDisabledTransactions(t *testing.T) { require := require.New(t) - env := newEnvironment(t, etna) + env := newEnvironment(t, upgradetest.Etna) env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() @@ -1743,7 +1744,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().DeleteUTXO(gomock.Any()).Times(len(env.unsignedTx.Ins)) env.state.EXPECT().AddUTXO(gomock.Any()).Times(len(env.unsignedTx.Outs)) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1771,7 +1772,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1799,7 +1800,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(nil, database.ErrNotFound) env.state.EXPECT().GetPendingValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(nil, database.ErrNotFound) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1830,7 +1831,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(&staker, nil).Times(1) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1859,7 +1860,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(env.staker, nil) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1887,7 +1888,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(env.staker, nil) env.state.EXPECT().GetSubnetOwner(env.unsignedTx.Subnet).Return(nil, database.ErrNotFound) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1917,7 +1918,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetSubnetOwner(env.unsignedTx.Subnet).Return(subnetOwner, nil) env.fx.EXPECT().VerifyPermission(gomock.Any(), env.unsignedTx.SubnetAuth, env.tx.Creds[len(env.tx.Creds)-1], subnetOwner).Return(errTest) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1950,7 +1951,7 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), ).Return(errTest) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -2108,7 +2109,7 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -2135,7 +2136,7 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -2163,7 +2164,7 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) cfg.MaxStakeDuration = math.MaxInt64 feeCalculator := state.PickFeeCalculator(cfg, env.state) @@ -2198,7 +2199,7 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), ).Return(ErrFlowCheckFailed) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) cfg.MaxStakeDuration = math.MaxInt64 feeCalculator := state.PickFeeCalculator(cfg, env.state) @@ -2238,7 +2239,7 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state.EXPECT().DeleteUTXO(gomock.Any()).Times(len(env.unsignedTx.Ins)) env.state.EXPECT().AddUTXO(gomock.Any()).Times(len(env.unsignedTx.Outs)) - cfg := defaultTestConfig(t, durango, env.latestForkTime) + cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) cfg.MaxStakeDuration = math.MaxInt64 feeCalculator := state.PickFeeCalculator(cfg, env.state) @@ -2272,7 +2273,7 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { } } -func defaultTestConfig(t *testing.T, f fork, tm time.Time) *config.Config { +func defaultTestConfig(t *testing.T, f upgradetest.Fork, tm time.Time) *config.Config { c := &config.Config{ UpgradeConfig: upgrade.Config{ ApricotPhase3Time: mockable.MaxTime, @@ -2285,22 +2286,22 @@ func defaultTestConfig(t *testing.T, f fork, tm time.Time) *config.Config { } switch f { - case etna: + case upgradetest.Etna: c.UpgradeConfig.EtnaTime = tm fallthrough - case durango: + case upgradetest.Durango: c.UpgradeConfig.DurangoTime = tm fallthrough - case cortina: + case upgradetest.Cortina: c.UpgradeConfig.CortinaTime = tm fallthrough - case banff: + case upgradetest.Banff: c.UpgradeConfig.BanffTime = tm fallthrough - case apricotPhase5: + case upgradetest.ApricotPhase5: c.UpgradeConfig.ApricotPhase5Time = tm fallthrough - case apricotPhase3: + case upgradetest.ApricotPhase3: c.UpgradeConfig.ApricotPhase3Time = tm default: require.FailNow(t, "unhandled fork", f) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index b967dfd6632f..716ea7a71d2f 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -28,6 +28,7 @@ import ( "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/bloom" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" @@ -53,7 +54,7 @@ import ( func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -258,7 +259,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, apricotPhase3) + vm, factory, _, _ := defaultVM(t, upgradetest.ApricotPhase3) vm.UpgradeConfig.ApricotPhase3Time = test.ap3Time vm.ctx.Lock.Lock() @@ -600,7 +601,7 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { require := require.New(t) - vm, factory, baseDB, mutableSharedMemory := defaultVM(t, cortina) + vm, factory, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -799,7 +800,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { require := require.New(t) - vm, factory, baseDB, mutableSharedMemory := defaultVM(t, cortina) + vm, factory, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1111,7 +1112,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1253,7 +1254,7 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) { delegator2EndTime := delegator2StartTime.Add(3 * defaultMinStakingDuration) delegator2Stake := defaultMaxValidatorStake - validatorStake - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1367,7 +1368,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t validatorStartTime := latestForkTime.Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1516,7 +1517,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t validatorStartTime := latestForkTime.Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1648,7 +1649,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1913,7 +1914,7 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2069,7 +2070,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2288,7 +2289,7 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2426,7 +2427,7 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { func TestValidatorSetRaceCondition(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 939112c03242..7ef99bcdc4c1 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -37,6 +37,7 @@ import ( "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/subnets" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" @@ -77,18 +78,7 @@ import ( walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) -const ( - apricotPhase3 fork = iota - apricotPhase5 - banff - cortina - durango - etna - - latestFork = durango - - defaultWeight uint64 = 10000 -) +const defaultWeight uint64 = 10000 var ( defaultMinStakingDuration = 24 * time.Hour @@ -162,8 +152,6 @@ func init() { } } -type fork uint8 - type mutableSharedMemory struct { atomic.SharedMemory } @@ -228,7 +216,7 @@ func defaultGenesis(t *testing.T, avaxAssetID ids.ID) (*api.BuildGenesisArgs, [] return &buildGenesisArgs, genesisBytes } -func defaultVM(t *testing.T, f fork) (*VM, *txstest.WalletFactory, database.Database, *mutableSharedMemory) { +func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, database.Database, *mutableSharedMemory) { require := require.New(t) var ( apricotPhase3Time = mockable.MaxTime @@ -243,22 +231,22 @@ func defaultVM(t *testing.T, f fork) (*VM, *txstest.WalletFactory, database.Data // to ensure test independence latestForkTime = defaultGenesisTime.Add(time.Second) switch f { - case etna: + case upgradetest.Etna: etnaTime = latestForkTime fallthrough - case durango: + case upgradetest.Durango: durangoTime = latestForkTime fallthrough - case cortina: + case upgradetest.Cortina: cortinaTime = latestForkTime fallthrough - case banff: + case upgradetest.Banff: banffTime = latestForkTime fallthrough - case apricotPhase5: + case upgradetest.ApricotPhase5: apricotPhase5Time = latestForkTime fallthrough - case apricotPhase3: + case upgradetest.ApricotPhase3: apricotPhase3Time = latestForkTime default: require.FailNow("unhandled fork", f) @@ -381,7 +369,7 @@ func defaultVM(t *testing.T, f fork) (*VM, *txstest.WalletFactory, database.Data // Ensure genesis state is parsed from bytes and stored correctly func TestGenesis(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, latestFork) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -435,7 +423,7 @@ func TestGenesis(t *testing.T) { // accept proposal to add validator to primary network func TestAddValidatorCommit(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -500,7 +488,7 @@ func TestAddValidatorCommit(t *testing.T) { // verify invalid attempt to add validator to primary network func TestInvalidAddValidatorCommit(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -556,7 +544,7 @@ func TestInvalidAddValidatorCommit(t *testing.T) { // Reject attempt to add validator to primary network func TestAddValidatorReject(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, cortina) + vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -607,7 +595,7 @@ func TestAddValidatorReject(t *testing.T) { // Reject proposal to add validator to primary network func TestAddValidatorInvalidNotReissued(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -658,7 +646,7 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) { // Accept proposal to add validator to subnet func TestAddSubnetValidatorAccept(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -710,7 +698,7 @@ func TestAddSubnetValidatorAccept(t *testing.T) { // Reject proposal to add validator to subnet func TestAddSubnetValidatorReject(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -761,7 +749,7 @@ func TestAddSubnetValidatorReject(t *testing.T) { // Test case where primary network validator rewarded func TestRewardValidatorAccept(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, latestFork) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -829,7 +817,7 @@ func TestRewardValidatorAccept(t *testing.T) { // Test case where primary network validator not rewarded func TestRewardValidatorReject(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, latestFork) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -899,7 +887,7 @@ func TestRewardValidatorReject(t *testing.T) { // Ensure BuildBlock errors when there is no block to build func TestUnneededBuildBlock(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, latestFork) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -910,7 +898,7 @@ func TestUnneededBuildBlock(t *testing.T) { // test acceptance of proposal to create a new chain func TestCreateChain(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -960,7 +948,7 @@ func TestCreateChain(t *testing.T) { // 3) Advance timestamp to validator's end time (removing validator from current) func TestCreateSubnet(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1062,7 +1050,7 @@ func TestCreateSubnet(t *testing.T) { // test asset import func TestAtomicImport(t *testing.T) { require := require.New(t) - vm, factory, baseDB, mutableSharedMemory := defaultVM(t, latestFork) + vm, factory, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1154,7 +1142,7 @@ func TestAtomicImport(t *testing.T) { // test optimistic asset import func TestOptimisticAtomicImport(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, apricotPhase3) + vm, _, _, _ := defaultVM(t, upgradetest.ApricotPhase3) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1817,7 +1805,7 @@ func TestUnverifiedParent(t *testing.T) { } func TestMaxStakeAmount(t *testing.T) { - vm, _, _, _ := defaultVM(t, latestFork) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2130,7 +2118,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { validatorStartTime := latestForkTime.Add(txexecutor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2266,7 +2254,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { func TestTransferSubnetOwnershipTx(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2355,7 +2343,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { func TestBaseTx(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2441,7 +2429,7 @@ func TestBaseTx(t *testing.T) { func TestPruneMempool(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, latestFork) + vm, factory, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() From 700b9af48485f0bf71a2f40444a522c5703dbc89 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 19:39:54 -0400 Subject: [PATCH 024/114] nits --- upgrade/upgradetest/config.go | 30 +++--- vms/avm/block/executor/block_test.go | 6 +- vms/avm/service_test.go | 7 +- .../txs/executor/syntactic_verifier_test.go | 7 +- .../block/executor/verifier_test.go | 65 +++---------- .../executor/staker_tx_verification_test.go | 92 ++++++++++++------ .../txs/executor/standard_tx_executor_test.go | 97 ++++++++----------- vms/platformvm/validator_set_property_test.go | 13 +-- vms/platformvm/vm_regression_test.go | 9 +- vms/platformvm/vm_test.go | 90 ++--------------- vms/proposervm/block_test.go | 14 +-- vms/proposervm/post_fork_option_test.go | 8 +- vms/proposervm/state_syncable_vm_test.go | 9 +- vms/proposervm/vm_test.go | 13 +-- 14 files changed, 163 insertions(+), 297 deletions(-) diff --git a/upgrade/upgradetest/config.go b/upgrade/upgradetest/config.go index 3eb86363740d..0c66a0c119f5 100644 --- a/upgrade/upgradetest/config.go +++ b/upgrade/upgradetest/config.go @@ -4,11 +4,17 @@ package upgradetest import ( + "time" + "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/upgrade" ) func GetConfig(fork Fork) upgrade.Config { + return GetConfigWithUpgradeTime(fork, upgrade.InitiallyActiveTime) +} + +func GetConfigWithUpgradeTime(fork Fork, upgradeTime time.Time) upgrade.Config { c := upgrade.Config{ ApricotPhase1Time: upgrade.UnscheduledActivationTime, ApricotPhase2Time: upgrade.UnscheduledActivationTime, @@ -28,40 +34,40 @@ func GetConfig(fork Fork) upgrade.Config { switch fork { case Etna: - c.EtnaTime = upgrade.InitiallyActiveTime + c.EtnaTime = upgradeTime fallthrough case Durango: - c.DurangoTime = upgrade.InitiallyActiveTime + c.DurangoTime = upgradeTime fallthrough case Cortina: - c.CortinaTime = upgrade.InitiallyActiveTime + c.CortinaTime = upgradeTime fallthrough case Banff: - c.BanffTime = upgrade.InitiallyActiveTime + c.BanffTime = upgradeTime fallthrough case ApricotPhasePost6: - c.ApricotPhasePost6Time = upgrade.InitiallyActiveTime + c.ApricotPhasePost6Time = upgradeTime fallthrough case ApricotPhase6: - c.ApricotPhase6Time = upgrade.InitiallyActiveTime + c.ApricotPhase6Time = upgradeTime fallthrough case ApricotPhasePre6: - c.ApricotPhasePre6Time = upgrade.InitiallyActiveTime + c.ApricotPhasePre6Time = upgradeTime fallthrough case ApricotPhase5: - c.ApricotPhase5Time = upgrade.InitiallyActiveTime + c.ApricotPhase5Time = upgradeTime fallthrough case ApricotPhase4: - c.ApricotPhase4Time = upgrade.InitiallyActiveTime + c.ApricotPhase4Time = upgradeTime fallthrough case ApricotPhase3: - c.ApricotPhase3Time = upgrade.InitiallyActiveTime + c.ApricotPhase3Time = upgradeTime fallthrough case ApricotPhase2: - c.ApricotPhase2Time = upgrade.InitiallyActiveTime + c.ApricotPhase2Time = upgradeTime fallthrough case ApricotPhase1: - c.ApricotPhase1Time = upgrade.InitiallyActiveTime + c.ApricotPhase1Time = upgradeTime } return c } diff --git a/vms/avm/block/executor/block_test.go b/vms/avm/block/executor/block_test.go index c95796da638f..0a3e8e42059a 100644 --- a/vms/avm/block/executor/block_test.go +++ b/vms/avm/block/executor/block_test.go @@ -15,7 +15,7 @@ import ( "github.com/ava-labs/avalanchego/chains/atomic" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/set" @@ -940,9 +940,7 @@ func defaultTestBackend(bootstrapped bool, sharedMemory atomic.SharedMemory) *ex Log: logging.NoLog{}, }, Config: &config.Config{ - Upgrades: upgrade.Config{ - EtnaTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfig(upgradetest.Durango), TxFee: 0, CreateAssetTxFee: 0, }, diff --git a/vms/avm/service_test.go b/vms/avm/service_test.go index 3de4102841d2..b052552e4a13 100644 --- a/vms/avm/service_test.go +++ b/vms/avm/service_test.go @@ -22,14 +22,12 @@ import ( "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/snow/choices" "github.com/ava-labs/avalanchego/snow/engine/common" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/formatting" "github.com/ava-labs/avalanchego/utils/formatting/address" "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/avm/block" "github.com/ava-labs/avalanchego/vms/avm/block/executor" @@ -2721,7 +2719,6 @@ func TestSendMultiple(t *testing.T) { require := require.New(t) env := setup(t, &envConfig{ - fork: upgradetest.Durango, isCustomFeeAsset: !tc.avaxAsset, keystoreUsers: []*user{{ username: username, @@ -2729,9 +2726,7 @@ func TestSendMultiple(t *testing.T) { initialKeys: keys, }}, vmStaticConfig: &config.Config{ - Upgrades: upgrade.Config{ - EtnaTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfig(upgradetest.Durango), }, }) service := &Service{vm: env.vm} diff --git a/vms/avm/txs/executor/syntactic_verifier_test.go b/vms/avm/txs/executor/syntactic_verifier_test.go index a5811163bad1..438e936af7a8 100644 --- a/vms/avm/txs/executor/syntactic_verifier_test.go +++ b/vms/avm/txs/executor/syntactic_verifier_test.go @@ -12,10 +12,9 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow/snowtest" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" - "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/vms/avm/config" "github.com/ava-labs/avalanchego/vms/avm/fxs" "github.com/ava-labs/avalanchego/vms/avm/txs" @@ -29,9 +28,7 @@ import ( var ( keys = secp256k1.TestKeys() feeConfig = config.Config{ - Upgrades: upgrade.Config{ - EtnaTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfig(upgradetest.Durango), TxFee: 2, CreateAssetTxFee: 3, } diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index 5c058e7c69ee..535e7d70f37e 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -15,7 +15,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/timer/mockable" @@ -61,9 +61,7 @@ func TestVerifierVisitProposalBlock(t *testing.T) { manager := &manager{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -143,10 +141,7 @@ func TestVerifierVisitAtomicBlock(t *testing.T) { manager := &manager{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - ApricotPhase5Time: time.Now().Add(time.Hour), - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -228,10 +223,7 @@ func TestVerifierVisitStandardBlock(t *testing.T) { manager := &manager{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - ApricotPhase5Time: time.Now().Add(time.Hour), - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -332,9 +324,7 @@ func TestVerifierVisitCommitBlock(t *testing.T) { manager := &manager{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -401,9 +391,7 @@ func TestVerifierVisitAbortBlock(t *testing.T) { manager := &manager{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -458,9 +446,7 @@ func TestVerifyUnverifiedParent(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -532,9 +518,7 @@ func TestBanffAbortBlockTimestampChecks(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: time.Time{}, // banff is activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.Banff), }, Clk: &mockable.Clock{}, }, @@ -631,9 +615,7 @@ func TestBanffCommitBlockTimestampChecks(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: time.Time{}, // banff is activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.Banff), }, Clk: &mockable.Clock{}, }, @@ -713,10 +695,7 @@ func TestVerifierVisitStandardBlockWithDuplicateInputs(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - ApricotPhase5Time: time.Now().Add(time.Hour), - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -805,9 +784,7 @@ func TestVerifierVisitApricotStandardBlockWithProposalBlockParent(t *testing.T) verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -864,9 +841,7 @@ func TestVerifierVisitBanffStandardBlockWithProposalBlockParent(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: time.Time{}, // banff is activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.Banff), }, Clk: &mockable.Clock{}, }, @@ -903,9 +878,7 @@ func TestVerifierVisitApricotCommitBlockUnexpectedParentState(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -948,9 +921,7 @@ func TestVerifierVisitBanffCommitBlockUnexpectedParentState(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: time.Time{}, // banff is activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.Banff), }, Clk: &mockable.Clock{}, }, @@ -994,9 +965,7 @@ func TestVerifierVisitApricotAbortBlockUnexpectedParentState(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: mockable.MaxTime, // banff is not activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.ApricotPhasePost6), }, Clk: &mockable.Clock{}, }, @@ -1039,9 +1008,7 @@ func TestVerifierVisitBanffAbortBlockUnexpectedParentState(t *testing.T) { verifier := &verifier{ txExecutorBackend: &executor.Backend{ Config: &config.Config{ - UpgradeConfig: upgrade.Config{ - BanffTime: time.Time{}, // banff is activated - }, + UpgradeConfig: upgradetest.GetConfig(upgradetest.Banff), }, Clk: &mockable.Clock{}, }, diff --git a/vms/platformvm/txs/executor/staker_tx_verification_test.go b/vms/platformvm/txs/executor/staker_tx_verification_test.go index 75f84657bcd7..aa8ea9319c81 100644 --- a/vms/platformvm/txs/executor/staker_tx_verification_test.go +++ b/vms/platformvm/txs/executor/staker_tx_verification_test.go @@ -23,6 +23,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/config" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" ) @@ -110,10 +111,13 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { name: "fail syntactic verification", backendF: func(*gomock.Controller) *Backend { return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, } }, + stateF: func(ctrl *gomock.Controller) state.Chain { mockState := state.NewMockChain(ctrl) mockState.EXPECT().GetTimestamp().Return(now) @@ -131,8 +135,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { name: "not bootstrapped", backendF: func(*gomock.Controller) *Backend { return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: &utils.Atomic[bool]{}, } }, @@ -155,8 +161,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Cortina, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Cortina, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -179,8 +187,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -206,8 +216,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -233,8 +245,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -261,8 +275,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -292,8 +308,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -323,8 +341,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -356,8 +376,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -383,8 +405,10 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { bootstrapped := &utils.Atomic[bool]{} bootstrapped.Set(true) return &Backend{ - Ctx: ctx, - Config: defaultTestConfig(t, upgradetest.Durango, activeForkTime), + Ctx: ctx, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + }, Bootstrapped: bootstrapped, } }, @@ -425,12 +449,14 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { gomock.Any(), ).Return(ErrFlowCheckFailed) - cfg := defaultTestConfig(t, upgradetest.Durango, activeForkTime) - cfg.StaticFeeConfig.AddSubnetValidatorFee = 1 - return &Backend{ - FlowChecker: flowChecker, - Config: cfg, + FlowChecker: flowChecker, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + StaticFeeConfig: fee.StaticConfig{ + AddSubnetValidatorFee: 1, + }, + }, Ctx: ctx, Bootstrapped: bootstrapped, } @@ -471,12 +497,14 @@ func TestVerifyAddPermissionlessValidatorTx(t *testing.T) { gomock.Any(), ).Return(nil) - cfg := defaultTestConfig(t, upgradetest.Durango, activeForkTime) - cfg.StaticFeeConfig.AddSubnetValidatorFee = 1 - return &Backend{ - FlowChecker: flowChecker, - Config: cfg, + FlowChecker: flowChecker, + Config: &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, activeForkTime), + StaticFeeConfig: fee.StaticConfig{ + AddSubnetValidatorFee: 1, + }, + }, Ctx: ctx, Bootstrapped: bootstrapped, } diff --git a/vms/platformvm/txs/executor/standard_tx_executor_test.go b/vms/platformvm/txs/executor/standard_tx_executor_test.go index 6600735549ce..7e7c2c3c0269 100644 --- a/vms/platformvm/txs/executor/standard_tx_executor_test.go +++ b/vms/platformvm/txs/executor/standard_tx_executor_test.go @@ -17,14 +17,12 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/hashing" - "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/components/verify" @@ -1744,7 +1742,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().DeleteUTXO(gomock.Any()).Times(len(env.unsignedTx.Ins)) env.state.EXPECT().AddUTXO(gomock.Any()).Times(len(env.unsignedTx.Outs)) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1772,7 +1772,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1800,7 +1802,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(nil, database.ErrNotFound) env.state.EXPECT().GetPendingValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(nil, database.ErrNotFound) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1831,7 +1835,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(&staker, nil).Times(1) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1860,7 +1866,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(env.staker, nil) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1888,7 +1896,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetCurrentValidator(env.unsignedTx.Subnet, env.unsignedTx.NodeID).Return(env.staker, nil) env.state.EXPECT().GetSubnetOwner(env.unsignedTx.Subnet).Return(nil, database.ErrNotFound) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1918,7 +1928,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { env.state.EXPECT().GetSubnetOwner(env.unsignedTx.Subnet).Return(subnetOwner, nil) env.fx.EXPECT().VerifyPermission(gomock.Any(), env.unsignedTx.SubnetAuth, env.tx.Creds[len(env.tx.Creds)-1], subnetOwner).Return(errTest) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -1951,7 +1963,9 @@ func TestStandardExecutorRemoveSubnetValidatorTx(t *testing.T) { gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), ).Return(errTest) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -2109,7 +2123,9 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -2136,7 +2152,9 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ Backend: &Backend{ @@ -2164,8 +2182,10 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state = state.NewMockDiff(ctrl) env.state.EXPECT().GetTimestamp().Return(env.latestForkTime).AnyTimes() - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) - cfg.MaxStakeDuration = math.MaxInt64 + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + MaxStakeDuration: math.MaxInt64, + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ @@ -2199,8 +2219,10 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), ).Return(ErrFlowCheckFailed) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) - cfg.MaxStakeDuration = math.MaxInt64 + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + MaxStakeDuration: math.MaxInt64, + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ @@ -2239,8 +2261,10 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { env.state.EXPECT().DeleteUTXO(gomock.Any()).Times(len(env.unsignedTx.Ins)) env.state.EXPECT().AddUTXO(gomock.Any()).Times(len(env.unsignedTx.Outs)) - cfg := defaultTestConfig(t, upgradetest.Durango, env.latestForkTime) - cfg.MaxStakeDuration = math.MaxInt64 + cfg := &config.Config{ + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, env.latestForkTime), + MaxStakeDuration: math.MaxInt64, + } feeCalculator := state.PickFeeCalculator(cfg, env.state) e := &StandardTxExecutor{ @@ -2272,40 +2296,3 @@ func TestStandardExecutorTransformSubnetTx(t *testing.T) { }) } } - -func defaultTestConfig(t *testing.T, f upgradetest.Fork, tm time.Time) *config.Config { - c := &config.Config{ - UpgradeConfig: upgrade.Config{ - ApricotPhase3Time: mockable.MaxTime, - ApricotPhase5Time: mockable.MaxTime, - BanffTime: mockable.MaxTime, - CortinaTime: mockable.MaxTime, - DurangoTime: mockable.MaxTime, - EtnaTime: mockable.MaxTime, - }, - } - - switch f { - case upgradetest.Etna: - c.UpgradeConfig.EtnaTime = tm - fallthrough - case upgradetest.Durango: - c.UpgradeConfig.DurangoTime = tm - fallthrough - case upgradetest.Cortina: - c.UpgradeConfig.CortinaTime = tm - fallthrough - case upgradetest.Banff: - c.UpgradeConfig.BanffTime = tm - fallthrough - case upgradetest.ApricotPhase5: - c.UpgradeConfig.ApricotPhase5Time = tm - fallthrough - case upgradetest.ApricotPhase3: - c.UpgradeConfig.ApricotPhase3Time = tm - default: - require.FailNow(t, "unhandled fork", f) - } - - return c -} diff --git a/vms/platformvm/validator_set_property_test.go b/vms/platformvm/validator_set_property_test.go index 3411fb7e1d72..3935b75416a9 100644 --- a/vms/platformvm/validator_set_property_test.go +++ b/vms/platformvm/validator_set_property_test.go @@ -29,7 +29,7 @@ import ( "github.com/ava-labs/avalanchego/snow/snowtest" "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/formatting" @@ -645,7 +645,6 @@ func TestTimestampListGenerator(t *testing.T) { // add a single validator at the end of times, // to make sure it won't pollute our tests func buildVM(t *testing.T) (*VM, ids.ID, error) { - forkTime := defaultGenesisTime vm := &VM{Config: config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), @@ -663,15 +662,9 @@ func buildVM(t *testing.T) (*VM, ids.ID, error) { MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - ApricotPhase3Time: forkTime, - ApricotPhase5Time: forkTime, - BanffTime: forkTime, - CortinaTime: forkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, defaultGenesisTime), }} - vm.clock.Set(forkTime.Add(time.Second)) + vm.clock.Set(defaultGenesisTime.Add(time.Second)) baseDB := memdb.New() chainDB := prefixdb.New([]byte{0}, baseDB) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 716ea7a71d2f..3146a8372518 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -27,13 +27,11 @@ import ( "github.com/ava-labs/avalanchego/snow/snowtest" "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/bloom" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" - "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/version" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/block" @@ -457,12 +455,7 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: mockable.MaxTime, - DurangoTime: mockable.MaxTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Banff, latestForkTime), }} ctx := snowtest.Context(t, snowtest.PChainID) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 7ef99bcdc4c1..4175c0346c70 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -36,7 +36,6 @@ import ( "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/subnets" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" @@ -49,7 +48,6 @@ import ( "github.com/ava-labs/avalanchego/utils/resource" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/timer" - "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/version" "github.com/ava-labs/avalanchego/vms/components/avax" @@ -218,40 +216,10 @@ func defaultGenesis(t *testing.T, avaxAssetID ids.ID) (*api.BuildGenesisArgs, [] func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, database.Database, *mutableSharedMemory) { require := require.New(t) - var ( - apricotPhase3Time = mockable.MaxTime - apricotPhase5Time = mockable.MaxTime - banffTime = mockable.MaxTime - cortinaTime = mockable.MaxTime - durangoTime = mockable.MaxTime - etnaTime = mockable.MaxTime - ) // always reset latestForkTime (a package level variable) // to ensure test independence latestForkTime = defaultGenesisTime.Add(time.Second) - switch f { - case upgradetest.Etna: - etnaTime = latestForkTime - fallthrough - case upgradetest.Durango: - durangoTime = latestForkTime - fallthrough - case upgradetest.Cortina: - cortinaTime = latestForkTime - fallthrough - case upgradetest.Banff: - banffTime = latestForkTime - fallthrough - case upgradetest.ApricotPhase5: - apricotPhase5Time = latestForkTime - fallthrough - case upgradetest.ApricotPhase3: - apricotPhase3Time = latestForkTime - default: - require.FailNow("unhandled fork", f) - } - vm := &VM{Config: config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), @@ -265,14 +233,7 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - ApricotPhase3Time: apricotPhase3Time, - ApricotPhase5Time: apricotPhase5Time, - BanffTime: banffTime, - CortinaTime: cortinaTime, - DurangoTime: durangoTime, - EtnaTime: etnaTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(f, latestForkTime), }} db := memdb.New() @@ -1209,12 +1170,7 @@ func TestRestartFullyAccepted(t *testing.T) { MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} firstCtx := snowtest.Context(t, snowtest.PChainID) @@ -1299,12 +1255,7 @@ func TestRestartFullyAccepted(t *testing.T) { MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} secondCtx := snowtest.Context(t, snowtest.PChainID) @@ -1350,12 +1301,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) { MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} initialClkTime := latestForkTime.Add(time.Second) @@ -1701,12 +1647,7 @@ func TestUnverifiedParent(t *testing.T) { MinStakeDuration: defaultMinStakingDuration, MaxStakeDuration: defaultMaxStakingDuration, RewardConfig: defaultRewardConfig, - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} initialClkTime := latestForkTime.Add(time.Second) @@ -1864,12 +1805,7 @@ func TestUptimeDisallowedWithRestart(t *testing.T) { RewardConfig: defaultRewardConfig, Validators: validators.NewManager(), UptimeLockedCalculator: uptime.NewLockedCalculator(), - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} firstCtx := snowtest.Context(t, snowtest.PChainID) @@ -1915,12 +1851,7 @@ func TestUptimeDisallowedWithRestart(t *testing.T) { UptimePercentage: secondUptimePercentage / 100., Validators: validators.NewManager(), UptimeLockedCalculator: uptime.NewLockedCalculator(), - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} secondCtx := snowtest.Context(t, snowtest.PChainID) @@ -2017,12 +1948,7 @@ func TestUptimeDisallowedAfterNeverConnecting(t *testing.T) { RewardConfig: defaultRewardConfig, Validators: validators.NewManager(), UptimeLockedCalculator: uptime.NewLockedCalculator(), - UpgradeConfig: upgrade.Config{ - BanffTime: latestForkTime, - CortinaTime: latestForkTime, - DurangoTime: latestForkTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgradetest.GetConfigWithUpgradeTime(upgradetest.Durango, latestForkTime), }} ctx := snowtest.Context(t, snowtest.PChainID) diff --git a/vms/proposervm/block_test.go b/vms/proposervm/block_test.go index 6c04c5d13948..4603a30f40d4 100644 --- a/vms/proposervm/block_test.go +++ b/vms/proposervm/block_test.go @@ -23,7 +23,7 @@ import ( "github.com/ava-labs/avalanchego/snow/engine/snowman/block" "github.com/ava-labs/avalanchego/snow/validators" "github.com/ava-labs/avalanchego/staking" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/vms/proposervm/proposer" @@ -72,11 +72,7 @@ func TestPostForkCommonComponents_buildChild(t *testing.T) { require.NoError(err) vm := &VM{ Config: Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfig(upgradetest.Latest), StakingCertLeaf: &staking.Certificate{}, StakingLeafSigner: pk, Registerer: prometheus.NewRegistry(), @@ -388,11 +384,7 @@ func TestPostDurangoBuildChildResetScheduler(t *testing.T) { require.NoError(err) vm := &VM{ Config: Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfig(upgradetest.Latest), StakingCertLeaf: &staking.Certificate{}, StakingLeafSigner: pk, Registerer: prometheus.NewRegistry(), diff --git a/vms/proposervm/post_fork_option_test.go b/vms/proposervm/post_fork_option_test.go index 3a76bc9faa06..0cce5076449f 100644 --- a/vms/proposervm/post_fork_option_test.go +++ b/vms/proposervm/post_fork_option_test.go @@ -19,7 +19,7 @@ import ( "github.com/ava-labs/avalanchego/snow/consensus/snowman/snowmantest" "github.com/ava-labs/avalanchego/snow/engine/common" "github.com/ava-labs/avalanchego/snow/snowtest" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/vms/proposervm/block" ) @@ -528,11 +528,7 @@ func TestOptionTimestampValidity(t *testing.T) { proVM = New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfig(upgradetest.Latest), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, diff --git a/vms/proposervm/state_syncable_vm_test.go b/vms/proposervm/state_syncable_vm_test.go index 1017c35d8a40..41f699790934 100644 --- a/vms/proposervm/state_syncable_vm_test.go +++ b/vms/proposervm/state_syncable_vm_test.go @@ -6,7 +6,6 @@ package proposervm import ( "context" "testing" - "time" "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/require" @@ -23,7 +22,7 @@ import ( "github.com/ava-labs/avalanchego/snow/engine/snowman/block" "github.com/ava-labs/avalanchego/snow/engine/snowman/block/blocktest" "github.com/ava-labs/avalanchego/snow/snowtest" - "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/vms/proposervm/summary" statelessblock "github.com/ava-labs/avalanchego/vms/proposervm/block" @@ -61,11 +60,7 @@ func helperBuildStateSyncTestObjects(t *testing.T) (*fullVM, *VM) { vm := New( innerVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfig(upgradetest.Latest), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, diff --git a/vms/proposervm/vm_test.go b/vms/proposervm/vm_test.go index e5d5f142281c..8d1356f859b8 100644 --- a/vms/proposervm/vm_test.go +++ b/vms/proposervm/vm_test.go @@ -32,6 +32,7 @@ import ( "github.com/ava-labs/avalanchego/snow/validators/validatorstest" "github.com/ava-labs/avalanchego/staking" "github.com/ava-labs/avalanchego/upgrade" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/timer/mockable" @@ -1910,11 +1911,7 @@ func TestVMInnerBlkCache(t *testing.T) { vm := New( innerVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfig(upgradetest.Latest), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -2022,11 +2019,7 @@ func TestVM_VerifyBlockWithContext(t *testing.T) { vm := New( innerVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfig(upgradetest.Latest), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, From eecb49e9e6fa773a104675376fbf4560225d6fbe Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 22:29:51 -0400 Subject: [PATCH 025/114] more cleanup --- upgrade/upgradetest/config.go | 18 ++----- vms/platformvm/block/builder/helpers_test.go | 48 +++++------------- vms/platformvm/block/executor/helpers_test.go | 48 +++++------------- vms/platformvm/txs/executor/helpers_test.go | 50 ++++++------------- vms/proposervm/vm_test.go | 48 +++--------------- 5 files changed, 51 insertions(+), 161 deletions(-) diff --git a/upgrade/upgradetest/config.go b/upgrade/upgradetest/config.go index 0c66a0c119f5..9b2b26d1bfab 100644 --- a/upgrade/upgradetest/config.go +++ b/upgrade/upgradetest/config.go @@ -16,22 +16,15 @@ func GetConfig(fork Fork) upgrade.Config { func GetConfigWithUpgradeTime(fork Fork, upgradeTime time.Time) upgrade.Config { c := upgrade.Config{ - ApricotPhase1Time: upgrade.UnscheduledActivationTime, - ApricotPhase2Time: upgrade.UnscheduledActivationTime, - ApricotPhase3Time: upgrade.UnscheduledActivationTime, - ApricotPhase4Time: upgrade.UnscheduledActivationTime, ApricotPhase4MinPChainHeight: 0, - ApricotPhase5Time: upgrade.UnscheduledActivationTime, - ApricotPhasePre6Time: upgrade.UnscheduledActivationTime, - ApricotPhase6Time: upgrade.UnscheduledActivationTime, - ApricotPhasePost6Time: upgrade.UnscheduledActivationTime, - BanffTime: upgrade.UnscheduledActivationTime, - CortinaTime: upgrade.UnscheduledActivationTime, CortinaXChainStopVertexID: ids.Empty, - DurangoTime: upgrade.UnscheduledActivationTime, - EtnaTime: upgrade.UnscheduledActivationTime, } + SetConfigTimesTo(&c, Latest, upgrade.UnscheduledActivationTime) + SetConfigTimesTo(&c, fork, upgradeTime) + return c +} +func SetConfigTimesTo(c *upgrade.Config, fork Fork, upgradeTime time.Time) { switch fork { case Etna: c.EtnaTime = upgradeTime @@ -69,5 +62,4 @@ func GetConfigWithUpgradeTime(fork Fork, upgradeTime time.Time) upgrade.Config { case ApricotPhase1: c.ApricotPhase1Time = upgradeTime } - return c } diff --git a/vms/platformvm/block/builder/helpers_test.go b/vms/platformvm/block/builder/helpers_test.go index 6666ff89c68c..0b5ef4149dcd 100644 --- a/vms/platformvm/block/builder/helpers_test.go +++ b/vms/platformvm/block/builder/helpers_test.go @@ -26,7 +26,6 @@ import ( "github.com/ava-labs/avalanchego/snow/snowtest" "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" @@ -119,7 +118,7 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { //nolint:un res := &environment{ isBootstrapped: &utils.Atomic[bool]{}, - config: defaultConfig(t, f), + config: defaultConfig(f), clk: defaultClock(), } res.isBootstrapped.Set(true) @@ -293,8 +292,16 @@ func defaultState( return state } -func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { - c := &config.Config{ +func defaultConfig(f upgradetest.Fork) *config.Config { + upgrades := upgradetest.GetConfigWithUpgradeTime(f, time.Time{}) + // This package neglects fork ordering + upgradetest.SetConfigTimesTo( + &upgrades, + min(f, upgradetest.ApricotPhase5), + defaultValidateEndTime, + ) + + return &config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), Validators: validators.NewManager(), @@ -314,39 +321,8 @@ func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { MintingPeriod: 365 * 24 * time.Hour, SupplyCap: 720 * units.MegaAvax, }, - UpgradeConfig: upgrade.Config{ - ApricotPhase3Time: mockable.MaxTime, - ApricotPhase5Time: mockable.MaxTime, - BanffTime: mockable.MaxTime, - CortinaTime: mockable.MaxTime, - DurangoTime: mockable.MaxTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgrades, } - - switch f { - case upgradetest.Etna: - c.UpgradeConfig.EtnaTime = time.Time{} // neglecting fork ordering this for package tests - fallthrough - case upgradetest.Durango: - c.UpgradeConfig.DurangoTime = time.Time{} // neglecting fork ordering for this package's tests - fallthrough - case upgradetest.Cortina: - c.UpgradeConfig.CortinaTime = time.Time{} // neglecting fork ordering for this package's tests - fallthrough - case upgradetest.Banff: - c.UpgradeConfig.BanffTime = time.Time{} // neglecting fork ordering for this package's tests - fallthrough - case upgradetest.ApricotPhase5: - c.UpgradeConfig.ApricotPhase5Time = defaultValidateEndTime - fallthrough - case upgradetest.ApricotPhase3: - c.UpgradeConfig.ApricotPhase3Time = defaultValidateEndTime - default: - require.FailNow(t, "unhandled fork", f) - } - - return c } func defaultClock() *mockable.Clock { diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index 4a1ceccce48f..d55461fc2b14 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -27,7 +27,6 @@ import ( "github.com/ava-labs/avalanchego/snow/snowtest" "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" @@ -131,7 +130,7 @@ type environment struct { func newEnvironment(t *testing.T, ctrl *gomock.Controller, f upgradetest.Fork) *environment { res := &environment{ isBootstrapped: &utils.Atomic[bool]{}, - config: defaultConfig(t, f), + config: defaultConfig(f), clk: defaultClock(), } res.isBootstrapped.Set(true) @@ -324,8 +323,16 @@ func defaultState( return state } -func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { - c := &config.Config{ +func defaultConfig(f upgradetest.Fork) *config.Config { + upgrades := upgradetest.GetConfigWithUpgradeTime(f, time.Time{}) + // This package neglects fork ordering + upgradetest.SetConfigTimesTo( + &upgrades, + min(f, upgradetest.ApricotPhase5), + defaultValidateEndTime, + ) + + return &config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), Validators: validators.NewManager(), @@ -345,39 +352,8 @@ func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { MintingPeriod: 365 * 24 * time.Hour, SupplyCap: 720 * units.MegaAvax, }, - UpgradeConfig: upgrade.Config{ - ApricotPhase3Time: mockable.MaxTime, - ApricotPhase5Time: mockable.MaxTime, - BanffTime: mockable.MaxTime, - CortinaTime: mockable.MaxTime, - DurangoTime: mockable.MaxTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgrades, } - - switch f { - case upgradetest.Etna: - c.UpgradeConfig.EtnaTime = time.Time{} // neglecting fork ordering this for package tests - fallthrough - case upgradetest.Durango: - c.UpgradeConfig.DurangoTime = time.Time{} // neglecting fork ordering for this package's tests - fallthrough - case upgradetest.Cortina: - c.UpgradeConfig.CortinaTime = time.Time{} // neglecting fork ordering for this package's tests - fallthrough - case upgradetest.Banff: - c.UpgradeConfig.BanffTime = time.Time{} // neglecting fork ordering for this package's tests - fallthrough - case upgradetest.ApricotPhase5: - c.UpgradeConfig.ApricotPhase5Time = defaultValidateEndTime - fallthrough - case upgradetest.ApricotPhase3: - c.UpgradeConfig.ApricotPhase3Time = defaultValidateEndTime - default: - require.FailNow(t, "unhandled fork", f) - } - - return c } func defaultClock() *mockable.Clock { diff --git a/vms/platformvm/txs/executor/helpers_test.go b/vms/platformvm/txs/executor/helpers_test.go index 030ec40697cd..4e57a1e78f71 100644 --- a/vms/platformvm/txs/executor/helpers_test.go +++ b/vms/platformvm/txs/executor/helpers_test.go @@ -25,7 +25,6 @@ import ( "github.com/ava-labs/avalanchego/snow/snowtest" "github.com/ava-labs/avalanchego/snow/uptime" "github.com/ava-labs/avalanchego/snow/validators" - "github.com/ava-labs/avalanchego/upgrade" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" @@ -120,7 +119,7 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { var isBootstrapped utils.Atomic[bool] isBootstrapped.Set(true) - config := defaultConfig(t, f) + config := defaultConfig(f) clk := defaultClock(f) baseDB := versiondb.New(memdb.New()) @@ -267,8 +266,18 @@ func defaultState( return state } -func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { - c := &config.Config{ +func defaultConfig(f upgradetest.Fork) *config.Config { + upgrades := upgradetest.GetConfigWithUpgradeTime( + f, + defaultValidateStartTime.Add(-2*time.Second), + ) + upgradetest.SetConfigTimesTo( + &upgrades, + min(f, upgradetest.ApricotPhase5), + defaultValidateEndTime, + ) + + return &config.Config{ Chains: chains.TestManager, UptimeLockedCalculator: uptime.NewLockedCalculator(), Validators: validators.NewManager(), @@ -288,39 +297,8 @@ func defaultConfig(t *testing.T, f upgradetest.Fork) *config.Config { MintingPeriod: 365 * 24 * time.Hour, SupplyCap: 720 * units.MegaAvax, }, - UpgradeConfig: upgrade.Config{ - ApricotPhase3Time: mockable.MaxTime, - ApricotPhase5Time: mockable.MaxTime, - BanffTime: mockable.MaxTime, - CortinaTime: mockable.MaxTime, - DurangoTime: mockable.MaxTime, - EtnaTime: mockable.MaxTime, - }, + UpgradeConfig: upgrades, } - - switch f { - case upgradetest.Etna: - c.UpgradeConfig.EtnaTime = defaultValidateStartTime.Add(-2 * time.Second) - fallthrough - case upgradetest.Durango: - c.UpgradeConfig.DurangoTime = defaultValidateStartTime.Add(-2 * time.Second) - fallthrough - case upgradetest.Cortina: - c.UpgradeConfig.CortinaTime = defaultValidateStartTime.Add(-2 * time.Second) - fallthrough - case upgradetest.Banff: - c.UpgradeConfig.BanffTime = defaultValidateStartTime.Add(-2 * time.Second) - fallthrough - case upgradetest.ApricotPhase5: - c.UpgradeConfig.ApricotPhase5Time = defaultValidateEndTime - fallthrough - case upgradetest.ApricotPhase3: - c.UpgradeConfig.ApricotPhase3Time = defaultValidateEndTime - default: - require.FailNow(t, "unhandled fork", f) - } - - return c } func defaultClock(f upgradetest.Fork) *mockable.Clock { diff --git a/vms/proposervm/vm_test.go b/vms/proposervm/vm_test.go index 8d1356f859b8..a66df4012072 100644 --- a/vms/proposervm/vm_test.go +++ b/vms/proposervm/vm_test.go @@ -809,11 +809,7 @@ func TestExpiredBuildBlock(t *testing.T) { proVM := New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Time{}, - ApricotPhase4MinPChainHeight: 0, - DurangoTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.ApricotPhase4, time.Time{}), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -1129,11 +1125,7 @@ func TestInnerVMRollback(t *testing.T) { proVM := New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Time{}, - ApricotPhase4MinPChainHeight: 0, - DurangoTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.ApricotPhase4, time.Time{}), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -1211,11 +1203,7 @@ func TestInnerVMRollback(t *testing.T) { proVM = New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Time{}, - ApricotPhase4MinPChainHeight: 0, - DurangoTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.ApricotPhase4, time.Time{}), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -1601,11 +1589,7 @@ func TestRejectedHeightNotIndexed(t *testing.T) { proVM := New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.Latest, time.Unix(0, 0)), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -1774,11 +1758,7 @@ func TestRejectedOptionHeightNotIndexed(t *testing.T) { proVM := New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: time.Unix(0, 0), - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.Latest, time.Unix(0, 0)), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -2219,11 +2199,7 @@ func TestHistoricalBlockDeletion(t *testing.T) { proVM := New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Unix(0, 0), - ApricotPhase4MinPChainHeight: 0, - DurangoTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.ApricotPhase4, time.Unix(0, 0)), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: DefaultNumHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -2313,11 +2289,7 @@ func TestHistoricalBlockDeletion(t *testing.T) { proVM = New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Time{}, - ApricotPhase4MinPChainHeight: 0, - DurangoTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.ApricotPhase4, time.Time{}), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: numHistoricalBlocks, StakingLeafSigner: pTestSigner, @@ -2360,11 +2332,7 @@ func TestHistoricalBlockDeletion(t *testing.T) { proVM = New( coreVM, Config{ - Upgrades: upgrade.Config{ - ApricotPhase4Time: time.Time{}, - ApricotPhase4MinPChainHeight: 0, - DurangoTime: mockable.MaxTime, - }, + Upgrades: upgradetest.GetConfigWithUpgradeTime(upgradetest.ApricotPhase4, time.Time{}), MinBlkDelay: DefaultMinBlockDelay, NumHistoricalBlocks: newNumHistoricalBlocks, StakingLeafSigner: pTestSigner, From f685c702705af089e00c928340cd2458f219561f Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 22:33:47 -0400 Subject: [PATCH 026/114] comments --- upgrade/upgradetest/config.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/upgrade/upgradetest/config.go b/upgrade/upgradetest/config.go index 9b2b26d1bfab..c75c47137964 100644 --- a/upgrade/upgradetest/config.go +++ b/upgrade/upgradetest/config.go @@ -10,20 +10,28 @@ import ( "github.com/ava-labs/avalanchego/upgrade" ) +// GetConfig returns an upgrade config with the provided fork scheduled to have +// been initially activated and all other forks to be unscheduled. func GetConfig(fork Fork) upgrade.Config { return GetConfigWithUpgradeTime(fork, upgrade.InitiallyActiveTime) } +// GetConfig returns an upgrade config with the provided fork scheduled to be +// activated at the provided upgradeTime and all other forks to be unscheduled. func GetConfigWithUpgradeTime(fork Fork, upgradeTime time.Time) upgrade.Config { c := upgrade.Config{ ApricotPhase4MinPChainHeight: 0, CortinaXChainStopVertexID: ids.Empty, } + // Initialize all forks to be unscheduled SetConfigTimesTo(&c, Latest, upgrade.UnscheduledActivationTime) + // Schedule the requested forks at the provided upgrade time SetConfigTimesTo(&c, fork, upgradeTime) return c } +// SetConfigTimesTo sets the upgrade time of the provided fork, and all prior +// forks, to the provided upgradeTime. func SetConfigTimesTo(c *upgrade.Config, fork Fork, upgradeTime time.Time) { switch fork { case Etna: From 94435880a8f44791c44409c75ca7c4cab94f8bc6 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 22:34:50 -0400 Subject: [PATCH 027/114] add comment --- upgrade/upgradetest/fork.go | 1 + 1 file changed, 1 insertion(+) diff --git a/upgrade/upgradetest/fork.go b/upgrade/upgradetest/fork.go index 12f7f9899550..01c9b2ea03ee 100644 --- a/upgrade/upgradetest/fork.go +++ b/upgrade/upgradetest/fork.go @@ -21,4 +21,5 @@ const ( Latest = Etna ) +// Fork is an enum of all the major network upgrades. type Fork int From 80a7f2f1a22d11d91ddddd37d9eebe0cb05914d1 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 22:57:24 -0400 Subject: [PATCH 028/114] nit --- upgrade/upgradetest/config.go | 10 +++++----- vms/platformvm/block/builder/helpers_test.go | 2 +- vms/platformvm/block/executor/helpers_test.go | 2 +- vms/platformvm/txs/executor/helpers_test.go | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/upgrade/upgradetest/config.go b/upgrade/upgradetest/config.go index c75c47137964..b50564e601a2 100644 --- a/upgrade/upgradetest/config.go +++ b/upgrade/upgradetest/config.go @@ -24,15 +24,15 @@ func GetConfigWithUpgradeTime(fork Fork, upgradeTime time.Time) upgrade.Config { CortinaXChainStopVertexID: ids.Empty, } // Initialize all forks to be unscheduled - SetConfigTimesTo(&c, Latest, upgrade.UnscheduledActivationTime) + SetTimesTo(&c, Latest, upgrade.UnscheduledActivationTime) // Schedule the requested forks at the provided upgrade time - SetConfigTimesTo(&c, fork, upgradeTime) + SetTimesTo(&c, fork, upgradeTime) return c } -// SetConfigTimesTo sets the upgrade time of the provided fork, and all prior -// forks, to the provided upgradeTime. -func SetConfigTimesTo(c *upgrade.Config, fork Fork, upgradeTime time.Time) { +// SetTimesTo sets the upgrade time of the provided fork, and all prior forks, +// to the provided upgradeTime. +func SetTimesTo(c *upgrade.Config, fork Fork, upgradeTime time.Time) { switch fork { case Etna: c.EtnaTime = upgradeTime diff --git a/vms/platformvm/block/builder/helpers_test.go b/vms/platformvm/block/builder/helpers_test.go index 0b5ef4149dcd..0ed61f930d01 100644 --- a/vms/platformvm/block/builder/helpers_test.go +++ b/vms/platformvm/block/builder/helpers_test.go @@ -295,7 +295,7 @@ func defaultState( func defaultConfig(f upgradetest.Fork) *config.Config { upgrades := upgradetest.GetConfigWithUpgradeTime(f, time.Time{}) // This package neglects fork ordering - upgradetest.SetConfigTimesTo( + upgradetest.SetTimesTo( &upgrades, min(f, upgradetest.ApricotPhase5), defaultValidateEndTime, diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index d55461fc2b14..22305de07ac7 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -326,7 +326,7 @@ func defaultState( func defaultConfig(f upgradetest.Fork) *config.Config { upgrades := upgradetest.GetConfigWithUpgradeTime(f, time.Time{}) // This package neglects fork ordering - upgradetest.SetConfigTimesTo( + upgradetest.SetTimesTo( &upgrades, min(f, upgradetest.ApricotPhase5), defaultValidateEndTime, diff --git a/vms/platformvm/txs/executor/helpers_test.go b/vms/platformvm/txs/executor/helpers_test.go index 4e57a1e78f71..2342f2270d43 100644 --- a/vms/platformvm/txs/executor/helpers_test.go +++ b/vms/platformvm/txs/executor/helpers_test.go @@ -271,7 +271,7 @@ func defaultConfig(f upgradetest.Fork) *config.Config { f, defaultValidateStartTime.Add(-2*time.Second), ) - upgradetest.SetConfigTimesTo( + upgradetest.SetTimesTo( &upgrades, min(f, upgradetest.ApricotPhase5), defaultValidateEndTime, From 39d48f612fb894f5ea226c65fb118b3e88215215 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 15 Aug 2024 22:58:09 -0400 Subject: [PATCH 029/114] fix comment --- upgrade/upgradetest/config.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/upgrade/upgradetest/config.go b/upgrade/upgradetest/config.go index b50564e601a2..92e093f212af 100644 --- a/upgrade/upgradetest/config.go +++ b/upgrade/upgradetest/config.go @@ -16,8 +16,9 @@ func GetConfig(fork Fork) upgrade.Config { return GetConfigWithUpgradeTime(fork, upgrade.InitiallyActiveTime) } -// GetConfig returns an upgrade config with the provided fork scheduled to be -// activated at the provided upgradeTime and all other forks to be unscheduled. +// GetConfigWithUpgradeTime returns an upgrade config with the provided fork +// scheduled to be activated at the provided upgradeTime and all other forks to +// be unscheduled. func GetConfigWithUpgradeTime(fork Fork, upgradeTime time.Time) upgrade.Config { c := upgrade.Config{ ApricotPhase4MinPChainHeight: 0, From f91f3be40e5c264c26f8a2ccd89fc41f77061e91 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 16 Aug 2024 11:15:59 -0400 Subject: [PATCH 030/114] wip --- upgrade/upgradetest/fork.go | 40 +++++++++++ .../state/chain_time_helpers_test.go | 66 +++++++++++++++++++ 2 files changed, 106 insertions(+) create mode 100644 vms/platformvm/state/chain_time_helpers_test.go diff --git a/upgrade/upgradetest/fork.go b/upgrade/upgradetest/fork.go index 01c9b2ea03ee..47f230736109 100644 --- a/upgrade/upgradetest/fork.go +++ b/upgrade/upgradetest/fork.go @@ -23,3 +23,43 @@ const ( // Fork is an enum of all the major network upgrades. type Fork int + +func (f Fork) String() string { + switch fork { + case Etna: + c.EtnaTime = upgradeTime + fallthrough + case Durango: + c.DurangoTime = upgradeTime + fallthrough + case Cortina: + c.CortinaTime = upgradeTime + fallthrough + case Banff: + c.BanffTime = upgradeTime + fallthrough + case ApricotPhasePost6: + c.ApricotPhasePost6Time = upgradeTime + fallthrough + case ApricotPhase6: + c.ApricotPhase6Time = upgradeTime + fallthrough + case ApricotPhasePre6: + c.ApricotPhasePre6Time = upgradeTime + fallthrough + case ApricotPhase5: + c.ApricotPhase5Time = upgradeTime + fallthrough + case ApricotPhase4: + c.ApricotPhase4Time = upgradeTime + fallthrough + case ApricotPhase3: + c.ApricotPhase3Time = upgradeTime + fallthrough + case ApricotPhase2: + c.ApricotPhase2Time = upgradeTime + fallthrough + case ApricotPhase1: + c.ApricotPhase1Time = upgradeTime + } +} diff --git a/vms/platformvm/state/chain_time_helpers_test.go b/vms/platformvm/state/chain_time_helpers_test.go new file mode 100644 index 000000000000..2a51b320a5ff --- /dev/null +++ b/vms/platformvm/state/chain_time_helpers_test.go @@ -0,0 +1,66 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package state + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/upgrade/upgradetest" + "github.com/ava-labs/avalanchego/vms/platformvm/config" + + feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" +) + +func TestPickFeeCalculator(t *testing.T) { + var ( + createAssetTxFee uint64 = 0 + dynamicFeeConfig = feecomponent.Config{} + staticFeeConfig = txfee.StaticConfig{} + ) + + apricotPhase2StaticFeeConfig := staticFeeConfig + apricotPhase2StaticFeeConfig.CreateSubnetTxFee = createAssetTxFee + apricotPhase2StaticFeeConfig.CreateBlockchainTxFee = createAssetTxFee + + tests := []struct { + name string + fork upgradetest.Fork + expected txfee.Calculator + }{ + { + name: "apricot phase 2", + fork: upgradetest.ApricotPhase2, + expected: txfee.NewStaticCalculator(apricotPhase2StaticFeeConfig), + }, + { + name: "apricot phase 3", + fork: upgradetest.ApricotPhase3, + expected: txfee.NewStaticCalculator(staticFeeConfig), + }, + // { + // name: "etna", + // fork: upgradetest.Etna, + // }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require := require.New(t) + + var ( + config = &config.Config{ + CreateAssetTxFee: createAssetTxFee, + StaticFeeConfig: staticFeeConfig, + DynamicFeeConfig: dynamicFeeConfig, + UpgradeConfig: upgradetest.GetConfig(test.fork), + } + s = newInitializedState(require) + ) + actual := PickFeeCalculator(config, s) + require.Equal(test.expected, actual) + }) + } +} From f0b74592ca3af5d0bb666c134f8287285689bccd Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 09:49:10 -0400 Subject: [PATCH 031/114] functions over methods --- vms/platformvm/state/state.go | 23 ++++++++++----------- vms/platformvm/state/state_test.go | 33 ++++++++++++++---------------- 2 files changed, 26 insertions(+), 30 deletions(-) diff --git a/vms/platformvm/state/state.go b/vms/platformvm/state/state.go index da2564f55cc2..f7224cd61610 100644 --- a/vms/platformvm/state/state.go +++ b/vms/platformvm/state/state.go @@ -753,15 +753,6 @@ func (s *state) GetPendingStakerIterator() (StakerIterator, error) { return s.pendingStakers.GetStakerIterator(), nil } -func (s *state) shouldInit() (bool, error) { - has, err := s.singletonDB.Has(InitializedKey) - return !has, err -} - -func (s *state) doneInit() error { - return s.singletonDB.Put(InitializedKey, nil) -} - func (s *state) GetSubnetIDs() ([]ids.ID, error) { if s.cachedSubnetIDs != nil { return s.cachedSubnetIDs, nil @@ -1751,7 +1742,7 @@ func (s *state) Close() error { } func (s *state) sync(genesis []byte) error { - shouldInit, err := s.shouldInit() + isInitialized, err := isInitialized(s.singletonDB) if err != nil { return fmt.Errorf( "failed to check if the database is initialized: %w", @@ -1761,7 +1752,7 @@ func (s *state) sync(genesis []byte) error { // If the database is empty, create the platform chain anew using the // provided genesis state - if shouldInit { + if !isInitialized { if err := s.init(genesis); err != nil { return fmt.Errorf( "failed to initialize the database: %w", @@ -1797,7 +1788,7 @@ func (s *state) init(genesisBytes []byte) error { return err } - if err := s.doneInit(); err != nil { + if err := markInitialized(s.singletonDB); err != nil { return err } @@ -2548,6 +2539,14 @@ func (s *state) ReindexBlocks(lock sync.Locker, log logging.Logger) error { return s.Commit() } +func markInitialized(db database.KeyValueWriter) error { + return db.Put(InitializedKey, nil) +} + +func isInitialized(db database.KeyValueReader) (bool, error) { + return db.Has(InitializedKey) +} + func putFeeState(db database.KeyValueWriter, feeState fee.State) error { feeStateBytes, err := block.GenesisCodec.Marshal(block.CodecVersion, feeState) if err != nil { diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go index 52c6ac978929..f6c311a66813 100644 --- a/vms/platformvm/state/state_test.go +++ b/vms/platformvm/state/state_test.go @@ -52,24 +52,6 @@ var ( initialValidatorEndTime = initialTime.Add(28 * 24 * time.Hour) ) -func TestStateInitialization(t *testing.T) { - require := require.New(t) - s, db := newUninitializedState(require) - - shouldInit, err := s.shouldInit() - require.NoError(err) - require.True(shouldInit) - - require.NoError(s.doneInit()) - require.NoError(s.Commit()) - - s = newStateFromDB(require, db) - - shouldInit, err = s.shouldInit() - require.NoError(err) - require.False(shouldInit) -} - func TestStateSyncGenesis(t *testing.T) { require := require.New(t) state := newInitializedState(require) @@ -1564,6 +1546,21 @@ func TestStateFeeStateCommitAndLoad(t *testing.T) { require.Equal(expectedFeeState, s.GetFeeState()) } +func TestMarkAndIsInitialized(t *testing.T) { + require := require.New(t) + + db := memdb.New() + defaultIsInitialized, err := isInitialized(db) + require.NoError(err) + require.False(defaultIsInitialized) + + require.NoError(markInitialized(db)) + + isInitializedAfterMarking, err := isInitialized(db) + require.NoError(err) + require.True(isInitializedAfterMarking) +} + // Verify that reading from the database returns the same value that was written // to it. func TestPutAndGetFeeState(t *testing.T) { From 05fccff6be4450399c2c06fb4ee78f1410d74c34 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 10:18:03 -0400 Subject: [PATCH 032/114] Refactor --- vms/platformvm/genesis/genesistest/genesis.go | 107 +++++++++++++++ vms/platformvm/state/diff_test.go | 19 +-- vms/platformvm/state/stakers_test.go | 3 +- vms/platformvm/state/state_test.go | 124 ++++-------------- 4 files changed, 148 insertions(+), 105 deletions(-) create mode 100644 vms/platformvm/genesis/genesistest/genesis.go diff --git a/vms/platformvm/genesis/genesistest/genesis.go b/vms/platformvm/genesis/genesistest/genesis.go new file mode 100644 index 000000000000..24e16ecf0934 --- /dev/null +++ b/vms/platformvm/genesis/genesistest/genesis.go @@ -0,0 +1,107 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package genesistest + +import ( + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/utils/constants" + "github.com/ava-labs/avalanchego/utils/units" + "github.com/ava-labs/avalanchego/vms/components/avax" + "github.com/ava-labs/avalanchego/vms/platformvm/genesis" + "github.com/ava-labs/avalanchego/vms/platformvm/reward" + "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/vms/secp256k1fx" +) + +var ( + AVAXAssetID = ids.GenerateTestID() + AVAXAsset = avax.Asset{ID: AVAXAssetID} + + ValidatorNodeID = ids.GenerateTestNodeID() + Time = time.Now().Round(time.Second) + TimeUnix = uint64(Time.Unix()) + ValidatorDuration = 28 * 24 * time.Hour + ValidatorEndTime = Time.Add(ValidatorDuration) + ValidatorEndTimeUnix = uint64(ValidatorEndTime.Unix()) + ValidatorWeight = units.Avax + ValidatorRewardsOwner = &secp256k1fx.OutputOwners{} + ValidatorDelegationShares uint32 = reward.PercentDenominator + + XChainName = "x" + + InitialBalance = units.Schmeckle + InitialSupply = ValidatorWeight + InitialBalance +) + +func New(t testing.TB) *genesis.Genesis { + require := require.New(t) + + genesisValidator := &txs.AddValidatorTx{ + Validator: txs.Validator{ + NodeID: ValidatorNodeID, + Start: TimeUnix, + End: ValidatorEndTimeUnix, + Wght: ValidatorWeight, + }, + StakeOuts: []*avax.TransferableOutput{ + { + Asset: AVAXAsset, + Out: &secp256k1fx.TransferOutput{ + Amt: ValidatorWeight, + }, + }, + }, + RewardsOwner: ValidatorRewardsOwner, + DelegationShares: ValidatorDelegationShares, + } + genesisValidatorTx := &txs.Tx{Unsigned: genesisValidator} + require.NoError(genesisValidatorTx.Initialize(txs.Codec)) + + genesisChain := &txs.CreateChainTx{ + SubnetID: constants.PrimaryNetworkID, + ChainName: XChainName, + VMID: constants.AVMID, + SubnetAuth: &secp256k1fx.Input{}, + } + genesisChainTx := &txs.Tx{Unsigned: genesisChain} + require.NoError(genesisChainTx.Initialize(txs.Codec)) + + return &genesis.Genesis{ + UTXOs: []*genesis.UTXO{ + { + UTXO: avax.UTXO{ + UTXOID: avax.UTXOID{ + TxID: AVAXAssetID, + OutputIndex: 0, + }, + Asset: AVAXAsset, + Out: &secp256k1fx.TransferOutput{ + Amt: InitialBalance, + }, + }, + Message: nil, + }, + }, + Validators: []*txs.Tx{ + genesisValidatorTx, + }, + Chains: []*txs.Tx{ + genesisChainTx, + }, + Timestamp: TimeUnix, + InitialSupply: InitialSupply, + } +} + +func NewBytes(t testing.TB) []byte { + g := New(t) + genesisBytes, err := genesis.Codec.Marshal(genesis.CodecVersion, g) + require.NoError(t, err) + return genesisBytes +} diff --git a/vms/platformvm/state/diff_test.go b/vms/platformvm/state/diff_test.go index 48f0d567b116..a1de83c32efc 100644 --- a/vms/platformvm/state/diff_test.go +++ b/vms/platformvm/state/diff_test.go @@ -11,6 +11,7 @@ import ( "go.uber.org/mock/gomock" "github.com/ava-labs/avalanchego/database" + "github.com/ava-labs/avalanchego/database/memdb" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" @@ -36,7 +37,7 @@ func TestDiffMissingState(t *testing.T) { func TestNewDiffOn(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) d, err := NewDiffOn(state) require.NoError(err) @@ -47,7 +48,7 @@ func TestNewDiffOn(t *testing.T) { func TestDiffFeeState(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) d, err := NewDiffOn(state) require.NoError(err) @@ -68,7 +69,7 @@ func TestDiffFeeState(t *testing.T) { func TestDiffCurrentSupply(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) d, err := NewDiffOn(state) require.NoError(err) @@ -256,7 +257,7 @@ func TestDiffSubnet(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) // Initialize parent with one subnet parentStateCreateSubnetTx := &txs.Tx{ @@ -305,7 +306,7 @@ func TestDiffSubnet(t *testing.T) { func TestDiffChain(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) subnetID := ids.GenerateTestID() // Initialize parent with one chain @@ -402,7 +403,7 @@ func TestDiffTx(t *testing.T) { func TestDiffRewardUTXO(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) // Initialize parent with one reward UTXO var ( @@ -531,7 +532,7 @@ func TestDiffSubnetOwner(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) var ( owner1 = fx.NewMockOwner(ctrl) @@ -589,7 +590,7 @@ func TestDiffSubnetManager(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) states := NewMockVersions(ctrl) lastAcceptedID := ids.GenerateTestID() @@ -638,7 +639,7 @@ func TestDiffStacking(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) var ( owner1 = fx.NewMockOwner(ctrl) diff --git a/vms/platformvm/state/stakers_test.go b/vms/platformvm/state/stakers_test.go index 5c6d9a8b28f8..d01593c0548e 100644 --- a/vms/platformvm/state/stakers_test.go +++ b/vms/platformvm/state/stakers_test.go @@ -11,6 +11,7 @@ import ( "github.com/ava-labs/avalanchego/database" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/txs" ) @@ -219,7 +220,7 @@ func TestDiffStakersDelegator(t *testing.T) { func newTestStaker() *Staker { startTime := time.Now().Round(time.Second) - endTime := startTime.Add(28 * 24 * time.Hour) + endTime := startTime.Add(genesistest.ValidatorDuration) return &Staker{ TxID: ids.GenerateTestID(), NodeID: ids.GenerateTestNodeID(), diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go index f6c311a66813..82f0c5902ffd 100644 --- a/vms/platformvm/state/state_test.go +++ b/vms/platformvm/state/state_test.go @@ -33,7 +33,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/block" "github.com/ava-labs/avalanchego/vms/platformvm/config" "github.com/ava-labs/avalanchego/vms/platformvm/fx" - "github.com/ava-labs/avalanchego/vms/platformvm/genesis" + "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/metrics" "github.com/ava-labs/avalanchego/vms/platformvm/reward" "github.com/ava-labs/avalanchego/vms/platformvm/signer" @@ -45,23 +45,16 @@ import ( safemath "github.com/ava-labs/avalanchego/utils/math" ) -var ( - initialTxID = ids.GenerateTestID() - initialNodeID = ids.GenerateTestNodeID() - initialTime = time.Now().Round(time.Second) - initialValidatorEndTime = initialTime.Add(28 * 24 * time.Hour) -) - func TestStateSyncGenesis(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) - staker, err := state.GetCurrentValidator(constants.PrimaryNetworkID, initialNodeID) + staker, err := state.GetCurrentValidator(constants.PrimaryNetworkID, genesistest.ValidatorNodeID) require.NoError(err) require.NotNil(staker) - require.Equal(initialNodeID, staker.NodeID) + require.Equal(genesistest.ValidatorNodeID, staker.NodeID) - delegatorIterator, err := state.GetCurrentDelegatorIterator(constants.PrimaryNetworkID, initialNodeID) + delegatorIterator, err := state.GetCurrentDelegatorIterator(constants.PrimaryNetworkID, genesistest.ValidatorNodeID) require.NoError(err) assertIteratorsEqual(t, EmptyIterator, delegatorIterator) @@ -69,10 +62,10 @@ func TestStateSyncGenesis(t *testing.T) { require.NoError(err) assertIteratorsEqual(t, NewSliceIterator(staker), stakerIterator) - _, err = state.GetPendingValidator(constants.PrimaryNetworkID, initialNodeID) + _, err = state.GetPendingValidator(constants.PrimaryNetworkID, genesistest.ValidatorNodeID) require.ErrorIs(err, database.ErrNotFound) - delegatorIterator, err = state.GetPendingDelegatorIterator(constants.PrimaryNetworkID, initialNodeID) + delegatorIterator, err = state.GetPendingDelegatorIterator(constants.PrimaryNetworkID, genesistest.ValidatorNodeID) require.NoError(err) assertIteratorsEqual(t, EmptyIterator, delegatorIterator) } @@ -657,7 +650,8 @@ func TestPersistStakers(t *testing.T) { t.Run(fmt.Sprintf("%s - subnetID %s", name, subnetID), func(t *testing.T) { require := require.New(t) - state, db := newUninitializedState(require) + db := memdb.New() + state := newStateFromDB(t, db) // create and store the staker staker := test.storeStaker(require, subnetID, state) @@ -669,7 +663,7 @@ func TestPersistStakers(t *testing.T) { test.checkDiffs(require, state, staker, 0 /*height*/) // rebuild the state - rebuiltState := newStateFromDB(require, db) + rebuiltState := newStateFromDB(t, db) // load relevant quantities require.NoError(rebuiltState.loadCurrentValidators()) @@ -686,89 +680,29 @@ func TestPersistStakers(t *testing.T) { } } -func newInitializedState(require *require.Assertions) State { - s, _ := newUninitializedState(require) - initializeState(require, s) +func newInitializedStateFromDB(t testing.TB, db database.Database) *state { + s := newStateFromDB(t, db) + initializeState(t, s) return s } -func newUninitializedState(require *require.Assertions) (*state, database.Database) { - db := memdb.New() - return newStateFromDB(require, db), db -} - -func initializeState(require *require.Assertions, s *state) { - initialValidator := &txs.AddValidatorTx{ - Validator: txs.Validator{ - NodeID: initialNodeID, - Start: uint64(initialTime.Unix()), - End: uint64(initialValidatorEndTime.Unix()), - Wght: units.Avax, - }, - StakeOuts: []*avax.TransferableOutput{ - { - Asset: avax.Asset{ID: initialTxID}, - Out: &secp256k1fx.TransferOutput{ - Amt: units.Avax, - }, - }, - }, - RewardsOwner: &secp256k1fx.OutputOwners{}, - DelegationShares: reward.PercentDenominator, - } - initialValidatorTx := &txs.Tx{Unsigned: initialValidator} - require.NoError(initialValidatorTx.Initialize(txs.Codec)) - - initialChain := &txs.CreateChainTx{ - SubnetID: constants.PrimaryNetworkID, - ChainName: "x", - VMID: constants.AVMID, - SubnetAuth: &secp256k1fx.Input{}, - } - initialChainTx := &txs.Tx{Unsigned: initialChain} - require.NoError(initialChainTx.Initialize(txs.Codec)) - +func initializeState(t testing.TB, s *state) { genesisBlkID := ids.GenerateTestID() - genesisState := &genesis.Genesis{ - UTXOs: []*genesis.UTXO{ - { - UTXO: avax.UTXO{ - UTXOID: avax.UTXOID{ - TxID: initialTxID, - OutputIndex: 0, - }, - Asset: avax.Asset{ID: initialTxID}, - Out: &secp256k1fx.TransferOutput{ - Amt: units.Schmeckle, - }, - }, - Message: nil, - }, - }, - Validators: []*txs.Tx{ - initialValidatorTx, - }, - Chains: []*txs.Tx{ - initialChainTx, - }, - Timestamp: uint64(initialTime.Unix()), - InitialSupply: units.Schmeckle + units.Avax, - } - genesisBlk, err := block.NewApricotCommitBlock(genesisBlkID, 0) - require.NoError(err) - require.NoError(s.syncGenesis(genesisBlk, genesisState)) + require.NoError(t, err) + + genesis := genesistest.New(t) + require.NoError(t, s.syncGenesis(genesisBlk, genesis)) } -func newStateFromDB(require *require.Assertions, db database.Database) *state { - execCfg, _ := config.GetExecutionConfig(nil) +func newStateFromDB(t testing.TB, db database.Database) *state { state, err := newState( db, metrics.Noop, &config.Config{ Validators: validators.NewManager(), }, - execCfg, + &config.DefaultExecutionConfig, &snow.Context{}, prometheus.NewRegistry(), reward.NewCalculator(reward.Config{ @@ -778,8 +712,8 @@ func newStateFromDB(require *require.Assertions, db database.Database) *state { SupplyCap: 720 * units.MegaAvax, }), ) - require.NoError(err) - require.NotNil(state) + require.NoError(t, err) + require.NotNil(t, state) return state } @@ -1058,7 +992,7 @@ func TestValidatorWeightDiff(t *testing.T) { func TestStateAddRemoveValidator(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) var ( numNodes = 3 @@ -1313,7 +1247,7 @@ func TestParsedStateBlock(t *testing.T) { func TestReindexBlocks(t *testing.T) { var ( require = require.New(t) - s = newInitializedState(require).(*state) + s = newInitializedStateFromDB(t, memdb.New()) blks = makeBlocks(require) ) @@ -1354,7 +1288,7 @@ func TestReindexBlocks(t *testing.T) { func TestStateSubnetOwner(t *testing.T) { require := require.New(t) - state := newInitializedState(require) + state := newInitializedStateFromDB(t, memdb.New()) ctrl := gomock.NewController(t) var ( @@ -1417,7 +1351,7 @@ func TestStateSubnetManager(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - initializedState := newInitializedState(require) + initializedState := newInitializedStateFromDB(t, memdb.New()) subnetID := ids.GenerateTestID() chainID, addr, err := initializedState.GetSubnetManager(subnetID) @@ -1531,8 +1465,8 @@ func makeBlocks(require *require.Assertions) []block.Block { func TestStateFeeStateCommitAndLoad(t *testing.T) { require := require.New(t) - s, db := newUninitializedState(require) - initializeState(require, s) + db := memdb.New() + s := newInitializedStateFromDB(t, db) expectedFeeState := fee.State{ Capacity: 1, @@ -1541,7 +1475,7 @@ func TestStateFeeStateCommitAndLoad(t *testing.T) { s.SetFeeState(expectedFeeState) require.NoError(s.Commit()) - s = newStateFromDB(require, db) + s = newStateFromDB(t, db) require.NoError(s.load()) require.Equal(expectedFeeState, s.GetFeeState()) } From 38ce20bde84419cc7d61712865dfa970a924e57a Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 10:18:44 -0400 Subject: [PATCH 033/114] fix test --- vms/platformvm/state/state_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go index 82f0c5902ffd..4cf8128df20f 100644 --- a/vms/platformvm/state/state_test.go +++ b/vms/platformvm/state/state_test.go @@ -671,10 +671,10 @@ func TestPersistStakers(t *testing.T) { require.NoError(rebuiltState.initValidatorSets()) // check again that all relevant data are still available in rebuilt state - test.checkStakerInState(require, state, staker) - test.checkValidatorsSet(require, state, staker) - test.checkValidatorUptimes(require, state, staker) - test.checkDiffs(require, state, staker, 0 /*height*/) + test.checkStakerInState(require, rebuiltState, staker) + test.checkValidatorsSet(require, rebuiltState, staker) + test.checkValidatorUptimes(require, rebuiltState, staker) + test.checkDiffs(require, rebuiltState, staker, 0 /*height*/) }) } } From caf3b6036c972ad953b1e0cdd6467aa2d34ae24e Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 10:19:53 -0400 Subject: [PATCH 034/114] fix state initialization --- vms/platformvm/state/state_test.go | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go index 4cf8128df20f..cc12a3d0414e 100644 --- a/vms/platformvm/state/state_test.go +++ b/vms/platformvm/state/state_test.go @@ -687,12 +687,8 @@ func newInitializedStateFromDB(t testing.TB, db database.Database) *state { } func initializeState(t testing.TB, s *state) { - genesisBlkID := ids.GenerateTestID() - genesisBlk, err := block.NewApricotCommitBlock(genesisBlkID, 0) - require.NoError(t, err) - - genesis := genesistest.New(t) - require.NoError(t, s.syncGenesis(genesisBlk, genesis)) + genesis := genesistest.NewBytes(t) + require.NoError(t, s.sync(genesis)) } func newStateFromDB(t testing.TB, db database.Database) *state { From f4ef32f4e1fbd63b7aee59dd6e99378181120a8a Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 10:35:14 -0400 Subject: [PATCH 035/114] Only test initialized states --- vms/platformvm/state/diff_test.go | 18 ++--- vms/platformvm/state/state.go | 45 +++-------- vms/platformvm/state/state_test.go | 118 +++++++++++++---------------- 3 files changed, 71 insertions(+), 110 deletions(-) diff --git a/vms/platformvm/state/diff_test.go b/vms/platformvm/state/diff_test.go index a1de83c32efc..d76437f692df 100644 --- a/vms/platformvm/state/diff_test.go +++ b/vms/platformvm/state/diff_test.go @@ -37,7 +37,7 @@ func TestDiffMissingState(t *testing.T) { func TestNewDiffOn(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) d, err := NewDiffOn(state) require.NoError(err) @@ -48,7 +48,7 @@ func TestNewDiffOn(t *testing.T) { func TestDiffFeeState(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) d, err := NewDiffOn(state) require.NoError(err) @@ -69,7 +69,7 @@ func TestDiffFeeState(t *testing.T) { func TestDiffCurrentSupply(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) d, err := NewDiffOn(state) require.NoError(err) @@ -257,7 +257,7 @@ func TestDiffSubnet(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) // Initialize parent with one subnet parentStateCreateSubnetTx := &txs.Tx{ @@ -306,7 +306,7 @@ func TestDiffSubnet(t *testing.T) { func TestDiffChain(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) subnetID := ids.GenerateTestID() // Initialize parent with one chain @@ -403,7 +403,7 @@ func TestDiffTx(t *testing.T) { func TestDiffRewardUTXO(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) // Initialize parent with one reward UTXO var ( @@ -532,7 +532,7 @@ func TestDiffSubnetOwner(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) var ( owner1 = fx.NewMockOwner(ctrl) @@ -590,7 +590,7 @@ func TestDiffSubnetManager(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) states := NewMockVersions(ctrl) lastAcceptedID := ids.GenerateTestID() @@ -639,7 +639,7 @@ func TestDiffStacking(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) var ( owner1 = fx.NewMockOwner(ctrl) diff --git a/vms/platformvm/state/state.go b/vms/platformvm/state/state.go index f7224cd61610..2277c83417ab 100644 --- a/vms/platformvm/state/state.go +++ b/vms/platformvm/state/state.go @@ -458,38 +458,6 @@ func New( metrics metrics.Metrics, rewards reward.Calculator, ) (State, error) { - s, err := newState( - db, - metrics, - cfg, - execCfg, - ctx, - metricsReg, - rewards, - ) - if err != nil { - return nil, err - } - - if err := s.sync(genesisBytes); err != nil { - // Drop any errors on close to return the first error - _ = s.Close() - - return nil, err - } - - return s, nil -} - -func newState( - db database.Database, - metrics metrics.Metrics, - cfg *config.Config, - execCfg *config.ExecutionConfig, - ctx *snow.Context, - metricsReg prometheus.Registerer, - rewards reward.Calculator, -) (*state, error) { blockIDCache, err := metercacher.New[uint64, ids.ID]( "block_id_cache", metricsReg, @@ -614,7 +582,7 @@ func newState( return nil, err } - return &state{ + s := &state{ validatorState: newValidatorState(), validators: cfg.Validators, @@ -694,7 +662,16 @@ func newState( chainDBCache: chainDBCache, singletonDB: prefixdb.New(SingletonPrefix, baseDB), - }, nil + } + + if err := s.sync(genesisBytes); err != nil { + // Drop any errors on close to return the first error + _ = s.Close() + + return nil, err + } + + return s, nil } func (s *state) GetCurrentValidator(subnetID ids.ID, nodeID ids.NodeID) (*Staker, error) { diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go index cc12a3d0414e..49cabdf950e3 100644 --- a/vms/platformvm/state/state_test.go +++ b/vms/platformvm/state/state_test.go @@ -45,9 +45,34 @@ import ( safemath "github.com/ava-labs/avalanchego/utils/math" ) +func newTestState(t testing.TB, db database.Database) *state { + s, err := New( + db, + genesistest.NewBytes(t), + prometheus.NewRegistry(), + &config.Config{ + Validators: validators.NewManager(), + }, + &config.DefaultExecutionConfig, + &snow.Context{ + Log: logging.NoLog{}, + }, + metrics.Noop, + reward.NewCalculator(reward.Config{ + MaxConsumptionRate: .12 * reward.PercentDenominator, + MinConsumptionRate: .1 * reward.PercentDenominator, + MintingPeriod: 365 * 24 * time.Hour, + SupplyCap: 720 * units.MegaAvax, + }), + ) + require.NoError(t, err) + require.IsType(t, (*state)(nil), s) + return s.(*state) +} + func TestStateSyncGenesis(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) staker, err := state.GetCurrentValidator(constants.PrimaryNetworkID, genesistest.ValidatorNodeID) require.NoError(err) @@ -128,14 +153,14 @@ func TestPersistStakers(t *testing.T) { }, checkValidatorsSet: func(r *require.Assertions, s *state, staker *Staker) { valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Len(valsMap, 1) - valOut, found := valsMap[staker.NodeID] - r.True(found) - r.Equal(&validators.GetValidatorOutput{ - NodeID: staker.NodeID, - PublicKey: staker.PublicKey, - Weight: staker.Weight, - }, valOut) + r.Contains(valsMap, staker.NodeID) + r.Equal( + &validators.GetValidatorOutput{ + NodeID: staker.NodeID, + PublicKey: staker.PublicKey, + Weight: staker.Weight, + }, + valsMap[staker.NodeID]) }, checkValidatorUptimes: func(r *require.Assertions, s *state, staker *Staker) { upDuration, lastUpdated, err := s.GetUptime(staker.NodeID, staker.SubnetID) @@ -233,9 +258,8 @@ func TestPersistStakers(t *testing.T) { r.NoError(err) valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Len(valsMap, 1) - valOut, found := valsMap[staker.NodeID] - r.True(found) + r.Contains(valsMap, staker.NodeID) + valOut := valsMap[staker.NodeID] r.Equal(valOut.NodeID, staker.NodeID) r.Equal(valOut.Weight, val.Weight+staker.Weight) }, @@ -289,7 +313,7 @@ func TestPersistStakers(t *testing.T) { checkValidatorsSet: func(r *require.Assertions, s *state, staker *Staker) { // pending validators are not showed in validators set valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Empty(valsMap) + r.NotContains(valsMap, staker.NodeID) }, checkValidatorUptimes: func(r *require.Assertions, s *state, staker *Staker) { // pending validators uptime is not tracked @@ -364,7 +388,7 @@ func TestPersistStakers(t *testing.T) { }, checkValidatorsSet: func(r *require.Assertions, s *state, staker *Staker) { valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Empty(valsMap) + r.NotContains(valsMap, staker.NodeID) }, checkValidatorUptimes: func(*require.Assertions, *state, *Staker) {}, checkDiffs: func(*require.Assertions, *state, *Staker, uint64) {}, @@ -411,7 +435,7 @@ func TestPersistStakers(t *testing.T) { checkValidatorsSet: func(r *require.Assertions, s *state, staker *Staker) { // deleted validators are not showed in the validators set anymore valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Empty(valsMap) + r.NotContains(valsMap, staker.NodeID) }, checkValidatorUptimes: func(r *require.Assertions, s *state, staker *Staker) { // uptimes of delete validators are dropped @@ -508,9 +532,8 @@ func TestPersistStakers(t *testing.T) { r.NoError(err) valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Len(valsMap, 1) - valOut, found := valsMap[staker.NodeID] - r.True(found) + r.Contains(valsMap, staker.NodeID) + valOut := valsMap[staker.NodeID] r.Equal(valOut.NodeID, staker.NodeID) r.Equal(valOut.Weight, val.Weight) }, @@ -566,7 +589,7 @@ func TestPersistStakers(t *testing.T) { }, checkValidatorsSet: func(r *require.Assertions, s *state, staker *Staker) { valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Empty(valsMap) + r.NotContains(valsMap, staker.NodeID) }, checkValidatorUptimes: func(r *require.Assertions, s *state, staker *Staker) { _, _, err := s.GetUptime(staker.NodeID, staker.SubnetID) @@ -637,7 +660,7 @@ func TestPersistStakers(t *testing.T) { }, checkValidatorsSet: func(r *require.Assertions, s *state, staker *Staker) { valsMap := s.cfg.Validators.GetMap(staker.SubnetID) - r.Empty(valsMap) + r.NotContains(valsMap, staker.NodeID) }, checkValidatorUptimes: func(*require.Assertions, *state, *Staker) {}, checkDiffs: func(*require.Assertions, *state, *Staker, uint64) {}, @@ -651,7 +674,7 @@ func TestPersistStakers(t *testing.T) { require := require.New(t) db := memdb.New() - state := newStateFromDB(t, db) + state := newTestState(t, db) // create and store the staker staker := test.storeStaker(require, subnetID, state) @@ -663,12 +686,7 @@ func TestPersistStakers(t *testing.T) { test.checkDiffs(require, state, staker, 0 /*height*/) // rebuild the state - rebuiltState := newStateFromDB(t, db) - - // load relevant quantities - require.NoError(rebuiltState.loadCurrentValidators()) - require.NoError(rebuiltState.loadPendingValidators()) - require.NoError(rebuiltState.initValidatorSets()) + rebuiltState := newTestState(t, db) // check again that all relevant data are still available in rebuilt state test.checkStakerInState(require, rebuiltState, staker) @@ -680,39 +698,6 @@ func TestPersistStakers(t *testing.T) { } } -func newInitializedStateFromDB(t testing.TB, db database.Database) *state { - s := newStateFromDB(t, db) - initializeState(t, s) - return s -} - -func initializeState(t testing.TB, s *state) { - genesis := genesistest.NewBytes(t) - require.NoError(t, s.sync(genesis)) -} - -func newStateFromDB(t testing.TB, db database.Database) *state { - state, err := newState( - db, - metrics.Noop, - &config.Config{ - Validators: validators.NewManager(), - }, - &config.DefaultExecutionConfig, - &snow.Context{}, - prometheus.NewRegistry(), - reward.NewCalculator(reward.Config{ - MaxConsumptionRate: .12 * reward.PercentDenominator, - MinConsumptionRate: .1 * reward.PercentDenominator, - MintingPeriod: 365 * 24 * time.Hour, - SupplyCap: 720 * units.MegaAvax, - }), - ) - require.NoError(t, err) - require.NotNil(t, state) - return state -} - func createPermissionlessValidatorTx(r *require.Assertions, subnetID ids.ID, validatorsData txs.Validator) *txs.AddPermissionlessValidatorTx { var sig signer.Signer = &signer.Empty{} if subnetID == constants.PrimaryNetworkID { @@ -988,7 +973,7 @@ func TestValidatorWeightDiff(t *testing.T) { func TestStateAddRemoveValidator(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) var ( numNodes = 3 @@ -1243,7 +1228,7 @@ func TestParsedStateBlock(t *testing.T) { func TestReindexBlocks(t *testing.T) { var ( require = require.New(t) - s = newInitializedStateFromDB(t, memdb.New()) + s = newTestState(t, memdb.New()) blks = makeBlocks(require) ) @@ -1284,7 +1269,7 @@ func TestReindexBlocks(t *testing.T) { func TestStateSubnetOwner(t *testing.T) { require := require.New(t) - state := newInitializedStateFromDB(t, memdb.New()) + state := newTestState(t, memdb.New()) ctrl := gomock.NewController(t) var ( @@ -1347,7 +1332,7 @@ func TestStateSubnetManager(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - initializedState := newInitializedStateFromDB(t, memdb.New()) + initializedState := newTestState(t, memdb.New()) subnetID := ids.GenerateTestID() chainID, addr, err := initializedState.GetSubnetManager(subnetID) @@ -1462,7 +1447,7 @@ func TestStateFeeStateCommitAndLoad(t *testing.T) { require := require.New(t) db := memdb.New() - s := newInitializedStateFromDB(t, db) + s := newTestState(t, db) expectedFeeState := fee.State{ Capacity: 1, @@ -1471,8 +1456,7 @@ func TestStateFeeStateCommitAndLoad(t *testing.T) { s.SetFeeState(expectedFeeState) require.NoError(s.Commit()) - s = newStateFromDB(t, db) - require.NoError(s.load()) + s = newTestState(t, db) require.Equal(expectedFeeState, s.GetFeeState()) } From 11bcdeff73b37c842c4c8576ad1a683b8c075df6 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 10:40:22 -0400 Subject: [PATCH 036/114] nit --- vms/platformvm/state/state_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go index 49cabdf950e3..21357874e434 100644 --- a/vms/platformvm/state/state_test.go +++ b/vms/platformvm/state/state_test.go @@ -160,7 +160,8 @@ func TestPersistStakers(t *testing.T) { PublicKey: staker.PublicKey, Weight: staker.Weight, }, - valsMap[staker.NodeID]) + valsMap[staker.NodeID], + ) }, checkValidatorUptimes: func(r *require.Assertions, s *state, staker *Staker) { upDuration, lastUpdated, err := s.GetUptime(staker.NodeID, staker.SubnetID) From 6f2010d011d5dbdb44c6c921f50a259c7cfc9a8d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 13:28:01 -0400 Subject: [PATCH 037/114] merged --- vms/platformvm/state/chain_time_helpers_test.go | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/vms/platformvm/state/chain_time_helpers_test.go b/vms/platformvm/state/chain_time_helpers_test.go index 22a0fc19db52..434a9e802647 100644 --- a/vms/platformvm/state/chain_time_helpers_test.go +++ b/vms/platformvm/state/chain_time_helpers_test.go @@ -8,6 +8,7 @@ import ( "github.com/stretchr/testify/require" + "github.com/ava-labs/avalanchego/database/memdb" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/vms/platformvm/config" @@ -64,8 +65,6 @@ func TestPickFeeCalculator(t *testing.T) { } for _, test := range tests { t.Run(test.fork.String(), func(t *testing.T) { - require := require.New(t) - var ( config = &config.Config{ CreateAssetTxFee: createAssetTxFee, @@ -73,10 +72,10 @@ func TestPickFeeCalculator(t *testing.T) { DynamicFeeConfig: dynamicFeeConfig, UpgradeConfig: upgradetest.GetConfig(test.fork), } - s = newInitializedState(require) + s = newTestState(t, memdb.New()) ) actual := PickFeeCalculator(config, s) - require.Equal(test.expected, actual) + require.Equal(t, test.expected, actual) }) } } From ffbee12b7e89c6827ccc40bf91c9cdecca0facf5 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 13:59:37 -0400 Subject: [PATCH 038/114] Add test --- vms/platformvm/state/statetest/state.go | 47 ++++++++ .../txs/executor/state_changes_test.go | 108 ++++++++++++++++++ 2 files changed, 155 insertions(+) create mode 100644 vms/platformvm/state/statetest/state.go create mode 100644 vms/platformvm/txs/executor/state_changes_test.go diff --git a/vms/platformvm/state/statetest/state.go b/vms/platformvm/state/statetest/state.go new file mode 100644 index 000000000000..a294b1eb0edb --- /dev/null +++ b/vms/platformvm/state/statetest/state.go @@ -0,0 +1,47 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package statetest + +import ( + "testing" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/database" + "github.com/ava-labs/avalanchego/snow" + "github.com/ava-labs/avalanchego/snow/validators" + "github.com/ava-labs/avalanchego/utils/logging" + "github.com/ava-labs/avalanchego/utils/units" + "github.com/ava-labs/avalanchego/vms/platformvm/config" + "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" + "github.com/ava-labs/avalanchego/vms/platformvm/metrics" + "github.com/ava-labs/avalanchego/vms/platformvm/reward" + "github.com/ava-labs/avalanchego/vms/platformvm/state" +) + +func New(t testing.TB, db database.Database) state.State { + s, err := state.New( + db, + genesistest.NewBytes(t), + prometheus.NewRegistry(), + &config.Config{ + Validators: validators.NewManager(), + }, + &config.DefaultExecutionConfig, + &snow.Context{ + Log: logging.NoLog{}, + }, + metrics.Noop, + reward.NewCalculator(reward.Config{ + MaxConsumptionRate: .12 * reward.PercentDenominator, + MinConsumptionRate: .1 * reward.PercentDenominator, + MintingPeriod: 365 * 24 * time.Hour, + SupplyCap: 720 * units.MegaAvax, + }), + ) + require.NoError(t, err) + return s +} diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go new file mode 100644 index 000000000000..54b4cf672796 --- /dev/null +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -0,0 +1,108 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package executor + +import ( + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/database/memdb" + "github.com/ava-labs/avalanchego/upgrade/upgradetest" + "github.com/ava-labs/avalanchego/vms/components/fee" + "github.com/ava-labs/avalanchego/vms/platformvm/config" + "github.com/ava-labs/avalanchego/vms/platformvm/state" + "github.com/ava-labs/avalanchego/vms/platformvm/state/statetest" +) + +func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { + s := statetest.New(t, memdb.New()) + nextStakerChangeTime, err := state.GetNextStakerChangeTime(s) + require.NoError(t, err) + + currentTime := s.GetTimestamp() + durationToAdvance := nextStakerChangeTime.Sub(currentTime) + secondsToAdvance := uint64(durationToAdvance / time.Second) + + tests := []struct { + name string + fork upgradetest.Fork + config fee.Config + initialState fee.State + expectedState fee.State + }{ + { + name: "Pre-Etna", + fork: upgradetest.Durango, + config: fee.Config{ + MaxGasCapacity: 1000, + MaxGasPerSecond: 100, + TargetGasPerSecond: 50, + }, + initialState: fee.State{}, + expectedState: fee.State{}, + }, + { + name: "Etna with no usage", + fork: upgradetest.Etna, + config: fee.Config{ + MaxGasCapacity: 1000, + MaxGasPerSecond: 100, + TargetGasPerSecond: 50, + }, + initialState: fee.State{ + Capacity: 1000, + Excess: 0, + }, + expectedState: fee.State{ + Capacity: 1000, + Excess: 0, + }, + }, + { + name: "Etna with usage", + fork: upgradetest.Etna, + config: fee.Config{ + MaxGasCapacity: 1000, + MaxGasPerSecond: 100, + TargetGasPerSecond: 50, + }, + initialState: fee.State{ + Capacity: 600, + Excess: 400, + }, + expectedState: fee.State{ + Capacity: min(fee.Gas(600).AddPerSecond(100, secondsToAdvance), 1000), + Excess: fee.Gas(400).SubPerSecond(50, secondsToAdvance), + }, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require := require.New(t) + + modifiedState, err := state.NewDiffOn(s) + require.NoError(err) + + modifiedState.SetFeeState(test.initialState) + + validatorsModified, err := AdvanceTimeTo( + &Backend{ + Config: &config.Config{ + DynamicFeeConfig: test.config, + UpgradeConfig: upgradetest.GetConfig(test.fork), + }, + }, + modifiedState, + nextStakerChangeTime, + ) + require.NoError(err) + require.False(validatorsModified) + + feeState := modifiedState.GetFeeState() + require.Equal(test.expectedState, feeState) + }) + } +} From 179f557cb6b7a627ab16e6a6bc9c41fecc98cd64 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 15:06:08 -0400 Subject: [PATCH 039/114] Simplify tests --- .../txs/executor/state_changes_test.go | 39 +++++++------------ 1 file changed, 14 insertions(+), 25 deletions(-) diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go index 54b4cf672796..839b93d10984 100644 --- a/vms/platformvm/txs/executor/state_changes_test.go +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -26,56 +26,45 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { durationToAdvance := nextStakerChangeTime.Sub(currentTime) secondsToAdvance := uint64(durationToAdvance / time.Second) + feeConfig := fee.Config{ + MaxGasCapacity: 1000, + MaxGasPerSecond: 100, + TargetGasPerSecond: 50, + } + tests := []struct { name string fork upgradetest.Fork - config fee.Config initialState fee.State expectedState fee.State }{ { - name: "Pre-Etna", - fork: upgradetest.Durango, - config: fee.Config{ - MaxGasCapacity: 1000, - MaxGasPerSecond: 100, - TargetGasPerSecond: 50, - }, + name: "Pre-Etna", + fork: upgradetest.Durango, initialState: fee.State{}, - expectedState: fee.State{}, + expectedState: fee.State{}, // Pre-Etna, fee state should not change }, { name: "Etna with no usage", - fork: upgradetest.Etna, - config: fee.Config{ - MaxGasCapacity: 1000, - MaxGasPerSecond: 100, - TargetGasPerSecond: 50, - }, initialState: fee.State{ - Capacity: 1000, + Capacity: feeConfig.MaxGasCapacity, Excess: 0, }, expectedState: fee.State{ - Capacity: 1000, + Capacity: feeConfig.MaxGasCapacity, Excess: 0, }, }, { name: "Etna with usage", fork: upgradetest.Etna, - config: fee.Config{ - MaxGasCapacity: 1000, - MaxGasPerSecond: 100, - TargetGasPerSecond: 50, - }, initialState: fee.State{ Capacity: 600, Excess: 400, }, expectedState: fee.State{ - Capacity: min(fee.Gas(600).AddPerSecond(100, secondsToAdvance), 1000), - Excess: fee.Gas(400).SubPerSecond(50, secondsToAdvance), + Capacity: min(fee.Gas(600).AddPerSecond(feeConfig.MaxGasPerSecond, secondsToAdvance), feeConfig.MaxGasCapacity), + Excess: fee.Gas(400).SubPerSecond(feeConfig.TargetGasPerSecond, secondsToAdvance), }, }, } @@ -91,7 +80,7 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { validatorsModified, err := AdvanceTimeTo( &Backend{ Config: &config.Config{ - DynamicFeeConfig: test.config, + DynamicFeeConfig: feeConfig, UpgradeConfig: upgradetest.GetConfig(test.fork), }, }, From 9918ac80c0df422c05a7517356a4bd126b3a98c0 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 15:07:09 -0400 Subject: [PATCH 040/114] nit --- .../txs/executor/state_changes_test.go | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go index 839b93d10984..fa92de14bfb6 100644 --- a/vms/platformvm/txs/executor/state_changes_test.go +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -22,15 +22,17 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { nextStakerChangeTime, err := state.GetNextStakerChangeTime(s) require.NoError(t, err) - currentTime := s.GetTimestamp() - durationToAdvance := nextStakerChangeTime.Sub(currentTime) - secondsToAdvance := uint64(durationToAdvance / time.Second) + var ( + currentTime = s.GetTimestamp() + durationToAdvance = nextStakerChangeTime.Sub(currentTime) + secondsToAdvance = uint64(durationToAdvance / time.Second) - feeConfig := fee.Config{ - MaxGasCapacity: 1000, - MaxGasPerSecond: 100, - TargetGasPerSecond: 50, - } + feeConfig = fee.Config{ + MaxGasCapacity: 1000, + MaxGasPerSecond: 100, + TargetGasPerSecond: 50, + } + ) tests := []struct { name string From 894e1210df02bccf92de6bbf79ff1ad89c406b2e Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 15:17:16 -0400 Subject: [PATCH 041/114] Use reasonable values --- .../txs/executor/state_changes_test.go | 31 ++++++++++++------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go index fa92de14bfb6..b32348b2c665 100644 --- a/vms/platformvm/txs/executor/state_changes_test.go +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -19,21 +19,28 @@ import ( func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { s := statetest.New(t, memdb.New()) - nextStakerChangeTime, err := state.GetNextStakerChangeTime(s) - require.NoError(t, err) - var ( - currentTime = s.GetTimestamp() - durationToAdvance = nextStakerChangeTime.Sub(currentTime) - secondsToAdvance = uint64(durationToAdvance / time.Second) + const ( + secondsToAdvance = 3 + durationToAdvance = secondsToAdvance * time.Second + ) - feeConfig = fee.Config{ + var ( + currentTime = s.GetTimestamp() + nextTime = currentTime.Add(durationToAdvance) + feeConfig = fee.Config{ MaxGasCapacity: 1000, MaxGasPerSecond: 100, TargetGasPerSecond: 50, } ) + // Ensure the invariant that [nextTime <= nextStakerChangeTime] on + // AdvanceTimeTo is maintained. + nextStakerChangeTime, err := state.GetNextStakerChangeTime(s) + require.NoError(t, err) + require.False(t, nextTime.After(nextStakerChangeTime)) + tests := []struct { name string fork upgradetest.Fork @@ -61,12 +68,12 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { name: "Etna with usage", fork: upgradetest.Etna, initialState: fee.State{ - Capacity: 600, - Excess: 400, + Capacity: 1, + Excess: 10_000, }, expectedState: fee.State{ - Capacity: min(fee.Gas(600).AddPerSecond(feeConfig.MaxGasPerSecond, secondsToAdvance), feeConfig.MaxGasCapacity), - Excess: fee.Gas(400).SubPerSecond(feeConfig.TargetGasPerSecond, secondsToAdvance), + Capacity: min(fee.Gas(1).AddPerSecond(feeConfig.MaxGasPerSecond, secondsToAdvance), feeConfig.MaxGasCapacity), + Excess: fee.Gas(10_000).SubPerSecond(feeConfig.TargetGasPerSecond, secondsToAdvance), }, }, } @@ -87,7 +94,7 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { }, }, modifiedState, - nextStakerChangeTime, + nextTime, ) require.NoError(err) require.False(validatorsModified) From 9353d05d2115e80f884a7e044cc542cc2ec4ad36 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 15:18:19 -0400 Subject: [PATCH 042/114] nit --- vms/platformvm/txs/executor/state_changes_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go index b32348b2c665..231b0ff7d5dd 100644 --- a/vms/platformvm/txs/executor/state_changes_test.go +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -98,9 +98,8 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { ) require.NoError(err) require.False(validatorsModified) - - feeState := modifiedState.GetFeeState() - require.Equal(test.expectedState, feeState) + require.Equal(test.expectedState, modifiedState.GetFeeState()) + require.Equal(nextTime, modifiedState.GetTimestamp()) }) } } From afac03921dc0271c1835e32751ad6378525a4538 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 15:19:00 -0400 Subject: [PATCH 043/114] nit --- vms/platformvm/txs/executor/state_changes_test.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go index 231b0ff7d5dd..33f4b1c47ba1 100644 --- a/vms/platformvm/txs/executor/state_changes_test.go +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -18,14 +18,13 @@ import ( ) func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { - s := statetest.New(t, memdb.New()) - const ( secondsToAdvance = 3 durationToAdvance = secondsToAdvance * time.Second ) var ( + s = statetest.New(t, memdb.New()) currentTime = s.GetTimestamp() nextTime = currentTime.Add(durationToAdvance) feeConfig = fee.Config{ From 420d3cad8136b17bd589c4b41547c9abffa1ccb5 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 15:21:28 -0400 Subject: [PATCH 044/114] nit --- .../txs/executor/state_changes_test.go | 41 +++++++++---------- 1 file changed, 19 insertions(+), 22 deletions(-) diff --git a/vms/platformvm/txs/executor/state_changes_test.go b/vms/platformvm/txs/executor/state_changes_test.go index 33f4b1c47ba1..6b966322202e 100644 --- a/vms/platformvm/txs/executor/state_changes_test.go +++ b/vms/platformvm/txs/executor/state_changes_test.go @@ -23,22 +23,11 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { durationToAdvance = secondsToAdvance * time.Second ) - var ( - s = statetest.New(t, memdb.New()) - currentTime = s.GetTimestamp() - nextTime = currentTime.Add(durationToAdvance) - feeConfig = fee.Config{ - MaxGasCapacity: 1000, - MaxGasPerSecond: 100, - TargetGasPerSecond: 50, - } - ) - - // Ensure the invariant that [nextTime <= nextStakerChangeTime] on - // AdvanceTimeTo is maintained. - nextStakerChangeTime, err := state.GetNextStakerChangeTime(s) - require.NoError(t, err) - require.False(t, nextTime.After(nextStakerChangeTime)) + feeConfig := fee.Config{ + MaxGasCapacity: 1000, + MaxGasPerSecond: 100, + TargetGasPerSecond: 50, + } tests := []struct { name string @@ -78,12 +67,20 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - require := require.New(t) + var ( + require = require.New(t) + + s = statetest.New(t, memdb.New()) + nextTime = s.GetTimestamp().Add(durationToAdvance) + ) - modifiedState, err := state.NewDiffOn(s) + // Ensure the invariant that [nextTime <= nextStakerChangeTime] on + // AdvanceTimeTo is maintained. + nextStakerChangeTime, err := state.GetNextStakerChangeTime(s) require.NoError(err) + require.False(nextTime.After(nextStakerChangeTime)) - modifiedState.SetFeeState(test.initialState) + s.SetFeeState(test.initialState) validatorsModified, err := AdvanceTimeTo( &Backend{ @@ -92,13 +89,13 @@ func TestAdvanceTimeTo_UpdatesFeeState(t *testing.T) { UpgradeConfig: upgradetest.GetConfig(test.fork), }, }, - modifiedState, + s, nextTime, ) require.NoError(err) require.False(validatorsModified) - require.Equal(test.expectedState, modifiedState.GetFeeState()) - require.Equal(nextTime, modifiedState.GetTimestamp()) + require.Equal(test.expectedState, s.GetFeeState()) + require.Equal(nextTime, s.GetTimestamp()) }) } } From 3925f3687a96bb1fd2f62c16790f3109a9ebb651 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 19 Aug 2024 17:33:10 -0400 Subject: [PATCH 045/114] Expose wallet backend --- vms/platformvm/txs/txstest/wallet.go | 104 ++++++++++++++++++ wallet/chain/p/{ => backend}/backend.go | 6 +- .../visitor.go} | 40 +++---- wallet/chain/p/builder_test.go | 23 ++-- wallet/chain/p/wallet.go | 5 +- .../examples/get-p-chain-balance/main.go | 4 +- wallet/subnet/primary/wallet.go | 3 +- 7 files changed, 146 insertions(+), 39 deletions(-) create mode 100644 vms/platformvm/txs/txstest/wallet.go rename wallet/chain/p/{ => backend}/backend.go (93%) rename wallet/chain/p/{backend_visitor.go => backend/visitor.go} (53%) diff --git a/vms/platformvm/txs/txstest/wallet.go b/vms/platformvm/txs/txstest/wallet.go new file mode 100644 index 000000000000..fb0dbf6c4930 --- /dev/null +++ b/vms/platformvm/txs/txstest/wallet.go @@ -0,0 +1,104 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package txstest + +import ( + "context" + "math" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/chains/atomic" + "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/utils/constants" + "github.com/ava-labs/avalanchego/vms/components/avax" + "github.com/ava-labs/avalanchego/vms/platformvm/fx" + "github.com/ava-labs/avalanchego/vms/platformvm/state" + "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/backend" + "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + "github.com/ava-labs/avalanchego/wallet/chain/p/signer" + "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" +) + +func NewWallet( + t testing.TB, + state state.State, + sharedMemory atomic.SharedMemory, + ctx *builder.Context, + kc *secp256k1fx.Keychain, + subnetIDs []ids.ID, + chainIDs []ids.ID, +) ( + backend.Backend, + builder.Builder, + signer.Signer, +) { + var ( + require = require.New(t) + addrs = kc.Addresses() + utxos = common.NewUTXOs() + ) + + pChainUTXOs, err := avax.GetAllUTXOs(state, addrs) + require.NoError(err) + + for _, utxo := range pChainUTXOs { + require.NoError(utxos.AddUTXO( + context.Background(), + constants.PlatformChainID, + constants.PlatformChainID, + utxo, + )) + } + + for _, chainID := range chainIDs { + remoteChainUTXOs, _, _, err := avax.GetAtomicUTXOs( + sharedMemory, + txs.Codec, + chainID, + addrs, + ids.ShortEmpty, + ids.Empty, + math.MaxInt, + ) + require.NoError(err) + + for _, utxo := range remoteChainUTXOs { + require.NoError(utxos.AddUTXO( + context.Background(), + chainID, + constants.PlatformChainID, + utxo, + )) + } + } + + owners := make(map[ids.ID]fx.Owner, len(subnetIDs)) + for _, subnetID := range subnetIDs { + owner, err := state.GetSubnetOwner(subnetID) + require.NoError(err) + owners[subnetID] = owner + } + + var ( + backend = backend.New( + ctx, + common.NewChainUTXOs(constants.PlatformChainID, utxos), + owners, + ) + builder = builder.New( + addrs, + ctx, + backend, + ) + signer = signer.New( + kc, + backend, + ) + ) + return backend, builder, signer +} diff --git a/wallet/chain/p/backend.go b/wallet/chain/p/backend/backend.go similarity index 93% rename from wallet/chain/p/backend.go rename to wallet/chain/p/backend/backend.go index 8a1cd6b7806c..fbe1d0e64fba 100644 --- a/wallet/chain/p/backend.go +++ b/wallet/chain/p/backend/backend.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package backend import ( "context" @@ -38,7 +38,7 @@ type backend struct { subnetOwner map[ids.ID]fx.Owner // subnetID -> owner } -func NewBackend(context *builder.Context, utxos common.ChainUTXOs, subnetOwner map[ids.ID]fx.Owner) Backend { +func New(context *builder.Context, utxos common.ChainUTXOs, subnetOwner map[ids.ID]fx.Owner) Backend { return &backend{ ChainUTXOs: utxos, context: context, @@ -48,7 +48,7 @@ func NewBackend(context *builder.Context, utxos common.ChainUTXOs, subnetOwner m func (b *backend) AcceptTx(ctx context.Context, tx *txs.Tx) error { txID := tx.ID() - err := tx.Unsigned.Visit(&backendVisitor{ + err := tx.Unsigned.Visit(&visitor{ b: b, ctx: ctx, txID: txID, diff --git a/wallet/chain/p/backend_visitor.go b/wallet/chain/p/backend/visitor.go similarity index 53% rename from wallet/chain/p/backend_visitor.go rename to wallet/chain/p/backend/visitor.go index c7cec9544da1..43275ebc87d8 100644 --- a/wallet/chain/p/backend_visitor.go +++ b/wallet/chain/p/backend/visitor.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package backend import ( "context" @@ -14,43 +14,43 @@ import ( ) var ( - _ txs.Visitor = (*backendVisitor)(nil) + _ txs.Visitor = (*visitor)(nil) ErrUnsupportedTxType = errors.New("unsupported tx type") ) -// backendVisitor handles accepting of transactions for the backend -type backendVisitor struct { +// visitor handles accepting transactions for the backend +type visitor struct { b *backend ctx context.Context txID ids.ID } -func (*backendVisitor) AdvanceTimeTx(*txs.AdvanceTimeTx) error { +func (*visitor) AdvanceTimeTx(*txs.AdvanceTimeTx) error { return ErrUnsupportedTxType } -func (*backendVisitor) RewardValidatorTx(*txs.RewardValidatorTx) error { +func (*visitor) RewardValidatorTx(*txs.RewardValidatorTx) error { return ErrUnsupportedTxType } -func (b *backendVisitor) AddValidatorTx(tx *txs.AddValidatorTx) error { +func (b *visitor) AddValidatorTx(tx *txs.AddValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) AddSubnetValidatorTx(tx *txs.AddSubnetValidatorTx) error { +func (b *visitor) AddSubnetValidatorTx(tx *txs.AddSubnetValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) AddDelegatorTx(tx *txs.AddDelegatorTx) error { +func (b *visitor) AddDelegatorTx(tx *txs.AddDelegatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) CreateChainTx(tx *txs.CreateChainTx) error { +func (b *visitor) CreateChainTx(tx *txs.CreateChainTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) CreateSubnetTx(tx *txs.CreateSubnetTx) error { +func (b *visitor) CreateSubnetTx(tx *txs.CreateSubnetTx) error { b.b.setSubnetOwner( b.txID, tx.Owner, @@ -58,11 +58,11 @@ func (b *backendVisitor) CreateSubnetTx(tx *txs.CreateSubnetTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) RemoveSubnetValidatorTx(tx *txs.RemoveSubnetValidatorTx) error { +func (b *visitor) RemoveSubnetValidatorTx(tx *txs.RemoveSubnetValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) TransferSubnetOwnershipTx(tx *txs.TransferSubnetOwnershipTx) error { +func (b *visitor) TransferSubnetOwnershipTx(tx *txs.TransferSubnetOwnershipTx) error { b.b.setSubnetOwner( tx.Subnet, tx.Owner, @@ -70,11 +70,11 @@ func (b *backendVisitor) TransferSubnetOwnershipTx(tx *txs.TransferSubnetOwnersh return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) BaseTx(tx *txs.BaseTx) error { +func (b *visitor) BaseTx(tx *txs.BaseTx) error { return b.baseTx(tx) } -func (b *backendVisitor) ImportTx(tx *txs.ImportTx) error { +func (b *visitor) ImportTx(tx *txs.ImportTx) error { err := b.b.removeUTXOs( b.ctx, tx.SourceChain, @@ -86,7 +86,7 @@ func (b *backendVisitor) ImportTx(tx *txs.ImportTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) ExportTx(tx *txs.ExportTx) error { +func (b *visitor) ExportTx(tx *txs.ExportTx) error { for i, out := range tx.ExportedOutputs { err := b.b.AddUTXO( b.ctx, @@ -107,19 +107,19 @@ func (b *backendVisitor) ExportTx(tx *txs.ExportTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) TransformSubnetTx(tx *txs.TransformSubnetTx) error { +func (b *visitor) TransformSubnetTx(tx *txs.TransformSubnetTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) AddPermissionlessValidatorTx(tx *txs.AddPermissionlessValidatorTx) error { +func (b *visitor) AddPermissionlessValidatorTx(tx *txs.AddPermissionlessValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) AddPermissionlessDelegatorTx(tx *txs.AddPermissionlessDelegatorTx) error { +func (b *visitor) AddPermissionlessDelegatorTx(tx *txs.AddPermissionlessDelegatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *backendVisitor) baseTx(tx *txs.BaseTx) error { +func (b *visitor) baseTx(tx *txs.BaseTx) error { return b.b.removeUTXOs( b.ctx, constants.PlatformChainID, diff --git a/wallet/chain/p/builder_test.go b/wallet/chain/p/builder_test.go index 6885a3b4fc9e..4dd0e21328bc 100644 --- a/wallet/chain/p/builder_test.go +++ b/wallet/chain/p/builder_test.go @@ -24,6 +24,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/vms/types" + "github.com/ava-labs/avalanchego/wallet/chain/p/backend" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common/utxotest" @@ -174,7 +175,7 @@ func TestBaseTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = backend.New(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr), e.context, backend) ) @@ -214,7 +215,7 @@ func TestAddSubnetValidatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = backend.New(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -246,7 +247,7 @@ func TestRemoveSubnetValidatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = backend.New(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -287,7 +288,7 @@ func TestCreateChainTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = backend.New(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -327,7 +328,7 @@ func TestCreateSubnetTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = backend.New(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -359,7 +360,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = backend.New(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -399,7 +400,7 @@ func TestImportTx(t *testing.T) { constants.PlatformChainID: utxos, sourceChainID: importedUTXOs, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = backend.New(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr), e.context, backend) ) @@ -436,7 +437,7 @@ func TestExportTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = backend.New(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr), e.context, backend) ) @@ -486,7 +487,7 @@ func TestTransformSubnetTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = backend.New(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -578,7 +579,7 @@ func TestAddPermissionlessValidatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = backend.New(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr, rewardAddr), e.context, backend) ) @@ -631,7 +632,7 @@ func TestAddPermissionlessDelegatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = backend.New(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr, rewardAddr), e.context, backend) ) diff --git a/wallet/chain/p/wallet.go b/wallet/chain/p/wallet.go index 631553431ef7..3f0656e92377 100644 --- a/wallet/chain/p/wallet.go +++ b/wallet/chain/p/wallet.go @@ -12,6 +12,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/backend" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" @@ -258,7 +259,7 @@ func NewWallet( builder builder.Builder, signer walletsigner.Signer, client platformvm.Client, - backend Backend, + backend backend.Backend, ) Wallet { return &wallet{ Backend: backend, @@ -269,7 +270,7 @@ func NewWallet( } type wallet struct { - Backend + backend.Backend builder builder.Builder signer walletsigner.Signer client platformvm.Client diff --git a/wallet/subnet/primary/examples/get-p-chain-balance/main.go b/wallet/subnet/primary/examples/get-p-chain-balance/main.go index e190247515bf..67142ed3d9f4 100644 --- a/wallet/subnet/primary/examples/get-p-chain-balance/main.go +++ b/wallet/subnet/primary/examples/get-p-chain-balance/main.go @@ -11,7 +11,7 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/formatting/address" "github.com/ava-labs/avalanchego/utils/set" - "github.com/ava-labs/avalanchego/wallet/chain/p" + "github.com/ava-labs/avalanchego/wallet/chain/p/backend" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" "github.com/ava-labs/avalanchego/wallet/subnet/primary" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" @@ -38,7 +38,7 @@ func main() { log.Printf("fetched state of %s in %s\n", addrStr, time.Since(fetchStartTime)) pUTXOs := common.NewChainUTXOs(constants.PlatformChainID, state.UTXOs) - pBackend := p.NewBackend(state.PCTX, pUTXOs, nil) + pBackend := backend.New(state.PCTX, pUTXOs, nil) pBuilder := builder.New(addresses, state.PCTX, pBackend) currentBalances, err := pBuilder.GetBalance() diff --git a/wallet/subnet/primary/wallet.go b/wallet/subnet/primary/wallet.go index d2c9f4d45050..3725f6595f95 100644 --- a/wallet/subnet/primary/wallet.go +++ b/wallet/subnet/primary/wallet.go @@ -15,6 +15,7 @@ import ( "github.com/ava-labs/avalanchego/wallet/chain/x" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" + pbackend "github.com/ava-labs/avalanchego/wallet/chain/p/backend" pbuilder "github.com/ava-labs/avalanchego/wallet/chain/p/builder" psigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" xbuilder "github.com/ava-labs/avalanchego/wallet/chain/x/builder" @@ -105,7 +106,7 @@ func MakeWallet(ctx context.Context, config *WalletConfig) (Wallet, error) { return nil, err } pUTXOs := common.NewChainUTXOs(constants.PlatformChainID, avaxState.UTXOs) - pBackend := p.NewBackend(avaxState.PCTX, pUTXOs, subnetOwners) + pBackend := pbackend.New(avaxState.PCTX, pUTXOs, subnetOwners) pBuilder := pbuilder.New(avaxAddrs, avaxState.PCTX, pBackend) pSigner := psigner.New(config.AVAXKeychain, pBackend) From 2d295d6f7cd97a46c7f0b438d269569f05efbbd8 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 12:34:40 -0400 Subject: [PATCH 046/114] Add verifier tests --- .../block/executor/verifier_test.go | 197 ++++++++++++- vms/platformvm/genesis/genesistest/genesis.go | 22 +- vms/platformvm/txs/fee/complexity.go | 18 +- vms/platformvm/txs/txstest/wallet.go | 269 ++++++++++++++++-- 4 files changed, 475 insertions(+), 31 deletions(-) diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index 535e7d70f37e..081cb606687b 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -8,28 +8,137 @@ import ( "testing" "time" + "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/require" "go.uber.org/mock/gomock" "github.com/ava-labs/avalanchego/chains/atomic" "github.com/ava-labs/avalanchego/database" + "github.com/ava-labs/avalanchego/database/memdb" + "github.com/ava-labs/avalanchego/genesis" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/upgrade/upgradetest" + "github.com/ava-labs/avalanchego/utils" + "github.com/ava-labs/avalanchego/utils/constants" + "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/timer/mockable" - "github.com/ava-labs/avalanchego/vms/components/fee" + "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/components/verify" "github.com/ava-labs/avalanchego/vms/platformvm/block" "github.com/ava-labs/avalanchego/vms/platformvm/config" + "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/state" + "github.com/ava-labs/avalanchego/vms/platformvm/state/statetest" "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" "github.com/ava-labs/avalanchego/vms/platformvm/txs/mempool" + "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" + "github.com/ava-labs/avalanchego/vms/platformvm/utxo" + "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + + feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" + txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) +func newTestVerifier(t testing.TB, s state.State) *verifier { + require := require.New(t) + + mempool, err := mempool.New("", prometheus.NewRegistry(), nil) + require.NoError(err) + + sk, err := bls.NewSecretKey() + require.NoError(err) + pk := bls.PublicFromSecretKey(sk) + + var ( + upgrades = upgradetest.GetConfig(upgradetest.Latest) + ctx = &snow.Context{ + NetworkID: constants.UnitTestID, + SubnetID: constants.PrimaryNetworkID, + ChainID: constants.PlatformChainID, + NodeID: ids.GenerateTestNodeID(), + PublicKey: pk, + NetworkUpgrades: upgrades, + + XChainID: ids.GenerateTestID(), + CChainID: ids.GenerateTestID(), + AVAXAssetID: genesistest.AVAXAssetID, + + Log: logging.NoLog{}, + } + clock = &mockable.Clock{} + fx = &secp256k1fx.Fx{} + ) + require.NoError(fx.InitializeVM(&secp256k1fx.TestVM{ + Clk: *clock, + Log: logging.NoLog{}, + })) + + return &verifier{ + backend: &backend{ + Mempool: mempool, + lastAccepted: s.GetLastAccepted(), + blkIDToState: make(map[ids.ID]*blockState), + state: s, + ctx: ctx, + }, + txExecutorBackend: &executor.Backend{ + Config: &config.Config{ + CreateAssetTxFee: genesis.LocalParams.CreateAssetTxFee, + StaticFeeConfig: genesis.LocalParams.StaticFeeConfig, + DynamicFeeConfig: genesis.LocalParams.DynamicFeeConfig, + SybilProtectionEnabled: true, + UpgradeConfig: upgrades, + }, + Ctx: ctx, + Clk: clock, + Fx: fx, + FlowChecker: utxo.NewVerifier( + ctx, + clock, + fx, + ), + Bootstrapped: utils.NewAtomic(true), + }, + pChainHeight: 0, + } +} + +func newTestWallet( + t testing.TB, + v *verifier, +) *txstest.Wallet { + ctx := &builder.Context{ + NetworkID: v.ctx.NetworkID, + AVAXAssetID: v.ctx.AVAXAssetID, + } + if !v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(v.state.GetTimestamp()) { + ctx.StaticFeeConfig = v.txExecutorBackend.Config.StaticFeeConfig + } else { + ctx.ComplexityWeights = v.txExecutorBackend.Config.DynamicFeeConfig.Weights + ctx.GasPrice = 10 * feecomponent.CalculateGasPrice( + v.txExecutorBackend.Config.DynamicFeeConfig.MinGasPrice, + v.state.GetFeeState().Excess, + v.txExecutorBackend.Config.DynamicFeeConfig.ExcessConversionConstant, + ) + } + + return txstest.NewWallet( + t, + v.state, + v.ctx.SharedMemory, + ctx, + secp256k1fx.NewKeychain(genesis.EWOQKey), + nil, // subnetIDs + nil, // chainIDs + ) +} + func TestVerifierVisitProposalBlock(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) @@ -42,7 +151,7 @@ func TestVerifierVisitProposalBlock(t *testing.T) { timestamp := time.Now() // One call for each of onCommitState and onAbortState. parentOnAcceptState.EXPECT().GetTimestamp().Return(timestamp).Times(2) - parentOnAcceptState.EXPECT().GetFeeState().Return(fee.State{}).Times(2) + parentOnAcceptState.EXPECT().GetFeeState().Return(feecomponent.State{}).Times(2) backend := &backend{ lastAccepted: parentID, @@ -273,7 +382,7 @@ func TestVerifierVisitStandardBlock(t *testing.T) { // Set expectations for dependencies. timestamp := time.Now() parentState.EXPECT().GetTimestamp().Return(timestamp).Times(1) - parentState.EXPECT().GetFeeState().Return(fee.State{}).Times(1) + parentState.EXPECT().GetFeeState().Return(feecomponent.State{}).Times(1) parentStatelessBlk.EXPECT().Height().Return(uint64(1)).Times(1) mempool.EXPECT().Remove(apricotBlk.Txs()).Times(1) @@ -534,7 +643,7 @@ func TestBanffAbortBlockTimestampChecks(t *testing.T) { parentTime := defaultGenesisTime s.EXPECT().GetLastAccepted().Return(parentID).Times(3) s.EXPECT().GetTimestamp().Return(parentTime).Times(3) - s.EXPECT().GetFeeState().Return(fee.State{}).Times(3) + s.EXPECT().GetFeeState().Return(feecomponent.State{}).Times(3) onDecisionState, err := state.NewDiff(parentID, backend) require.NoError(err) @@ -631,7 +740,7 @@ func TestBanffCommitBlockTimestampChecks(t *testing.T) { parentTime := defaultGenesisTime s.EXPECT().GetLastAccepted().Return(parentID).Times(3) s.EXPECT().GetTimestamp().Return(parentTime).Times(3) - s.EXPECT().GetFeeState().Return(fee.State{}).Times(3) + s.EXPECT().GetFeeState().Return(feecomponent.State{}).Times(3) onDecisionState, err := state.NewDiff(parentID, backend) require.NoError(err) @@ -746,7 +855,7 @@ func TestVerifierVisitStandardBlockWithDuplicateInputs(t *testing.T) { timestamp := time.Now() parentStatelessBlk.EXPECT().Height().Return(uint64(1)).Times(1) parentState.EXPECT().GetTimestamp().Return(timestamp).Times(1) - parentState.EXPECT().GetFeeState().Return(fee.State{}).Times(1) + parentState.EXPECT().GetFeeState().Return(feecomponent.State{}).Times(1) parentStatelessBlk.EXPECT().Parent().Return(grandParentID).Times(1) err = verifier.ApricotStandardBlock(blk) @@ -1040,3 +1149,79 @@ func TestVerifierVisitBanffAbortBlockUnexpectedParentState(t *testing.T) { err = verifier.BanffAbortBlock(blk) require.ErrorIs(err, state.ErrMissingParentState) } + +func TestBlockExecutionWithComplexity(t *testing.T) { + s := statetest.New(t, memdb.New()) + verifier := newTestVerifier(t, s) + wallet := newTestWallet(t, verifier) + + baseTx0, err := wallet.IssueBaseTx([]*avax.TransferableOutput{}) + require.NoError(t, err) + baseTx1, err := wallet.IssueBaseTx([]*avax.TransferableOutput{}) + require.NoError(t, err) + + blockComplexity, err := txfee.TxComplexity(baseTx0.Unsigned, baseTx1.Unsigned) + require.NoError(t, err) + blockGas, err := blockComplexity.ToGas(verifier.txExecutorBackend.Config.DynamicFeeConfig.Weights) + require.NoError(t, err) + + tests := []struct { + name string + timestamp time.Time + expectedErr error + expectedFeeState feecomponent.State + }{ + { + name: "no capacity", + timestamp: genesistest.Time, + expectedErr: feecomponent.ErrInsufficientCapacity, + }, + { + name: "updates fee state", + timestamp: genesistest.Time.Add(10 * time.Second), + expectedFeeState: feecomponent.State{ + Capacity: feecomponent.Gas(0).AddPerSecond(verifier.txExecutorBackend.Config.DynamicFeeConfig.MaxGasPerSecond, 10) - blockGas, + Excess: blockGas, + }, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require := require.New(t) + + // Clear the state to prevent prior tests from impacting this test. + clear(verifier.blkIDToState) + + verifier.txExecutorBackend.Clk.Set(test.timestamp) + timestamp, _, err := state.NextBlockTime(s, verifier.txExecutorBackend.Clk) + require.NoError(err) + + lastAcceptedID := s.GetLastAccepted() + lastAccepted, err := s.GetStatelessBlock(lastAcceptedID) + require.NoError(err) + + blk, err := block.NewBanffStandardBlock( + timestamp, + lastAcceptedID, + lastAccepted.Height()+1, + []*txs.Tx{ + baseTx0, + baseTx1, + }, + ) + require.NoError(err) + + blkID := blk.ID() + err = blk.Visit(verifier) + require.ErrorIs(err, test.expectedErr) + if err != nil { + require.NotContains(verifier.blkIDToState, blkID) + return + } + + require.Contains(verifier.blkIDToState, blkID) + onAcceptState := verifier.blkIDToState[blkID].onAcceptState + require.Equal(test.expectedFeeState, onAcceptState.GetFeeState()) + }) + } +} diff --git a/vms/platformvm/genesis/genesistest/genesis.go b/vms/platformvm/genesis/genesistest/genesis.go index 24e16ecf0934..c68c6c4a0169 100644 --- a/vms/platformvm/genesis/genesistest/genesis.go +++ b/vms/platformvm/genesis/genesistest/genesis.go @@ -13,10 +13,12 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/components/avax" - "github.com/ava-labs/avalanchego/vms/platformvm/genesis" "github.com/ava-labs/avalanchego/vms/platformvm/reward" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + + avalanchegenesis "github.com/ava-labs/avalanchego/genesis" + platformvmgenesis "github.com/ava-labs/avalanchego/vms/platformvm/genesis" ) var ( @@ -29,17 +31,17 @@ var ( ValidatorDuration = 28 * 24 * time.Hour ValidatorEndTime = Time.Add(ValidatorDuration) ValidatorEndTimeUnix = uint64(ValidatorEndTime.Unix()) - ValidatorWeight = units.Avax + ValidatorWeight = units.MegaAvax ValidatorRewardsOwner = &secp256k1fx.OutputOwners{} ValidatorDelegationShares uint32 = reward.PercentDenominator XChainName = "x" - InitialBalance = units.Schmeckle + InitialBalance = 30 * units.MegaAvax InitialSupply = ValidatorWeight + InitialBalance ) -func New(t testing.TB) *genesis.Genesis { +func New(t testing.TB) *platformvmgenesis.Genesis { require := require.New(t) genesisValidator := &txs.AddValidatorTx{ @@ -72,8 +74,8 @@ func New(t testing.TB) *genesis.Genesis { genesisChainTx := &txs.Tx{Unsigned: genesisChain} require.NoError(genesisChainTx.Initialize(txs.Codec)) - return &genesis.Genesis{ - UTXOs: []*genesis.UTXO{ + return &platformvmgenesis.Genesis{ + UTXOs: []*platformvmgenesis.UTXO{ { UTXO: avax.UTXO{ UTXOID: avax.UTXOID{ @@ -83,6 +85,12 @@ func New(t testing.TB) *genesis.Genesis { Asset: AVAXAsset, Out: &secp256k1fx.TransferOutput{ Amt: InitialBalance, + OutputOwners: secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ + avalanchegenesis.EWOQKey.Address(), + }, + }, }, }, Message: nil, @@ -101,7 +109,7 @@ func New(t testing.TB) *genesis.Genesis { func NewBytes(t testing.TB) []byte { g := New(t) - genesisBytes, err := genesis.Codec.Marshal(genesis.CodecVersion, g) + genesisBytes, err := platformvmgenesis.Codec.Marshal(platformvmgenesis.CodecVersion, g) require.NoError(t, err) return genesisBytes } diff --git a/vms/platformvm/txs/fee/complexity.go b/vms/platformvm/txs/fee/complexity.go index 2334230078a8..8672d2378a8f 100644 --- a/vms/platformvm/txs/fee/complexity.go +++ b/vms/platformvm/txs/fee/complexity.go @@ -183,7 +183,23 @@ var ( errUnsupportedSigner = errors.New("unsupported signer type") ) -func TxComplexity(tx txs.UnsignedTx) (fee.Dimensions, error) { +func TxComplexity(txs ...txs.UnsignedTx) (fee.Dimensions, error) { + var complexity fee.Dimensions + for _, tx := range txs { + txComplexity, err := txComplexity(tx) + if err != nil { + return fee.Dimensions{}, err + } + + complexity, err = complexity.Add(&txComplexity) + if err != nil { + return fee.Dimensions{}, err + } + } + return complexity, nil +} + +func txComplexity(tx txs.UnsignedTx) (fee.Dimensions, error) { c := complexityVisitor{} err := tx.Visit(&c) return c.output, err diff --git a/vms/platformvm/txs/txstest/wallet.go b/vms/platformvm/txs/txstest/wallet.go index fb0dbf6c4930..658490f99b99 100644 --- a/vms/platformvm/txs/txstest/wallet.go +++ b/vms/platformvm/txs/txstest/wallet.go @@ -7,6 +7,7 @@ import ( "context" "math" "testing" + "time" "github.com/stretchr/testify/require" @@ -20,10 +21,18 @@ import ( "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/chain/p/backend" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - "github.com/ava-labs/avalanchego/wallet/chain/p/signer" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" + + vmsigner "github.com/ava-labs/avalanchego/vms/platformvm/signer" + psigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) +type Wallet struct { + Backend backend.Backend + Builder builder.Builder + Signer psigner.Signer +} + func NewWallet( t testing.TB, state state.State, @@ -32,11 +41,7 @@ func NewWallet( kc *secp256k1fx.Keychain, subnetIDs []ids.ID, chainIDs []ids.ID, -) ( - backend.Backend, - builder.Builder, - signer.Signer, -) { +) *Wallet { var ( require = require.New(t) addrs = kc.Addresses() @@ -84,21 +89,251 @@ func NewWallet( owners[subnetID] = owner } - var ( - backend = backend.New( - ctx, - common.NewChainUTXOs(constants.PlatformChainID, utxos), - owners, - ) - builder = builder.New( + backend := backend.New( + ctx, + common.NewChainUTXOs(constants.PlatformChainID, utxos), + owners, + ) + return &Wallet{ + Backend: backend, + Builder: builder.New( addrs, ctx, backend, - ) - signer = signer.New( + ), + Signer: psigner.New( kc, backend, - ) + ), + } +} + +func (w *Wallet) IssueBaseTx( + outputs []*avax.TransferableOutput, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewBaseTx(outputs, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueAddValidatorTx( + vdr *txs.Validator, + rewardsOwner *secp256k1fx.OutputOwners, + shares uint32, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewAddValidatorTx(vdr, rewardsOwner, shares, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueAddSubnetValidatorTx( + vdr *txs.SubnetValidator, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewAddSubnetValidatorTx(vdr, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueRemoveSubnetValidatorTx( + nodeID ids.NodeID, + subnetID ids.ID, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewRemoveSubnetValidatorTx(nodeID, subnetID, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueAddDelegatorTx( + vdr *txs.Validator, + rewardsOwner *secp256k1fx.OutputOwners, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewAddDelegatorTx(vdr, rewardsOwner, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueCreateChainTx( + subnetID ids.ID, + genesis []byte, + vmID ids.ID, + fxIDs []ids.ID, + chainName string, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewCreateChainTx(subnetID, genesis, vmID, fxIDs, chainName, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueCreateSubnetTx( + owner *secp256k1fx.OutputOwners, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewCreateSubnetTx(owner, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueTransferSubnetOwnershipTx( + subnetID ids.ID, + owner *secp256k1fx.OutputOwners, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewTransferSubnetOwnershipTx(subnetID, owner, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueImportTx( + sourceChainID ids.ID, + to *secp256k1fx.OutputOwners, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewImportTx(sourceChainID, to, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueExportTx( + chainID ids.ID, + outputs []*avax.TransferableOutput, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewExportTx(chainID, outputs, options...) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueTransformSubnetTx( + subnetID ids.ID, + assetID ids.ID, + initialSupply uint64, + maxSupply uint64, + minConsumptionRate uint64, + maxConsumptionRate uint64, + minValidatorStake uint64, + maxValidatorStake uint64, + minStakeDuration time.Duration, + maxStakeDuration time.Duration, + minDelegationFee uint32, + minDelegatorStake uint64, + maxValidatorWeightFactor byte, + uptimeRequirement uint32, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewTransformSubnetTx( + subnetID, + assetID, + initialSupply, + maxSupply, + minConsumptionRate, + maxConsumptionRate, + minValidatorStake, + maxValidatorStake, + minStakeDuration, + maxStakeDuration, + minDelegationFee, + minDelegatorStake, + maxValidatorWeightFactor, + uptimeRequirement, + options..., ) - return backend, builder, signer + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueAddPermissionlessValidatorTx( + vdr *txs.SubnetValidator, + signer vmsigner.Signer, + assetID ids.ID, + validationRewardsOwner *secp256k1fx.OutputOwners, + delegationRewardsOwner *secp256k1fx.OutputOwners, + shares uint32, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewAddPermissionlessValidatorTx( + vdr, + signer, + assetID, + validationRewardsOwner, + delegationRewardsOwner, + shares, + options..., + ) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueAddPermissionlessDelegatorTx( + vdr *txs.SubnetValidator, + assetID ids.ID, + rewardsOwner *secp256k1fx.OutputOwners, + options ...common.Option, +) (*txs.Tx, error) { + utx, err := w.Builder.NewAddPermissionlessDelegatorTx( + vdr, + assetID, + rewardsOwner, + options..., + ) + if err != nil { + return nil, err + } + return w.IssueUnsignedTx(utx, options...) +} + +func (w *Wallet) IssueUnsignedTx( + utx txs.UnsignedTx, + options ...common.Option, +) (*txs.Tx, error) { + ops := common.NewOptions(options) + ctx := ops.Context() + tx, err := psigner.SignUnsigned(ctx, w.Signer, utx) + if err != nil { + return nil, err + } + + return tx, w.IssueTx(tx, options...) +} + +func (w *Wallet) IssueTx( + tx *txs.Tx, + options ...common.Option, +) error { + ops := common.NewOptions(options) + if f := ops.PostIssuanceFunc(); f != nil { + txID := tx.ID() + f(txID) + } + ctx := ops.Context() + return w.Backend.AcceptTx(ctx, tx) } From 191d13d08852982df06a91f631c93f78ccd82130 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 14:46:43 -0400 Subject: [PATCH 047/114] wip --- wallet/chain/p/client.go | 55 ++++++++++++++++ wallet/chain/p/{ => wallet}/wallet.go | 62 +++++-------------- .../with_options.go} | 44 ++++++------- wallet/subnet/primary/wallet.go | 14 +++-- 4 files changed, 102 insertions(+), 73 deletions(-) create mode 100644 wallet/chain/p/client.go rename wallet/chain/p/{ => wallet}/wallet.go (95%) rename wallet/chain/p/{wallet_with_options.go => wallet/with_options.go} (82%) diff --git a/wallet/chain/p/client.go b/wallet/chain/p/client.go new file mode 100644 index 000000000000..47da38dcd792 --- /dev/null +++ b/wallet/chain/p/client.go @@ -0,0 +1,55 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package p + +import ( + "github.com/ava-labs/avalanchego/vms/platformvm" + "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/wallet/chain/p/backend" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" + "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" +) + +var _ wallet.Client = (*client)(nil) + +func NewClient( + c platformvm.Client, + b backend.Backend, +) wallet.Client { + return &client{ + client: c, + backend: b, + } +} + +type client struct { + client platformvm.Client + backend backend.Backend +} + +func (c *client) IssueTx( + tx *txs.Tx, + options ...common.Option, +) error { + ops := common.NewOptions(options) + ctx := ops.Context() + txID, err := c.client.IssueTx(ctx, tx.Bytes()) + if err != nil { + return err + } + + if f := ops.PostIssuanceFunc(); f != nil { + f(txID) + } + + if ops.AssumeDecided() { + return c.backend.AcceptTx(ctx, tx) + } + + if err := platformvm.AwaitTxAccepted(c.client, ctx, txID, ops.PollFrequency()); err != nil { + return err + } + + return c.backend.AcceptTx(ctx, tx) +} diff --git a/wallet/chain/p/wallet.go b/wallet/chain/p/wallet/wallet.go similarity index 95% rename from wallet/chain/p/wallet.go rename to wallet/chain/p/wallet/wallet.go index 3f0656e92377..a72b3d532bcc 100644 --- a/wallet/chain/p/wallet.go +++ b/wallet/chain/p/wallet/wallet.go @@ -1,15 +1,13 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package wallet import ( - "errors" "time" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/vms/components/avax" - "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/chain/p/backend" @@ -20,13 +18,19 @@ import ( walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) -var ( - ErrNotCommitted = errors.New("not committed") +var _ Wallet = (*wallet)(nil) - _ Wallet = (*wallet)(nil) -) +type Client interface { + // IssueTx issues the signed tx. + IssueTx( + tx *txs.Tx, + options ...common.Option, + ) error +} type Wallet interface { + Client + // Builder returns the builder that will be used to create the transactions. Builder() builder.Builder @@ -247,33 +251,27 @@ type Wallet interface { utx txs.UnsignedTx, options ...common.Option, ) (*txs.Tx, error) - - // IssueTx issues the signed tx. - IssueTx( - tx *txs.Tx, - options ...common.Option, - ) error } -func NewWallet( +func New( + client Client, builder builder.Builder, signer walletsigner.Signer, - client platformvm.Client, backend backend.Backend, ) Wallet { return &wallet{ - Backend: backend, + Client: client, + backend: backend, builder: builder, signer: signer, - client: client, } } type wallet struct { - backend.Backend + Client + backend backend.Backend builder builder.Builder signer walletsigner.Signer - client platformvm.Client } func (w *wallet) Builder() builder.Builder { @@ -500,29 +498,3 @@ func (w *wallet) IssueUnsignedTx( return tx, w.IssueTx(tx, options...) } - -func (w *wallet) IssueTx( - tx *txs.Tx, - options ...common.Option, -) error { - ops := common.NewOptions(options) - ctx := ops.Context() - txID, err := w.client.IssueTx(ctx, tx.Bytes()) - if err != nil { - return err - } - - if f := ops.PostIssuanceFunc(); f != nil { - f(txID) - } - - if ops.AssumeDecided() { - return w.Backend.AcceptTx(ctx, tx) - } - - if err := platformvm.AwaitTxAccepted(w.client, ctx, txID, ops.PollFrequency()); err != nil { - return err - } - - return w.Backend.AcceptTx(ctx, tx) -} diff --git a/wallet/chain/p/wallet_with_options.go b/wallet/chain/p/wallet/with_options.go similarity index 82% rename from wallet/chain/p/wallet_with_options.go rename to wallet/chain/p/wallet/with_options.go index 92965f2e4f1f..64b22050a953 100644 --- a/wallet/chain/p/wallet_with_options.go +++ b/wallet/chain/p/wallet/with_options.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package wallet import ( "time" @@ -17,35 +17,35 @@ import ( walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) -var _ Wallet = (*walletWithOptions)(nil) +var _ Wallet = (*withOptions)(nil) -func NewWalletWithOptions( +func WithOptions( wallet Wallet, options ...common.Option, ) Wallet { - return &walletWithOptions{ + return &withOptions{ wallet: wallet, options: options, } } -type walletWithOptions struct { +type withOptions struct { wallet Wallet options []common.Option } -func (w *walletWithOptions) Builder() builder.Builder { +func (w *withOptions) Builder() builder.Builder { return builder.NewWithOptions( w.wallet.Builder(), w.options..., ) } -func (w *walletWithOptions) Signer() walletsigner.Signer { +func (w *withOptions) Signer() walletsigner.Signer { return w.wallet.Signer() } -func (w *walletWithOptions) IssueBaseTx( +func (w *withOptions) IssueBaseTx( outputs []*avax.TransferableOutput, options ...common.Option, ) (*txs.Tx, error) { @@ -55,7 +55,7 @@ func (w *walletWithOptions) IssueBaseTx( ) } -func (w *walletWithOptions) IssueAddValidatorTx( +func (w *withOptions) IssueAddValidatorTx( vdr *txs.Validator, rewardsOwner *secp256k1fx.OutputOwners, shares uint32, @@ -69,7 +69,7 @@ func (w *walletWithOptions) IssueAddValidatorTx( ) } -func (w *walletWithOptions) IssueAddSubnetValidatorTx( +func (w *withOptions) IssueAddSubnetValidatorTx( vdr *txs.SubnetValidator, options ...common.Option, ) (*txs.Tx, error) { @@ -79,7 +79,7 @@ func (w *walletWithOptions) IssueAddSubnetValidatorTx( ) } -func (w *walletWithOptions) IssueRemoveSubnetValidatorTx( +func (w *withOptions) IssueRemoveSubnetValidatorTx( nodeID ids.NodeID, subnetID ids.ID, options ...common.Option, @@ -91,7 +91,7 @@ func (w *walletWithOptions) IssueRemoveSubnetValidatorTx( ) } -func (w *walletWithOptions) IssueAddDelegatorTx( +func (w *withOptions) IssueAddDelegatorTx( vdr *txs.Validator, rewardsOwner *secp256k1fx.OutputOwners, options ...common.Option, @@ -103,7 +103,7 @@ func (w *walletWithOptions) IssueAddDelegatorTx( ) } -func (w *walletWithOptions) IssueCreateChainTx( +func (w *withOptions) IssueCreateChainTx( subnetID ids.ID, genesis []byte, vmID ids.ID, @@ -121,7 +121,7 @@ func (w *walletWithOptions) IssueCreateChainTx( ) } -func (w *walletWithOptions) IssueCreateSubnetTx( +func (w *withOptions) IssueCreateSubnetTx( owner *secp256k1fx.OutputOwners, options ...common.Option, ) (*txs.Tx, error) { @@ -131,7 +131,7 @@ func (w *walletWithOptions) IssueCreateSubnetTx( ) } -func (w *walletWithOptions) IssueTransferSubnetOwnershipTx( +func (w *withOptions) IssueTransferSubnetOwnershipTx( subnetID ids.ID, owner *secp256k1fx.OutputOwners, options ...common.Option, @@ -143,7 +143,7 @@ func (w *walletWithOptions) IssueTransferSubnetOwnershipTx( ) } -func (w *walletWithOptions) IssueImportTx( +func (w *withOptions) IssueImportTx( sourceChainID ids.ID, to *secp256k1fx.OutputOwners, options ...common.Option, @@ -155,7 +155,7 @@ func (w *walletWithOptions) IssueImportTx( ) } -func (w *walletWithOptions) IssueExportTx( +func (w *withOptions) IssueExportTx( chainID ids.ID, outputs []*avax.TransferableOutput, options ...common.Option, @@ -167,7 +167,7 @@ func (w *walletWithOptions) IssueExportTx( ) } -func (w *walletWithOptions) IssueTransformSubnetTx( +func (w *withOptions) IssueTransformSubnetTx( subnetID ids.ID, assetID ids.ID, initialSupply uint64, @@ -203,7 +203,7 @@ func (w *walletWithOptions) IssueTransformSubnetTx( ) } -func (w *walletWithOptions) IssueAddPermissionlessValidatorTx( +func (w *withOptions) IssueAddPermissionlessValidatorTx( vdr *txs.SubnetValidator, signer vmsigner.Signer, assetID ids.ID, @@ -223,7 +223,7 @@ func (w *walletWithOptions) IssueAddPermissionlessValidatorTx( ) } -func (w *walletWithOptions) IssueAddPermissionlessDelegatorTx( +func (w *withOptions) IssueAddPermissionlessDelegatorTx( vdr *txs.SubnetValidator, assetID ids.ID, rewardsOwner *secp256k1fx.OutputOwners, @@ -237,7 +237,7 @@ func (w *walletWithOptions) IssueAddPermissionlessDelegatorTx( ) } -func (w *walletWithOptions) IssueUnsignedTx( +func (w *withOptions) IssueUnsignedTx( utx txs.UnsignedTx, options ...common.Option, ) (*txs.Tx, error) { @@ -247,7 +247,7 @@ func (w *walletWithOptions) IssueUnsignedTx( ) } -func (w *walletWithOptions) IssueTx( +func (w *withOptions) IssueTx( tx *txs.Tx, options ...common.Option, ) error { diff --git a/wallet/subnet/primary/wallet.go b/wallet/subnet/primary/wallet.go index 3725f6595f95..acbe125707f7 100644 --- a/wallet/subnet/primary/wallet.go +++ b/wallet/subnet/primary/wallet.go @@ -18,6 +18,7 @@ import ( pbackend "github.com/ava-labs/avalanchego/wallet/chain/p/backend" pbuilder "github.com/ava-labs/avalanchego/wallet/chain/p/builder" psigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" + pwallet "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" xbuilder "github.com/ava-labs/avalanchego/wallet/chain/x/builder" xsigner "github.com/ava-labs/avalanchego/wallet/chain/x/signer" ) @@ -26,18 +27,18 @@ var _ Wallet = (*wallet)(nil) // Wallet provides chain wallets for the primary network. type Wallet interface { - P() p.Wallet + P() pwallet.Wallet X() x.Wallet C() c.Wallet } type wallet struct { - p p.Wallet + p pwallet.Wallet x x.Wallet c c.Wallet } -func (w *wallet) P() p.Wallet { +func (w *wallet) P() pwallet.Wallet { return w.p } @@ -50,7 +51,7 @@ func (w *wallet) C() c.Wallet { } // Creates a new default wallet -func NewWallet(p p.Wallet, x x.Wallet, c c.Wallet) Wallet { +func NewWallet(p pwallet.Wallet, x x.Wallet, c c.Wallet) Wallet { return &wallet{ p: p, x: x, @@ -61,7 +62,7 @@ func NewWallet(p p.Wallet, x x.Wallet, c c.Wallet) Wallet { // Creates a Wallet with the given set of options func NewWalletWithOptions(w Wallet, options ...common.Option) Wallet { return NewWallet( - p.NewWalletWithOptions(w.P(), options...), + pwallet.WithOptions(w.P(), options...), x.NewWalletWithOptions(w.X(), options...), c.NewWalletWithOptions(w.C(), options...), ) @@ -107,6 +108,7 @@ func MakeWallet(ctx context.Context, config *WalletConfig) (Wallet, error) { } pUTXOs := common.NewChainUTXOs(constants.PlatformChainID, avaxState.UTXOs) pBackend := pbackend.New(avaxState.PCTX, pUTXOs, subnetOwners) + pWalletClient := p.NewClient(avaxState.PClient, pBackend) pBuilder := pbuilder.New(avaxAddrs, avaxState.PCTX, pBackend) pSigner := psigner.New(config.AVAXKeychain, pBackend) @@ -123,7 +125,7 @@ func MakeWallet(ctx context.Context, config *WalletConfig) (Wallet, error) { cSigner := c.NewSigner(config.AVAXKeychain, config.EthKeychain, cBackend) return NewWallet( - p.NewWallet(pBuilder, pSigner, avaxState.PClient, pBackend), + pwallet.New(pWalletClient, pBuilder, pSigner, pBackend), x.NewWallet(xBuilder, xSigner, avaxState.XClient, xBackend), c.NewWallet(cBuilder, cSigner, avaxState.CClient, ethState.Client, cBackend), ), nil From 50c91091233a86f1861e0f4d0d718723cd2c9d57 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 14:52:19 -0400 Subject: [PATCH 048/114] reduce diff --- .../block/executor/verifier_test.go | 3 +- vms/platformvm/txs/txstest/wallet.go | 246 +----------------- 2 files changed, 16 insertions(+), 233 deletions(-) diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index 081cb606687b..56c47ad855ea 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -40,6 +40,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" @@ -112,7 +113,7 @@ func newTestVerifier(t testing.TB, s state.State) *verifier { func newTestWallet( t testing.TB, v *verifier, -) *txstest.Wallet { +) wallet.Wallet { ctx := &builder.Context{ NetworkID: v.ctx.NetworkID, AVAXAssetID: v.ctx.AVAXAssetID, diff --git a/vms/platformvm/txs/txstest/wallet.go b/vms/platformvm/txs/txstest/wallet.go index 658490f99b99..375d3ad76ded 100644 --- a/vms/platformvm/txs/txstest/wallet.go +++ b/vms/platformvm/txs/txstest/wallet.go @@ -7,7 +7,6 @@ import ( "context" "math" "testing" - "time" "github.com/stretchr/testify/require" @@ -21,18 +20,11 @@ import ( "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/chain/p/backend" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + "github.com/ava-labs/avalanchego/wallet/chain/p/signer" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" - - vmsigner "github.com/ava-labs/avalanchego/vms/platformvm/signer" - psigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) -type Wallet struct { - Backend backend.Backend - Builder builder.Builder - Signer psigner.Signer -} - func NewWallet( t testing.TB, state state.State, @@ -41,7 +33,7 @@ func NewWallet( kc *secp256k1fx.Keychain, subnetIDs []ids.ID, chainIDs []ids.ID, -) *Wallet { +) wallet.Wallet { var ( require = require.New(t) addrs = kc.Addresses() @@ -94,238 +86,28 @@ func NewWallet( common.NewChainUTXOs(constants.PlatformChainID, utxos), owners, ) - return &Wallet{ - Backend: backend, - Builder: builder.New( + return wallet.New( + &client{ + backend: backend, + }, + builder.New( addrs, ctx, backend, ), - Signer: psigner.New( + signer.New( kc, backend, ), - } -} - -func (w *Wallet) IssueBaseTx( - outputs []*avax.TransferableOutput, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewBaseTx(outputs, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueAddValidatorTx( - vdr *txs.Validator, - rewardsOwner *secp256k1fx.OutputOwners, - shares uint32, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewAddValidatorTx(vdr, rewardsOwner, shares, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueAddSubnetValidatorTx( - vdr *txs.SubnetValidator, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewAddSubnetValidatorTx(vdr, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueRemoveSubnetValidatorTx( - nodeID ids.NodeID, - subnetID ids.ID, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewRemoveSubnetValidatorTx(nodeID, subnetID, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueAddDelegatorTx( - vdr *txs.Validator, - rewardsOwner *secp256k1fx.OutputOwners, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewAddDelegatorTx(vdr, rewardsOwner, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueCreateChainTx( - subnetID ids.ID, - genesis []byte, - vmID ids.ID, - fxIDs []ids.ID, - chainName string, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewCreateChainTx(subnetID, genesis, vmID, fxIDs, chainName, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueCreateSubnetTx( - owner *secp256k1fx.OutputOwners, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewCreateSubnetTx(owner, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueTransferSubnetOwnershipTx( - subnetID ids.ID, - owner *secp256k1fx.OutputOwners, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewTransferSubnetOwnershipTx(subnetID, owner, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueImportTx( - sourceChainID ids.ID, - to *secp256k1fx.OutputOwners, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewImportTx(sourceChainID, to, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueExportTx( - chainID ids.ID, - outputs []*avax.TransferableOutput, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewExportTx(chainID, outputs, options...) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueTransformSubnetTx( - subnetID ids.ID, - assetID ids.ID, - initialSupply uint64, - maxSupply uint64, - minConsumptionRate uint64, - maxConsumptionRate uint64, - minValidatorStake uint64, - maxValidatorStake uint64, - minStakeDuration time.Duration, - maxStakeDuration time.Duration, - minDelegationFee uint32, - minDelegatorStake uint64, - maxValidatorWeightFactor byte, - uptimeRequirement uint32, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewTransformSubnetTx( - subnetID, - assetID, - initialSupply, - maxSupply, - minConsumptionRate, - maxConsumptionRate, - minValidatorStake, - maxValidatorStake, - minStakeDuration, - maxStakeDuration, - minDelegationFee, - minDelegatorStake, - maxValidatorWeightFactor, - uptimeRequirement, - options..., + backend, ) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) } -func (w *Wallet) IssueAddPermissionlessValidatorTx( - vdr *txs.SubnetValidator, - signer vmsigner.Signer, - assetID ids.ID, - validationRewardsOwner *secp256k1fx.OutputOwners, - delegationRewardsOwner *secp256k1fx.OutputOwners, - shares uint32, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewAddPermissionlessValidatorTx( - vdr, - signer, - assetID, - validationRewardsOwner, - delegationRewardsOwner, - shares, - options..., - ) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueAddPermissionlessDelegatorTx( - vdr *txs.SubnetValidator, - assetID ids.ID, - rewardsOwner *secp256k1fx.OutputOwners, - options ...common.Option, -) (*txs.Tx, error) { - utx, err := w.Builder.NewAddPermissionlessDelegatorTx( - vdr, - assetID, - rewardsOwner, - options..., - ) - if err != nil { - return nil, err - } - return w.IssueUnsignedTx(utx, options...) -} - -func (w *Wallet) IssueUnsignedTx( - utx txs.UnsignedTx, - options ...common.Option, -) (*txs.Tx, error) { - ops := common.NewOptions(options) - ctx := ops.Context() - tx, err := psigner.SignUnsigned(ctx, w.Signer, utx) - if err != nil { - return nil, err - } - - return tx, w.IssueTx(tx, options...) +type client struct { + backend backend.Backend } -func (w *Wallet) IssueTx( +func (c *client) IssueTx( tx *txs.Tx, options ...common.Option, ) error { @@ -335,5 +117,5 @@ func (w *Wallet) IssueTx( f(txID) } ctx := ops.Context() - return w.Backend.AcceptTx(ctx, tx) + return c.backend.AcceptTx(ctx, tx) } From a50f75ad2eab53ffa29b8a459c5f4a4d0a3d3fef Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 15:38:56 -0400 Subject: [PATCH 049/114] wip --- .../block/executor/verifier_test.go | 42 ++++--------------- .../txs/executor/create_chain_test.go | 24 +++++++---- .../txs/executor/create_subnet_test.go | 23 +++++----- vms/platformvm/txs/txstest/builder.go | 16 +++---- vms/platformvm/txs/txstest/context.go | 40 +++++++++++------- vms/platformvm/txs/txstest/wallet.go | 14 ++++--- 6 files changed, 79 insertions(+), 80 deletions(-) diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index 56c47ad855ea..d183d8165df7 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -39,8 +39,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" @@ -110,36 +108,6 @@ func newTestVerifier(t testing.TB, s state.State) *verifier { } } -func newTestWallet( - t testing.TB, - v *verifier, -) wallet.Wallet { - ctx := &builder.Context{ - NetworkID: v.ctx.NetworkID, - AVAXAssetID: v.ctx.AVAXAssetID, - } - if !v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(v.state.GetTimestamp()) { - ctx.StaticFeeConfig = v.txExecutorBackend.Config.StaticFeeConfig - } else { - ctx.ComplexityWeights = v.txExecutorBackend.Config.DynamicFeeConfig.Weights - ctx.GasPrice = 10 * feecomponent.CalculateGasPrice( - v.txExecutorBackend.Config.DynamicFeeConfig.MinGasPrice, - v.state.GetFeeState().Excess, - v.txExecutorBackend.Config.DynamicFeeConfig.ExcessConversionConstant, - ) - } - - return txstest.NewWallet( - t, - v.state, - v.ctx.SharedMemory, - ctx, - secp256k1fx.NewKeychain(genesis.EWOQKey), - nil, // subnetIDs - nil, // chainIDs - ) -} - func TestVerifierVisitProposalBlock(t *testing.T) { require := require.New(t) ctrl := gomock.NewController(t) @@ -1154,7 +1122,15 @@ func TestVerifierVisitBanffAbortBlockUnexpectedParentState(t *testing.T) { func TestBlockExecutionWithComplexity(t *testing.T) { s := statetest.New(t, memdb.New()) verifier := newTestVerifier(t, s) - wallet := newTestWallet(t, verifier) + wallet := txstest.NewWallet( + t, + verifier.ctx, + verifier.txExecutorBackend.Config, + s, + secp256k1fx.NewKeychain(genesis.EWOQKey), + nil, // subnetIDs + nil, // chainIDs + ) baseTx0, err := wallet.IssueBaseTx([]*avax.TransferableOutput{}) require.NoError(t, err) diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go index a1ad4c81e186..1d3fe8a7eafb 100644 --- a/vms/platformvm/txs/executor/create_chain_test.go +++ b/vms/platformvm/txs/executor/create_chain_test.go @@ -220,21 +220,27 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { env.state.SetTimestamp(test.time) // to duly set fee - cfg := *env.config - - cfg.StaticFeeConfig.CreateBlockchainTxFee = test.fee - factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) - builder, signer := factory.NewWallet(preFundedKeys...) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + config := *env.config + config.StaticFeeConfig.CreateBlockchainTxFee = test.fee + + subnetID := testSubnet1.ID() + wallet := txstest.NewWallet( + t, + env.ctx, + &config, + env.state, + secp256k1fx.NewKeychain(preFundedKeys...), + []ids.ID{subnetID}, + nil, + ) + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, ids.GenerateTestID(), nil, "", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/create_subnet_test.go b/vms/platformvm/txs/executor/create_subnet_test.go index a991bda7de0e..00d0c7daf6ec 100644 --- a/vms/platformvm/txs/executor/create_subnet_test.go +++ b/vms/platformvm/txs/executor/create_subnet_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "testing" "time" @@ -18,8 +17,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestCreateSubnetTxAP3FeeChange(t *testing.T) { @@ -65,16 +62,22 @@ func TestCreateSubnetTxAP3FeeChange(t *testing.T) { addrs.Add(key.Address()) } - cfg := *env.config - cfg.StaticFeeConfig.CreateSubnetTxFee = test.fee - factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) - builder, signer := factory.NewWallet(preFundedKeys...) - utx, err := builder.NewCreateSubnetTx( + config := *env.config + config.StaticFeeConfig.CreateSubnetTxFee = test.fee + + wallet := txstest.NewWallet( + t, + env.ctx, + &config, + env.state, + secp256k1fx.NewKeychain(preFundedKeys...), + nil, + nil, + ) + tx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{}, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/txstest/builder.go b/vms/platformvm/txs/txstest/builder.go index 532720be981f..772db8ebc323 100644 --- a/vms/platformvm/txs/txstest/builder.go +++ b/vms/platformvm/txs/txstest/builder.go @@ -15,20 +15,20 @@ import ( func NewWalletFactory( ctx *snow.Context, - cfg *config.Config, + config *config.Config, state state.State, ) *WalletFactory { return &WalletFactory{ - ctx: ctx, - cfg: cfg, - state: state, + ctx: ctx, + config: config, + state: state, } } type WalletFactory struct { - ctx *snow.Context - cfg *config.Config - state state.State + ctx *snow.Context + config *config.Config + state state.State } func (w *WalletFactory) NewWallet(keys ...*secp256k1.PrivateKey) (builder.Builder, signer.Signer) { @@ -36,7 +36,7 @@ func (w *WalletFactory) NewWallet(keys ...*secp256k1.PrivateKey) (builder.Builde kc = secp256k1fx.NewKeychain(keys...) addrs = kc.Addresses() backend = newBackend(addrs, w.state, w.ctx.SharedMemory) - context = newContext(w.ctx, w.cfg, w.state.GetTimestamp()) + context = newContext(w.ctx, w.config, w.state) ) return builder.New(addrs, context, backend), signer.New(kc, backend) diff --git a/vms/platformvm/txs/txstest/context.go b/vms/platformvm/txs/txstest/context.go index 5f453429c226..77a8d98bc221 100644 --- a/vms/platformvm/txs/txstest/context.go +++ b/vms/platformvm/txs/txstest/context.go @@ -4,27 +4,39 @@ package txstest import ( - "time" - "github.com/ava-labs/avalanchego/snow" + "github.com/ava-labs/avalanchego/vms/components/fee" "github.com/ava-labs/avalanchego/vms/platformvm/config" + "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" ) func newContext( ctx *snow.Context, - cfg *config.Config, - timestamp time.Time, + config *config.Config, + state state.State, ) *builder.Context { - feeConfig := cfg.StaticFeeConfig - if !cfg.UpgradeConfig.IsApricotPhase3Activated(timestamp) { - feeConfig.CreateSubnetTxFee = cfg.CreateAssetTxFee - feeConfig.CreateBlockchainTxFee = cfg.CreateAssetTxFee - } - - return &builder.Context{ - NetworkID: ctx.NetworkID, - AVAXAssetID: ctx.AVAXAssetID, - StaticFeeConfig: feeConfig, + var ( + timestamp = state.GetTimestamp() + builderContext = &builder.Context{ + NetworkID: ctx.NetworkID, + AVAXAssetID: ctx.AVAXAssetID, + } + ) + switch { + case config.UpgradeConfig.IsEtnaActivated(timestamp): + builderContext.ComplexityWeights = config.DynamicFeeConfig.Weights + builderContext.GasPrice = 10 * fee.CalculateGasPrice( + config.DynamicFeeConfig.MinGasPrice, + state.GetFeeState().Excess, + config.DynamicFeeConfig.ExcessConversionConstant, + ) + case config.UpgradeConfig.IsApricotPhase3Activated(timestamp): + builderContext.StaticFeeConfig = config.StaticFeeConfig + default: + builderContext.StaticFeeConfig = config.StaticFeeConfig + builderContext.StaticFeeConfig.CreateSubnetTxFee = config.CreateAssetTxFee + builderContext.StaticFeeConfig.CreateBlockchainTxFee = config.CreateAssetTxFee } + return builderContext } diff --git a/vms/platformvm/txs/txstest/wallet.go b/vms/platformvm/txs/txstest/wallet.go index 375d3ad76ded..2cfc20aa1aec 100644 --- a/vms/platformvm/txs/txstest/wallet.go +++ b/vms/platformvm/txs/txstest/wallet.go @@ -10,10 +10,11 @@ import ( "github.com/stretchr/testify/require" - "github.com/ava-labs/avalanchego/chains/atomic" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/snow" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/vms/components/avax" + "github.com/ava-labs/avalanchego/vms/platformvm/config" "github.com/ava-labs/avalanchego/vms/platformvm/fx" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/txs" @@ -27,9 +28,9 @@ import ( func NewWallet( t testing.TB, + ctx *snow.Context, + config *config.Config, state state.State, - sharedMemory atomic.SharedMemory, - ctx *builder.Context, kc *secp256k1fx.Keychain, subnetIDs []ids.ID, chainIDs []ids.ID, @@ -54,7 +55,7 @@ func NewWallet( for _, chainID := range chainIDs { remoteChainUTXOs, _, _, err := avax.GetAtomicUTXOs( - sharedMemory, + ctx.SharedMemory, txs.Codec, chainID, addrs, @@ -81,8 +82,9 @@ func NewWallet( owners[subnetID] = owner } + builderContext := newContext(ctx, config, state) backend := backend.New( - ctx, + builderContext, common.NewChainUTXOs(constants.PlatformChainID, utxos), owners, ) @@ -92,7 +94,7 @@ func NewWallet( }, builder.New( addrs, - ctx, + builderContext, backend, ), signer.New( From 77664c8313b66ee518f76a9eeebdfc61d56db5b6 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:00:39 -0400 Subject: [PATCH 050/114] Allow P-chain wallet to be used by the platformvm --- wallet/chain/p/builder_test.go | 23 +++---- wallet/chain/p/client.go | 60 +++++++++++++++++++ wallet/chain/p/{ => wallet}/backend.go | 2 +- .../chain/p/{ => wallet}/backend_visitor.go | 0 wallet/chain/p/{ => wallet}/wallet.go | 56 +++++------------ .../p/{ => wallet}/wallet_with_options.go | 44 +++++++------- .../examples/get-p-chain-balance/main.go | 4 +- wallet/subnet/primary/wallet.go | 16 ++--- 8 files changed, 121 insertions(+), 84 deletions(-) create mode 100644 wallet/chain/p/client.go rename wallet/chain/p/{ => wallet}/backend.go (99%) rename wallet/chain/p/{ => wallet}/backend_visitor.go (100%) rename wallet/chain/p/{ => wallet}/wallet.go (95%) rename wallet/chain/p/{ => wallet}/wallet_with_options.go (82%) diff --git a/wallet/chain/p/builder_test.go b/wallet/chain/p/builder_test.go index 6885a3b4fc9e..69168e463b2e 100644 --- a/wallet/chain/p/builder_test.go +++ b/wallet/chain/p/builder_test.go @@ -25,6 +25,7 @@ import ( "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/vms/types" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common/utxotest" @@ -174,7 +175,7 @@ func TestBaseTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = wallet.NewBackend(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr), e.context, backend) ) @@ -214,7 +215,7 @@ func TestAddSubnetValidatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = wallet.NewBackend(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -246,7 +247,7 @@ func TestRemoveSubnetValidatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = wallet.NewBackend(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -287,7 +288,7 @@ func TestCreateChainTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = wallet.NewBackend(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -327,7 +328,7 @@ func TestCreateSubnetTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = wallet.NewBackend(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -359,7 +360,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = wallet.NewBackend(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -399,7 +400,7 @@ func TestImportTx(t *testing.T) { constants.PlatformChainID: utxos, sourceChainID: importedUTXOs, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = wallet.NewBackend(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr), e.context, backend) ) @@ -436,7 +437,7 @@ func TestExportTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = wallet.NewBackend(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr), e.context, backend) ) @@ -486,7 +487,7 @@ func TestTransformSubnetTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, subnetOwners) + backend = wallet.NewBackend(e.context, chainUTXOs, subnetOwners) builder = builder.New(set.Of(utxoAddr, subnetAuthAddr), e.context, backend) ) @@ -578,7 +579,7 @@ func TestAddPermissionlessValidatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = wallet.NewBackend(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr, rewardAddr), e.context, backend) ) @@ -631,7 +632,7 @@ func TestAddPermissionlessDelegatorTx(t *testing.T) { chainUTXOs = utxotest.NewDeterministicChainUTXOs(t, map[ids.ID][]*avax.UTXO{ constants.PlatformChainID: utxos, }) - backend = NewBackend(e.context, chainUTXOs, nil) + backend = wallet.NewBackend(e.context, chainUTXOs, nil) builder = builder.New(set.Of(utxoAddr, rewardAddr), e.context, backend) ) diff --git a/wallet/chain/p/client.go b/wallet/chain/p/client.go new file mode 100644 index 000000000000..190bfbddf281 --- /dev/null +++ b/wallet/chain/p/client.go @@ -0,0 +1,60 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package p + +import ( + "errors" + + "github.com/ava-labs/avalanchego/vms/platformvm" + "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" + "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" +) + +var ( + ErrNotCommitted = errors.New("not committed") + + _ wallet.Client = (*client)(nil) +) + +func NewClient( + c platformvm.Client, + b wallet.Backend, +) wallet.Client { + return &client{ + client: c, + backend: b, + } +} + +type client struct { + client platformvm.Client + backend wallet.Backend +} + +func (c *client) IssueTx( + tx *txs.Tx, + options ...common.Option, +) error { + ops := common.NewOptions(options) + ctx := ops.Context() + txID, err := c.client.IssueTx(ctx, tx.Bytes()) + if err != nil { + return err + } + + if f := ops.PostIssuanceFunc(); f != nil { + f(txID) + } + + if ops.AssumeDecided() { + return c.backend.AcceptTx(ctx, tx) + } + + if err := platformvm.AwaitTxAccepted(c.client, ctx, txID, ops.PollFrequency()); err != nil { + return err + } + + return c.backend.AcceptTx(ctx, tx) +} diff --git a/wallet/chain/p/backend.go b/wallet/chain/p/wallet/backend.go similarity index 99% rename from wallet/chain/p/backend.go rename to wallet/chain/p/wallet/backend.go index 8a1cd6b7806c..f46902fa8a51 100644 --- a/wallet/chain/p/backend.go +++ b/wallet/chain/p/wallet/backend.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package wallet import ( "context" diff --git a/wallet/chain/p/backend_visitor.go b/wallet/chain/p/wallet/backend_visitor.go similarity index 100% rename from wallet/chain/p/backend_visitor.go rename to wallet/chain/p/wallet/backend_visitor.go diff --git a/wallet/chain/p/wallet.go b/wallet/chain/p/wallet/wallet.go similarity index 95% rename from wallet/chain/p/wallet.go rename to wallet/chain/p/wallet/wallet.go index 631553431ef7..1892defe505d 100644 --- a/wallet/chain/p/wallet.go +++ b/wallet/chain/p/wallet/wallet.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package wallet import ( "errors" @@ -9,7 +9,6 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/vms/components/avax" - "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" @@ -25,7 +24,17 @@ var ( _ Wallet = (*wallet)(nil) ) +type Client interface { + // IssueTx issues the signed tx. + IssueTx( + tx *txs.Tx, + options ...common.Option, + ) error +} + type Wallet interface { + Client + // Builder returns the builder that will be used to create the transactions. Builder() builder.Builder @@ -246,33 +255,24 @@ type Wallet interface { utx txs.UnsignedTx, options ...common.Option, ) (*txs.Tx, error) - - // IssueTx issues the signed tx. - IssueTx( - tx *txs.Tx, - options ...common.Option, - ) error } -func NewWallet( +func New( + client Client, builder builder.Builder, signer walletsigner.Signer, - client platformvm.Client, - backend Backend, ) Wallet { return &wallet{ - Backend: backend, + Client: client, builder: builder, signer: signer, - client: client, } } type wallet struct { - Backend + Client builder builder.Builder signer walletsigner.Signer - client platformvm.Client } func (w *wallet) Builder() builder.Builder { @@ -499,29 +499,3 @@ func (w *wallet) IssueUnsignedTx( return tx, w.IssueTx(tx, options...) } - -func (w *wallet) IssueTx( - tx *txs.Tx, - options ...common.Option, -) error { - ops := common.NewOptions(options) - ctx := ops.Context() - txID, err := w.client.IssueTx(ctx, tx.Bytes()) - if err != nil { - return err - } - - if f := ops.PostIssuanceFunc(); f != nil { - f(txID) - } - - if ops.AssumeDecided() { - return w.Backend.AcceptTx(ctx, tx) - } - - if err := platformvm.AwaitTxAccepted(w.client, ctx, txID, ops.PollFrequency()); err != nil { - return err - } - - return w.Backend.AcceptTx(ctx, tx) -} diff --git a/wallet/chain/p/wallet_with_options.go b/wallet/chain/p/wallet/wallet_with_options.go similarity index 82% rename from wallet/chain/p/wallet_with_options.go rename to wallet/chain/p/wallet/wallet_with_options.go index 92965f2e4f1f..64b22050a953 100644 --- a/wallet/chain/p/wallet_with_options.go +++ b/wallet/chain/p/wallet/wallet_with_options.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package wallet import ( "time" @@ -17,35 +17,35 @@ import ( walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) -var _ Wallet = (*walletWithOptions)(nil) +var _ Wallet = (*withOptions)(nil) -func NewWalletWithOptions( +func WithOptions( wallet Wallet, options ...common.Option, ) Wallet { - return &walletWithOptions{ + return &withOptions{ wallet: wallet, options: options, } } -type walletWithOptions struct { +type withOptions struct { wallet Wallet options []common.Option } -func (w *walletWithOptions) Builder() builder.Builder { +func (w *withOptions) Builder() builder.Builder { return builder.NewWithOptions( w.wallet.Builder(), w.options..., ) } -func (w *walletWithOptions) Signer() walletsigner.Signer { +func (w *withOptions) Signer() walletsigner.Signer { return w.wallet.Signer() } -func (w *walletWithOptions) IssueBaseTx( +func (w *withOptions) IssueBaseTx( outputs []*avax.TransferableOutput, options ...common.Option, ) (*txs.Tx, error) { @@ -55,7 +55,7 @@ func (w *walletWithOptions) IssueBaseTx( ) } -func (w *walletWithOptions) IssueAddValidatorTx( +func (w *withOptions) IssueAddValidatorTx( vdr *txs.Validator, rewardsOwner *secp256k1fx.OutputOwners, shares uint32, @@ -69,7 +69,7 @@ func (w *walletWithOptions) IssueAddValidatorTx( ) } -func (w *walletWithOptions) IssueAddSubnetValidatorTx( +func (w *withOptions) IssueAddSubnetValidatorTx( vdr *txs.SubnetValidator, options ...common.Option, ) (*txs.Tx, error) { @@ -79,7 +79,7 @@ func (w *walletWithOptions) IssueAddSubnetValidatorTx( ) } -func (w *walletWithOptions) IssueRemoveSubnetValidatorTx( +func (w *withOptions) IssueRemoveSubnetValidatorTx( nodeID ids.NodeID, subnetID ids.ID, options ...common.Option, @@ -91,7 +91,7 @@ func (w *walletWithOptions) IssueRemoveSubnetValidatorTx( ) } -func (w *walletWithOptions) IssueAddDelegatorTx( +func (w *withOptions) IssueAddDelegatorTx( vdr *txs.Validator, rewardsOwner *secp256k1fx.OutputOwners, options ...common.Option, @@ -103,7 +103,7 @@ func (w *walletWithOptions) IssueAddDelegatorTx( ) } -func (w *walletWithOptions) IssueCreateChainTx( +func (w *withOptions) IssueCreateChainTx( subnetID ids.ID, genesis []byte, vmID ids.ID, @@ -121,7 +121,7 @@ func (w *walletWithOptions) IssueCreateChainTx( ) } -func (w *walletWithOptions) IssueCreateSubnetTx( +func (w *withOptions) IssueCreateSubnetTx( owner *secp256k1fx.OutputOwners, options ...common.Option, ) (*txs.Tx, error) { @@ -131,7 +131,7 @@ func (w *walletWithOptions) IssueCreateSubnetTx( ) } -func (w *walletWithOptions) IssueTransferSubnetOwnershipTx( +func (w *withOptions) IssueTransferSubnetOwnershipTx( subnetID ids.ID, owner *secp256k1fx.OutputOwners, options ...common.Option, @@ -143,7 +143,7 @@ func (w *walletWithOptions) IssueTransferSubnetOwnershipTx( ) } -func (w *walletWithOptions) IssueImportTx( +func (w *withOptions) IssueImportTx( sourceChainID ids.ID, to *secp256k1fx.OutputOwners, options ...common.Option, @@ -155,7 +155,7 @@ func (w *walletWithOptions) IssueImportTx( ) } -func (w *walletWithOptions) IssueExportTx( +func (w *withOptions) IssueExportTx( chainID ids.ID, outputs []*avax.TransferableOutput, options ...common.Option, @@ -167,7 +167,7 @@ func (w *walletWithOptions) IssueExportTx( ) } -func (w *walletWithOptions) IssueTransformSubnetTx( +func (w *withOptions) IssueTransformSubnetTx( subnetID ids.ID, assetID ids.ID, initialSupply uint64, @@ -203,7 +203,7 @@ func (w *walletWithOptions) IssueTransformSubnetTx( ) } -func (w *walletWithOptions) IssueAddPermissionlessValidatorTx( +func (w *withOptions) IssueAddPermissionlessValidatorTx( vdr *txs.SubnetValidator, signer vmsigner.Signer, assetID ids.ID, @@ -223,7 +223,7 @@ func (w *walletWithOptions) IssueAddPermissionlessValidatorTx( ) } -func (w *walletWithOptions) IssueAddPermissionlessDelegatorTx( +func (w *withOptions) IssueAddPermissionlessDelegatorTx( vdr *txs.SubnetValidator, assetID ids.ID, rewardsOwner *secp256k1fx.OutputOwners, @@ -237,7 +237,7 @@ func (w *walletWithOptions) IssueAddPermissionlessDelegatorTx( ) } -func (w *walletWithOptions) IssueUnsignedTx( +func (w *withOptions) IssueUnsignedTx( utx txs.UnsignedTx, options ...common.Option, ) (*txs.Tx, error) { @@ -247,7 +247,7 @@ func (w *walletWithOptions) IssueUnsignedTx( ) } -func (w *walletWithOptions) IssueTx( +func (w *withOptions) IssueTx( tx *txs.Tx, options ...common.Option, ) error { diff --git a/wallet/subnet/primary/examples/get-p-chain-balance/main.go b/wallet/subnet/primary/examples/get-p-chain-balance/main.go index e190247515bf..a23c4c9b8e81 100644 --- a/wallet/subnet/primary/examples/get-p-chain-balance/main.go +++ b/wallet/subnet/primary/examples/get-p-chain-balance/main.go @@ -11,8 +11,8 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/formatting/address" "github.com/ava-labs/avalanchego/utils/set" - "github.com/ava-labs/avalanchego/wallet/chain/p" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" "github.com/ava-labs/avalanchego/wallet/subnet/primary" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) @@ -38,7 +38,7 @@ func main() { log.Printf("fetched state of %s in %s\n", addrStr, time.Since(fetchStartTime)) pUTXOs := common.NewChainUTXOs(constants.PlatformChainID, state.UTXOs) - pBackend := p.NewBackend(state.PCTX, pUTXOs, nil) + pBackend := wallet.NewBackend(state.PCTX, pUTXOs, nil) pBuilder := builder.New(addresses, state.PCTX, pBackend) currentBalances, err := pBuilder.GetBalance() diff --git a/wallet/subnet/primary/wallet.go b/wallet/subnet/primary/wallet.go index d2c9f4d45050..2b35c944c39c 100644 --- a/wallet/subnet/primary/wallet.go +++ b/wallet/subnet/primary/wallet.go @@ -17,6 +17,7 @@ import ( pbuilder "github.com/ava-labs/avalanchego/wallet/chain/p/builder" psigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" + pwallet "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" xbuilder "github.com/ava-labs/avalanchego/wallet/chain/x/builder" xsigner "github.com/ava-labs/avalanchego/wallet/chain/x/signer" ) @@ -25,18 +26,18 @@ var _ Wallet = (*wallet)(nil) // Wallet provides chain wallets for the primary network. type Wallet interface { - P() p.Wallet + P() pwallet.Wallet X() x.Wallet C() c.Wallet } type wallet struct { - p p.Wallet + p pwallet.Wallet x x.Wallet c c.Wallet } -func (w *wallet) P() p.Wallet { +func (w *wallet) P() pwallet.Wallet { return w.p } @@ -49,7 +50,7 @@ func (w *wallet) C() c.Wallet { } // Creates a new default wallet -func NewWallet(p p.Wallet, x x.Wallet, c c.Wallet) Wallet { +func NewWallet(p pwallet.Wallet, x x.Wallet, c c.Wallet) Wallet { return &wallet{ p: p, x: x, @@ -60,7 +61,7 @@ func NewWallet(p p.Wallet, x x.Wallet, c c.Wallet) Wallet { // Creates a Wallet with the given set of options func NewWalletWithOptions(w Wallet, options ...common.Option) Wallet { return NewWallet( - p.NewWalletWithOptions(w.P(), options...), + pwallet.WithOptions(w.P(), options...), x.NewWalletWithOptions(w.X(), options...), c.NewWalletWithOptions(w.C(), options...), ) @@ -105,7 +106,8 @@ func MakeWallet(ctx context.Context, config *WalletConfig) (Wallet, error) { return nil, err } pUTXOs := common.NewChainUTXOs(constants.PlatformChainID, avaxState.UTXOs) - pBackend := p.NewBackend(avaxState.PCTX, pUTXOs, subnetOwners) + pBackend := pwallet.NewBackend(avaxState.PCTX, pUTXOs, subnetOwners) + pClient := p.NewClient(avaxState.PClient, pBackend) pBuilder := pbuilder.New(avaxAddrs, avaxState.PCTX, pBackend) pSigner := psigner.New(config.AVAXKeychain, pBackend) @@ -122,7 +124,7 @@ func MakeWallet(ctx context.Context, config *WalletConfig) (Wallet, error) { cSigner := c.NewSigner(config.AVAXKeychain, config.EthKeychain, cBackend) return NewWallet( - p.NewWallet(pBuilder, pSigner, avaxState.PClient, pBackend), + pwallet.New(pClient, pBuilder, pSigner), x.NewWallet(xBuilder, xSigner, avaxState.XClient, xBackend), c.NewWallet(cBuilder, cSigner, avaxState.CClient, ethState.Client, cBackend), ), nil From eefd6c3053c95899b8180d286f53b285234555a2 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:05:15 -0400 Subject: [PATCH 051/114] save --- wallet/chain/p/wallet/backend_visitor.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wallet/chain/p/wallet/backend_visitor.go b/wallet/chain/p/wallet/backend_visitor.go index c7cec9544da1..61dc3e231da7 100644 --- a/wallet/chain/p/wallet/backend_visitor.go +++ b/wallet/chain/p/wallet/backend_visitor.go @@ -1,7 +1,7 @@ // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. // See the file LICENSE for licensing terms. -package p +package wallet import ( "context" From 3e27a8e58064518a2d5ca822988502f30a98679f Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:08:15 -0400 Subject: [PATCH 052/114] nit --- wallet/chain/p/client.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/wallet/chain/p/client.go b/wallet/chain/p/client.go index 190bfbddf281..62378eb1dd2f 100644 --- a/wallet/chain/p/client.go +++ b/wallet/chain/p/client.go @@ -15,25 +15,25 @@ import ( var ( ErrNotCommitted = errors.New("not committed") - _ wallet.Client = (*client)(nil) + _ wallet.Client = (*Client)(nil) ) func NewClient( c platformvm.Client, b wallet.Backend, -) wallet.Client { - return &client{ +) *Client { + return &Client{ client: c, backend: b, } } -type client struct { +type Client struct { client platformvm.Client backend wallet.Backend } -func (c *client) IssueTx( +func (c *Client) IssueTx( tx *txs.Tx, options ...common.Option, ) error { From 9db6d873058e3ea8a0b06d1bad598f24516a687c Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:09:15 -0400 Subject: [PATCH 053/114] deadcode --- wallet/chain/p/client.go | 8 +------- wallet/chain/p/wallet/wallet.go | 7 +------ 2 files changed, 2 insertions(+), 13 deletions(-) diff --git a/wallet/chain/p/client.go b/wallet/chain/p/client.go index 62378eb1dd2f..6575f5deed75 100644 --- a/wallet/chain/p/client.go +++ b/wallet/chain/p/client.go @@ -4,19 +4,13 @@ package p import ( - "errors" - "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) -var ( - ErrNotCommitted = errors.New("not committed") - - _ wallet.Client = (*Client)(nil) -) +var _ wallet.Client = (*Client)(nil) func NewClient( c platformvm.Client, diff --git a/wallet/chain/p/wallet/wallet.go b/wallet/chain/p/wallet/wallet.go index 1892defe505d..d7414f1b3e28 100644 --- a/wallet/chain/p/wallet/wallet.go +++ b/wallet/chain/p/wallet/wallet.go @@ -4,7 +4,6 @@ package wallet import ( - "errors" "time" "github.com/ava-labs/avalanchego/ids" @@ -18,11 +17,7 @@ import ( walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) -var ( - ErrNotCommitted = errors.New("not committed") - - _ Wallet = (*wallet)(nil) -) +var _ Wallet = (*wallet)(nil) type Client interface { // IssueTx issues the signed tx. From 348be199941b4403129d8fc854f791bbe9681279 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:15:53 -0400 Subject: [PATCH 054/114] nit --- wallet/chain/p/wallet/{wallet_with_options.go => with_options.go} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename wallet/chain/p/wallet/{wallet_with_options.go => with_options.go} (100%) diff --git a/wallet/chain/p/wallet/wallet_with_options.go b/wallet/chain/p/wallet/with_options.go similarity index 100% rename from wallet/chain/p/wallet/wallet_with_options.go rename to wallet/chain/p/wallet/with_options.go From 7e4b007d842b735af978ce87066bfeafd2220b2b Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:41:07 -0400 Subject: [PATCH 055/114] reduce diff --- wallet/chain/p/wallet/backend.go | 2 +- wallet/chain/p/wallet/backend_visitor.go | 38 ++++++++++++------------ 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/wallet/chain/p/wallet/backend.go b/wallet/chain/p/wallet/backend.go index a71962108060..f46902fa8a51 100644 --- a/wallet/chain/p/wallet/backend.go +++ b/wallet/chain/p/wallet/backend.go @@ -48,7 +48,7 @@ func NewBackend(context *builder.Context, utxos common.ChainUTXOs, subnetOwner m func (b *backend) AcceptTx(ctx context.Context, tx *txs.Tx) error { txID := tx.ID() - err := tx.Unsigned.Visit(&visitor{ + err := tx.Unsigned.Visit(&backendVisitor{ b: b, ctx: ctx, txID: txID, diff --git a/wallet/chain/p/wallet/backend_visitor.go b/wallet/chain/p/wallet/backend_visitor.go index f7068bccd30a..5f664acde458 100644 --- a/wallet/chain/p/wallet/backend_visitor.go +++ b/wallet/chain/p/wallet/backend_visitor.go @@ -14,43 +14,43 @@ import ( ) var ( - _ txs.Visitor = (*visitor)(nil) + _ txs.Visitor = (*backendVisitor)(nil) ErrUnsupportedTxType = errors.New("unsupported tx type") ) -// visitor handles accepting transactions for the backend -type visitor struct { +// backendVisitor handles accepting transactions for the backend +type backendVisitor struct { b *backend ctx context.Context txID ids.ID } -func (*visitor) AdvanceTimeTx(*txs.AdvanceTimeTx) error { +func (*backendVisitor) AdvanceTimeTx(*txs.AdvanceTimeTx) error { return ErrUnsupportedTxType } -func (*visitor) RewardValidatorTx(*txs.RewardValidatorTx) error { +func (*backendVisitor) RewardValidatorTx(*txs.RewardValidatorTx) error { return ErrUnsupportedTxType } -func (b *visitor) AddValidatorTx(tx *txs.AddValidatorTx) error { +func (b *backendVisitor) AddValidatorTx(tx *txs.AddValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) AddSubnetValidatorTx(tx *txs.AddSubnetValidatorTx) error { +func (b *backendVisitor) AddSubnetValidatorTx(tx *txs.AddSubnetValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) AddDelegatorTx(tx *txs.AddDelegatorTx) error { +func (b *backendVisitor) AddDelegatorTx(tx *txs.AddDelegatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) CreateChainTx(tx *txs.CreateChainTx) error { +func (b *backendVisitor) CreateChainTx(tx *txs.CreateChainTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) CreateSubnetTx(tx *txs.CreateSubnetTx) error { +func (b *backendVisitor) CreateSubnetTx(tx *txs.CreateSubnetTx) error { b.b.setSubnetOwner( b.txID, tx.Owner, @@ -58,11 +58,11 @@ func (b *visitor) CreateSubnetTx(tx *txs.CreateSubnetTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) RemoveSubnetValidatorTx(tx *txs.RemoveSubnetValidatorTx) error { +func (b *backendVisitor) RemoveSubnetValidatorTx(tx *txs.RemoveSubnetValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) TransferSubnetOwnershipTx(tx *txs.TransferSubnetOwnershipTx) error { +func (b *backendVisitor) TransferSubnetOwnershipTx(tx *txs.TransferSubnetOwnershipTx) error { b.b.setSubnetOwner( tx.Subnet, tx.Owner, @@ -70,11 +70,11 @@ func (b *visitor) TransferSubnetOwnershipTx(tx *txs.TransferSubnetOwnershipTx) e return b.baseTx(&tx.BaseTx) } -func (b *visitor) BaseTx(tx *txs.BaseTx) error { +func (b *backendVisitor) BaseTx(tx *txs.BaseTx) error { return b.baseTx(tx) } -func (b *visitor) ImportTx(tx *txs.ImportTx) error { +func (b *backendVisitor) ImportTx(tx *txs.ImportTx) error { err := b.b.removeUTXOs( b.ctx, tx.SourceChain, @@ -86,7 +86,7 @@ func (b *visitor) ImportTx(tx *txs.ImportTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) ExportTx(tx *txs.ExportTx) error { +func (b *backendVisitor) ExportTx(tx *txs.ExportTx) error { for i, out := range tx.ExportedOutputs { err := b.b.AddUTXO( b.ctx, @@ -107,19 +107,19 @@ func (b *visitor) ExportTx(tx *txs.ExportTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) TransformSubnetTx(tx *txs.TransformSubnetTx) error { +func (b *backendVisitor) TransformSubnetTx(tx *txs.TransformSubnetTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) AddPermissionlessValidatorTx(tx *txs.AddPermissionlessValidatorTx) error { +func (b *backendVisitor) AddPermissionlessValidatorTx(tx *txs.AddPermissionlessValidatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) AddPermissionlessDelegatorTx(tx *txs.AddPermissionlessDelegatorTx) error { +func (b *backendVisitor) AddPermissionlessDelegatorTx(tx *txs.AddPermissionlessDelegatorTx) error { return b.baseTx(&tx.BaseTx) } -func (b *visitor) baseTx(tx *txs.BaseTx) error { +func (b *backendVisitor) baseTx(tx *txs.BaseTx) error { return b.b.removeUTXOs( b.ctx, constants.PlatformChainID, From f6bbbe4cbd188e0c2bdb71108f5b518222252743 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:41:31 -0400 Subject: [PATCH 056/114] reduce diff --- wallet/chain/p/wallet/backend_visitor.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wallet/chain/p/wallet/backend_visitor.go b/wallet/chain/p/wallet/backend_visitor.go index 5f664acde458..61dc3e231da7 100644 --- a/wallet/chain/p/wallet/backend_visitor.go +++ b/wallet/chain/p/wallet/backend_visitor.go @@ -19,7 +19,7 @@ var ( ErrUnsupportedTxType = errors.New("unsupported tx type") ) -// backendVisitor handles accepting transactions for the backend +// backendVisitor handles accepting of transactions for the backend type backendVisitor struct { b *backend ctx context.Context From b7c1b1e58dfed10b9e420bfa348279c072fab4f8 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:47:19 -0400 Subject: [PATCH 057/114] reduce diff --- .../txs/executor/create_chain_test.go | 24 +++++++------------ .../txs/executor/create_subnet_test.go | 23 ++++++++---------- vms/platformvm/txs/txstest/wallet.go | 6 ++--- 3 files changed, 21 insertions(+), 32 deletions(-) diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go index 1d3fe8a7eafb..a1ad4c81e186 100644 --- a/vms/platformvm/txs/executor/create_chain_test.go +++ b/vms/platformvm/txs/executor/create_chain_test.go @@ -220,27 +220,21 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { env.state.SetTimestamp(test.time) // to duly set fee - config := *env.config - config.StaticFeeConfig.CreateBlockchainTxFee = test.fee - - subnetID := testSubnet1.ID() - wallet := txstest.NewWallet( - t, - env.ctx, - &config, - env.state, - secp256k1fx.NewKeychain(preFundedKeys...), - []ids.ID{subnetID}, - nil, - ) - tx, err := wallet.IssueCreateChainTx( - subnetID, + cfg := *env.config + + cfg.StaticFeeConfig.CreateBlockchainTxFee = test.fee + factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) + builder, signer := factory.NewWallet(preFundedKeys...) + utx, err := builder.NewCreateChainTx( + testSubnet1.ID(), nil, ids.GenerateTestID(), nil, "", ) require.NoError(err) + tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) + require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/create_subnet_test.go b/vms/platformvm/txs/executor/create_subnet_test.go index 00d0c7daf6ec..a991bda7de0e 100644 --- a/vms/platformvm/txs/executor/create_subnet_test.go +++ b/vms/platformvm/txs/executor/create_subnet_test.go @@ -4,6 +4,7 @@ package executor import ( + "context" "testing" "time" @@ -17,6 +18,8 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + + walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestCreateSubnetTxAP3FeeChange(t *testing.T) { @@ -62,22 +65,16 @@ func TestCreateSubnetTxAP3FeeChange(t *testing.T) { addrs.Add(key.Address()) } - config := *env.config - config.StaticFeeConfig.CreateSubnetTxFee = test.fee - - wallet := txstest.NewWallet( - t, - env.ctx, - &config, - env.state, - secp256k1fx.NewKeychain(preFundedKeys...), - nil, - nil, - ) - tx, err := wallet.IssueCreateSubnetTx( + cfg := *env.config + cfg.StaticFeeConfig.CreateSubnetTxFee = test.fee + factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) + builder, signer := factory.NewWallet(preFundedKeys...) + utx, err := builder.NewCreateSubnetTx( &secp256k1fx.OutputOwners{}, ) require.NoError(err) + tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) + require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/txstest/wallet.go b/vms/platformvm/txs/txstest/wallet.go index 2cfc20aa1aec..0a040eed7d82 100644 --- a/vms/platformvm/txs/txstest/wallet.go +++ b/vms/platformvm/txs/txstest/wallet.go @@ -19,7 +19,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - "github.com/ava-labs/avalanchego/wallet/chain/p/backend" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" "github.com/ava-labs/avalanchego/wallet/chain/p/signer" "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" @@ -83,7 +82,7 @@ func NewWallet( } builderContext := newContext(ctx, config, state) - backend := backend.New( + backend := wallet.NewBackend( builderContext, common.NewChainUTXOs(constants.PlatformChainID, utxos), owners, @@ -101,12 +100,11 @@ func NewWallet( kc, backend, ), - backend, ) } type client struct { - backend backend.Backend + backend wallet.Backend } func (c *client) IssueTx( From d68b2ce624cc26af17afc20e1b4428d8721e63ae Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 20 Aug 2024 16:54:36 -0400 Subject: [PATCH 058/114] Meter complexity first --- vms/platformvm/block/executor/verifier.go | 52 +++++++++++------------ 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index c83741bd405d..315c4ad90fae 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -467,18 +467,10 @@ func (v *verifier) processStandardTxs( func(), error, ) { - timestamp := state.GetTimestamp() - isEtnaActivated := v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) - - var ( - blockComplexity feecomponent.Dimensions - onAcceptFunc func() - inputs set.Set[ids.ID] - funcs = make([]func(), 0, len(txs)) - atomicRequests = make(map[ids.ID]*atomic.Requests) - ) - for _, tx := range txs { - if isEtnaActivated { + // Complexity is limited first to avoid processing too large of a block. + if timestamp := state.GetTimestamp(); v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) { + var blockComplexity feecomponent.Dimensions + for _, tx := range txs { txComplexity, err := txfee.TxComplexity(tx.Unsigned) if err != nil { txID := tx.ID() @@ -492,6 +484,27 @@ func (v *verifier) processStandardTxs( } } + blockGas, err := blockComplexity.ToGas(v.txExecutorBackend.Config.DynamicFeeConfig.Weights) + if err != nil { + return nil, nil, nil, err + } + + feeState := state.GetFeeState() + feeState, err = feeState.ConsumeGas(blockGas) + if err != nil { + return nil, nil, nil, err + } + + state.SetFeeState(feeState) + } + + var ( + onAcceptFunc func() + inputs set.Set[ids.ID] + funcs = make([]func(), 0, len(txs)) + atomicRequests = make(map[ids.ID]*atomic.Requests) + ) + for _, tx := range txs { txExecutor := executor.StandardTxExecutor{ Backend: v.txExecutorBackend, State: state, @@ -528,21 +541,6 @@ func (v *verifier) processStandardTxs( } } - if isEtnaActivated { - blockGas, err := blockComplexity.ToGas(v.txExecutorBackend.Config.DynamicFeeConfig.Weights) - if err != nil { - return nil, nil, nil, err - } - - feeState := state.GetFeeState() - feeState, err = feeState.ConsumeGas(blockGas) - if err != nil { - return nil, nil, nil, err - } - - state.SetFeeState(feeState) - } - if err := v.verifyUniqueInputs(parentID, inputs); err != nil { return nil, nil, nil, err } From 5a0c28b2683531223eef69c54a707fbd9b30d676 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 00:09:58 -0400 Subject: [PATCH 059/114] fix unit tests --- vms/platformvm/service_test.go | 28 ++++++++++++++-------------- vms/platformvm/vm_test.go | 7 +++++-- 2 files changed, 19 insertions(+), 16 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 3c89f712adf7..7ba1f50909d1 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -77,8 +77,8 @@ var ( } ) -func defaultService(t *testing.T) (*Service, *mutableSharedMemory, *txstest.WalletFactory) { - vm, factory, _, mutableSharedMemory := defaultVM(t, upgradetest.Latest) +func defaultService(t *testing.T, fork upgradetest.Fork) (*Service, *mutableSharedMemory, *txstest.WalletFactory) { + vm, factory, _, mutableSharedMemory := defaultVM(t, fork) return &Service{ vm: vm, @@ -92,7 +92,7 @@ func defaultService(t *testing.T) (*Service, *mutableSharedMemory, *txstest.Wall func TestExportKey(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _, _ := defaultService(t, upgradetest.Latest) service.vm.ctx.Lock.Lock() ks := keystore.New(logging.NoLog{}, memdb.New()) @@ -122,7 +122,7 @@ func TestExportKey(t *testing.T) { // Test issuing a tx and accepted func TestGetTxStatus(t *testing.T) { require := require.New(t) - service, mutableSharedMemory, factory := defaultService(t) + service, mutableSharedMemory, factory := defaultService(t, upgradetest.Latest) service.vm.ctx.Lock.Lock() recipientKey, err := secp256k1.NewPrivateKey() @@ -311,7 +311,7 @@ func TestGetTx(t *testing.T) { ) t.Run(testName, func(t *testing.T) { require := require.New(t) - service, _, txBuilder := defaultService(t) + service, _, txBuilder := defaultService(t, upgradetest.Latest) service.vm.ctx.Lock.Lock() tx, err := test.createTx(service, txBuilder) @@ -375,10 +375,10 @@ func TestGetTx(t *testing.T) { func TestGetBalance(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _, _ := defaultService(t, upgradetest.Durango) feeCalculator := state.PickFeeCalculator(&service.vm.Config, service.vm.state) - createSubnetFee, err := feeCalculator.CalculateFee(&txs.CreateSubnetTx{}) + createSubnetFee, err := feeCalculator.CalculateFee(testSubnet1.Unsigned) require.NoError(err) // Ensure GetStake is correct for each of the genesis validators @@ -407,7 +407,7 @@ func TestGetBalance(t *testing.T) { func TestGetStake(t *testing.T) { require := require.New(t) - service, _, factory := defaultService(t) + service, _, factory := defaultService(t, upgradetest.Latest) // Ensure GetStake is correct for each of the genesis validators genesis, _ := defaultGenesis(t, service.vm.ctx.AVAXAssetID) @@ -596,7 +596,7 @@ func TestGetStake(t *testing.T) { func TestGetCurrentValidators(t *testing.T) { require := require.New(t) - service, _, factory := defaultService(t) + service, _, factory := defaultService(t, upgradetest.Latest) genesis, _ := defaultGenesis(t, service.vm.ctx.AVAXAssetID) @@ -731,7 +731,7 @@ func TestGetCurrentValidators(t *testing.T) { func TestGetTimestamp(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _, _ := defaultService(t, upgradetest.Latest) reply := GetTimestampReply{} require.NoError(service.GetTimestamp(nil, nil, &reply)) @@ -767,7 +767,7 @@ func TestGetBlock(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { require := require.New(t) - service, _, factory := defaultService(t) + service, _, factory := defaultService(t, upgradetest.Latest) service.vm.ctx.Lock.Lock() service.vm.Config.CreateAssetTxFee = 100 * defaultTxFee @@ -1059,7 +1059,7 @@ func TestServiceGetBlockByHeight(t *testing.T) { func TestServiceGetSubnets(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _, _ := defaultService(t, upgradetest.Latest) testSubnet1ID := testSubnet1.ID() @@ -1131,7 +1131,7 @@ func TestGetFeeConfig(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _, _ := defaultService(t, upgradetest.Latest) service.vm.Config.UpgradeConfig.EtnaTime = test.etnaTime var reply fee.Config @@ -1145,7 +1145,7 @@ func FuzzGetFeeState(f *testing.F) { f.Fuzz(func(t *testing.T, capacity, excess uint64) { require := require.New(t) - service, _, _ := defaultService(t) + service, _, _ := defaultService(t, upgradetest.Latest) var ( expectedState = fee.State{ diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 4175c0346c70..b842b8f98aa7 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -277,6 +277,9 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d // align chain time and local clock vm.state.SetTimestamp(vm.clock.Time()) + vm.state.SetFeeState(feecomponent.State{ + Capacity: defaultDynamicFeeConfig.MaxGasCapacity, + }) require.NoError(vm.SetState(context.Background(), snow.NormalOp)) @@ -330,7 +333,7 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d // Ensure genesis state is parsed from bytes and stored correctly func TestGenesis(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Durango) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2269,7 +2272,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { func TestBaseTx(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, factory, _, _ := defaultVM(t, upgradetest.Durango) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() From 4671917947c45cc45c06f6a3c86deb3fe8e63f08 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 00:23:54 -0400 Subject: [PATCH 060/114] nit --- vms/platformvm/txs/txstest/context.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/vms/platformvm/txs/txstest/context.go b/vms/platformvm/txs/txstest/context.go index 77a8d98bc221..50f3bb4d3a61 100644 --- a/vms/platformvm/txs/txstest/context.go +++ b/vms/platformvm/txs/txstest/context.go @@ -11,6 +11,10 @@ import ( "github.com/ava-labs/avalanchego/wallet/chain/p/builder" ) +// gasPriceMultiplier increases the gas price to support multiple transactions +// to be issued. +const gasPriceMultiplier = 2 + func newContext( ctx *snow.Context, config *config.Config, @@ -26,7 +30,7 @@ func newContext( switch { case config.UpgradeConfig.IsEtnaActivated(timestamp): builderContext.ComplexityWeights = config.DynamicFeeConfig.Weights - builderContext.GasPrice = 10 * fee.CalculateGasPrice( + builderContext.GasPrice = gasPriceMultiplier * fee.CalculateGasPrice( config.DynamicFeeConfig.MinGasPrice, state.GetFeeState().Excess, config.DynamicFeeConfig.ExcessConversionConstant, From d75e73cbb89784911714e9e0799c116d3a8b716a Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 00:39:03 -0400 Subject: [PATCH 061/114] Add .String() to Fork testing utility --- upgrade/upgradetest/fork.go | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/upgrade/upgradetest/fork.go b/upgrade/upgradetest/fork.go index 01c9b2ea03ee..706fcb50fdd8 100644 --- a/upgrade/upgradetest/fork.go +++ b/upgrade/upgradetest/fork.go @@ -23,3 +23,36 @@ const ( // Fork is an enum of all the major network upgrades. type Fork int + +func (f Fork) String() string { + switch f { + case Etna: + return "Etna" + case Durango: + return "Durango" + case Cortina: + return "Cortina" + case Banff: + return "Banff" + case ApricotPhasePost6: + return "ApricotPhasePost6" + case ApricotPhase6: + return "ApricotPhase6" + case ApricotPhasePre6: + return "ApricotPhasePre6" + case ApricotPhase5: + return "ApricotPhase5" + case ApricotPhase4: + return "ApricotPhase4" + case ApricotPhase3: + return "ApricotPhase3" + case ApricotPhase2: + return "ApricotPhase2" + case ApricotPhase1: + return "ApricotPhase1" + case NoUpgrades: + return "NoUpgrades" + default: + return "Unknown" + } +} From 201410318f1dfffc66c0a11a5909c2b769503efa Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 11:23:03 -0400 Subject: [PATCH 062/114] Add comment --- vms/platformvm/block/executor/verifier.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index 315c4ad90fae..3b7d7d2eaa9f 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -495,6 +495,8 @@ func (v *verifier) processStandardTxs( return nil, nil, nil, err } + // Updating the fee state prior to executing the transactions is fine + // because the fee calculator was already created. state.SetFeeState(feeState) } From 78c8d93fee3776df133de336c59fffb42c2f8ff7 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 11:26:24 -0400 Subject: [PATCH 063/114] nit --- vms/platformvm/txs/txstest/context.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/vms/platformvm/txs/txstest/context.go b/vms/platformvm/txs/txstest/context.go index 50f3bb4d3a61..4d7543259038 100644 --- a/vms/platformvm/txs/txstest/context.go +++ b/vms/platformvm/txs/txstest/context.go @@ -11,10 +11,6 @@ import ( "github.com/ava-labs/avalanchego/wallet/chain/p/builder" ) -// gasPriceMultiplier increases the gas price to support multiple transactions -// to be issued. -const gasPriceMultiplier = 2 - func newContext( ctx *snow.Context, config *config.Config, @@ -30,7 +26,7 @@ func newContext( switch { case config.UpgradeConfig.IsEtnaActivated(timestamp): builderContext.ComplexityWeights = config.DynamicFeeConfig.Weights - builderContext.GasPrice = gasPriceMultiplier * fee.CalculateGasPrice( + builderContext.GasPrice = fee.CalculateGasPrice( config.DynamicFeeConfig.MinGasPrice, state.GetFeeState().Excess, config.DynamicFeeConfig.ExcessConversionConstant, From 8c0050cb7b6d6c47d59948b8386b18e11cb421c8 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 11:40:28 -0400 Subject: [PATCH 064/114] nit --- wallet/chain/p/context.go | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/wallet/chain/p/context.go b/wallet/chain/p/context.go index 1ae8f0371c17..841dbd7f2ed1 100644 --- a/wallet/chain/p/context.go +++ b/wallet/chain/p/context.go @@ -13,6 +13,12 @@ import ( "github.com/ava-labs/avalanchego/wallet/chain/p/builder" ) +// gasPriceMultiplier increases the gas price to support multiple transactions +// to be issued. +// +// TODO: Handle this better. Either here or in the mempool. +const gasPriceMultiplier = 2 + func NewContextFromURI(ctx context.Context, uri string) (*builder.Context, error) { infoClient := info.NewClient(uri) xChainClient := avm.NewClient(uri, "X") @@ -52,11 +58,7 @@ func NewContextFromClients( NetworkID: networkID, AVAXAssetID: asset.AssetID, ComplexityWeights: dynamicFeeConfig.Weights, - // The gas price is doubled to attempt to handle concurrent tx - // issuance. - // - // TODO: Handle this better. Either here or in the mempool. - GasPrice: 2 * gasPrice, + GasPrice: gasPriceMultiplier * gasPrice, }, nil } From a9f3bd183fc075f43fac0ae7a9ad53d4ac8d5a0d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 21 Aug 2024 11:41:36 -0400 Subject: [PATCH 065/114] nit --- vms/platformvm/block/executor/verifier.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index 3b7d7d2eaa9f..703944adef94 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -489,6 +489,8 @@ func (v *verifier) processStandardTxs( return nil, nil, nil, err } + // If this block exceeds the available capacity, ConsumeGas will return + // an error. feeState := state.GetFeeState() feeState, err = feeState.ConsumeGas(blockGas) if err != nil { From 40a637d09e5fa28044cb766978f489765b76fdac Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 22 Aug 2024 23:34:00 -0400 Subject: [PATCH 066/114] cleanup --- .../block/executor/verifier_test.go | 25 +++---------------- vms/platformvm/txs/txstest/context.go | 6 ++--- 2 files changed, 7 insertions(+), 24 deletions(-) diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index ff58bbae3b54..bc71d17e7ec2 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -17,10 +17,10 @@ import ( "github.com/ava-labs/avalanchego/genesis" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/snow" + "github.com/ava-labs/avalanchego/snow/snowtest" "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" - "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/timer/mockable" @@ -50,28 +50,11 @@ func newTestVerifier(t testing.TB, s state.State) *verifier { mempool, err := mempool.New("", prometheus.NewRegistry(), nil) require.NoError(err) - sk, err := bls.NewSecretKey() - require.NoError(err) - pk := bls.PublicFromSecretKey(sk) - var ( upgrades = upgradetest.GetConfig(upgradetest.Latest) - ctx = &snow.Context{ - NetworkID: constants.UnitTestID, - SubnetID: constants.PrimaryNetworkID, - ChainID: constants.PlatformChainID, - NodeID: ids.GenerateTestNodeID(), - PublicKey: pk, - NetworkUpgrades: upgrades, - - XChainID: ids.GenerateTestID(), - CChainID: ids.GenerateTestID(), - AVAXAssetID: genesistest.AVAXAssetID, - - Log: logging.NoLog{}, - } - clock = &mockable.Clock{} - fx = &secp256k1fx.Fx{} + ctx = snowtest.Context(t, constants.PlatformChainID) + clock = &mockable.Clock{} + fx = &secp256k1fx.Fx{} ) require.NoError(fx.InitializeVM(&secp256k1fx.TestVM{ Clk: *clock, diff --git a/vms/platformvm/txs/txstest/context.go b/vms/platformvm/txs/txstest/context.go index 4d7543259038..4fcc0f790ec8 100644 --- a/vms/platformvm/txs/txstest/context.go +++ b/vms/platformvm/txs/txstest/context.go @@ -5,7 +5,7 @@ package txstest import ( "github.com/ava-labs/avalanchego/snow" - "github.com/ava-labs/avalanchego/vms/components/fee" + "github.com/ava-labs/avalanchego/vms/components/gas" "github.com/ava-labs/avalanchego/vms/platformvm/config" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" @@ -26,8 +26,8 @@ func newContext( switch { case config.UpgradeConfig.IsEtnaActivated(timestamp): builderContext.ComplexityWeights = config.DynamicFeeConfig.Weights - builderContext.GasPrice = fee.CalculateGasPrice( - config.DynamicFeeConfig.MinGasPrice, + builderContext.GasPrice = gas.CalculatePrice( + config.DynamicFeeConfig.MinPrice, state.GetFeeState().Excess, config.DynamicFeeConfig.ExcessConversionConstant, ) From d39ab697d2ebf1b0578c9fc514f572ce6110275f Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 22 Aug 2024 23:35:21 -0400 Subject: [PATCH 067/114] reduce diff --- vms/platformvm/block/executor/verifier_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index bc71d17e7ec2..6508d4c88624 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -87,7 +87,6 @@ func newTestVerifier(t testing.TB, s state.State) *verifier { ), Bootstrapped: utils.NewAtomic(true), }, - pChainHeight: 0, } } From 43818992cdf543d410d511cee5557400ef5337c3 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Thu, 22 Aug 2024 23:57:56 -0400 Subject: [PATCH 068/114] nit --- .../state/chain_time_helpers_test.go | 29 +++++++++---------- vms/platformvm/vm_test.go | 2 +- 2 files changed, 15 insertions(+), 16 deletions(-) diff --git a/vms/platformvm/state/chain_time_helpers_test.go b/vms/platformvm/state/chain_time_helpers_test.go index 434a9e802647..1101b27f4639 100644 --- a/vms/platformvm/state/chain_time_helpers_test.go +++ b/vms/platformvm/state/chain_time_helpers_test.go @@ -10,16 +10,15 @@ import ( "github.com/ava-labs/avalanchego/database/memdb" "github.com/ava-labs/avalanchego/upgrade/upgradetest" + "github.com/ava-labs/avalanchego/vms/components/gas" "github.com/ava-labs/avalanchego/vms/platformvm/config" - - feecomponent "github.com/ava-labs/avalanchego/vms/components/fee" - txfee "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" + "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) func TestPickFeeCalculator(t *testing.T) { var ( createAssetTxFee uint64 = 9 - staticFeeConfig = txfee.StaticConfig{ + staticFeeConfig = fee.StaticConfig{ TxFee: 1, CreateSubnetTxFee: 2, TransformSubnetTxFee: 3, @@ -29,12 +28,12 @@ func TestPickFeeCalculator(t *testing.T) { AddSubnetValidatorFee: 7, AddSubnetDelegatorFee: 8, } - dynamicFeeConfig = feecomponent.Config{ - Weights: feecomponent.Dimensions{1}, - MaxGasCapacity: 2, - MaxGasPerSecond: 3, - TargetGasPerSecond: 4, - MinGasPrice: 5, + dynamicFeeConfig = gas.Config{ + Weights: gas.Dimensions{1}, + MaxCapacity: 2, + MaxPerSecond: 3, + TargetPerSecond: 4, + MinPrice: 5, ExcessConversionConstant: 6, } ) @@ -45,21 +44,21 @@ func TestPickFeeCalculator(t *testing.T) { tests := []struct { fork upgradetest.Fork - expected txfee.Calculator + expected fee.Calculator }{ { fork: upgradetest.ApricotPhase2, - expected: txfee.NewStaticCalculator(apricotPhase2StaticFeeConfig), + expected: fee.NewStaticCalculator(apricotPhase2StaticFeeConfig), }, { fork: upgradetest.ApricotPhase3, - expected: txfee.NewStaticCalculator(staticFeeConfig), + expected: fee.NewStaticCalculator(staticFeeConfig), }, { fork: upgradetest.Etna, - expected: txfee.NewDynamicCalculator( + expected: fee.NewDynamicCalculator( dynamicFeeConfig.Weights, - dynamicFeeConfig.MinGasPrice, + dynamicFeeConfig.MinPrice, ), }, } diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 75796a0ea8a3..8c1413a3e324 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -187,7 +187,7 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d // align chain time and local clock vm.state.SetTimestamp(vm.clock.Time()) - vm.state.SetFeeState(feecomponent.State{ + vm.state.SetFeeState(gas.State{ Capacity: defaultDynamicFeeConfig.MaxGasCapacity, }) From 67a81eefb1ab420cd7596480fa3485c7643b6bb6 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 10:57:38 -0400 Subject: [PATCH 069/114] wip --- vms/platformvm/service_test.go | 95 +++++++++----- .../txs/executor/create_chain_test.go | 21 +-- .../txs/executor/create_subnet_test.go | 23 ++-- vms/platformvm/txs/txstest/wallet.go | 121 ++++++++++++++++++ vms/platformvm/validator_set_property_test.go | 96 +++++++------- vms/platformvm/vm_regression_test.go | 39 ++++-- 6 files changed, 288 insertions(+), 107 deletions(-) create mode 100644 vms/platformvm/txs/txstest/wallet.go diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 47e8a48ef578..a6e41ecfa0ad 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -125,7 +125,7 @@ func TestExportKey(t *testing.T) { // Test issuing a tx and accepted func TestGetTxStatus(t *testing.T) { require := require.New(t) - service, mutableSharedMemory, factory := defaultService(t) + service, mutableSharedMemory, _ := defaultService(t) service.vm.ctx.Lock.Lock() recipientKey, err := secp256k1.NewPrivateKey() @@ -173,8 +173,16 @@ func TestGetTxStatus(t *testing.T) { mutableSharedMemory.SharedMemory = sm - builder, signer := factory.NewWallet(recipientKey) - utx, err := builder.NewImportTx( + wallet := txstest.NewWallet( + t, + service.vm.ctx, + &service.vm.Config, + service.vm.state, + secp256k1fx.NewKeychain(recipientKey), + nil, // subnetIDs + []ids.ID{service.vm.ctx.XChainID}, + ) + tx, err := wallet.IssueImportTx( service.vm.ctx.XChainID, &secp256k1fx.OutputOwners{ Threshold: 1, @@ -182,8 +190,6 @@ func TestGetTxStatus(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) service.vm.ctx.Lock.Unlock() @@ -219,16 +225,26 @@ func TestGetTxStatus(t *testing.T) { func TestGetTx(t *testing.T) { type test struct { description string - createTx func(service *Service, factory *txstest.WalletFactory) (*txs.Tx, error) + createTx func(t testing.TB, s *Service) *txs.Tx } tests := []test{ { "standard block", - func(_ *Service, factory *txstest.WalletFactory) (*txs.Tx, error) { - builder, signer := factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + func(t testing.TB, s *Service) *txs.Tx { + subnetID := testSubnet1.ID() + wallet := txstest.NewWallet( + t, + s.vm.ctx, + &s.vm.Config, + s.vm.state, + secp256k1fx.NewKeychain(testSubnet1ControlKeys[:2]...), + []ids.ID{subnetID}, + nil, // chainIDs + ) + + tx, err := wallet.IssueCreateChainTx( + subnetID, []byte{}, constants.AVMID, []ids.ID{}, @@ -239,12 +255,22 @@ func TestGetTx(t *testing.T) { }), ) require.NoError(t, err) - return walletsigner.SignUnsigned(context.Background(), signer, utx) + return tx }, }, { "proposal block", - func(service *Service, factory *txstest.WalletFactory) (*txs.Tx, error) { + func(t testing.TB, s *Service) *txs.Tx { + wallet := txstest.NewWallet( + t, + s.vm.ctx, + &s.vm.Config, + s.vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), + nil, // subnetIDs + nil, // chainIDs + ) + sk, err := bls.NewSecretKey() require.NoError(t, err) @@ -252,20 +278,18 @@ func TestGetTx(t *testing.T) { Threshold: 1, Addrs: []ids.ShortID{ids.GenerateTestShortID()}, } - - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddPermissionlessValidatorTx( + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: ids.GenerateTestNodeID(), - Start: uint64(service.vm.clock.Time().Add(txexecutor.SyncBound).Unix()), - End: uint64(service.vm.clock.Time().Add(txexecutor.SyncBound).Add(defaultMinStakingDuration).Unix()), - Wght: service.vm.MinValidatorStake, + Start: uint64(s.vm.clock.Time().Add(txexecutor.SyncBound).Unix()), + End: uint64(s.vm.clock.Time().Add(txexecutor.SyncBound).Add(defaultMinStakingDuration).Unix()), + Wght: s.vm.MinValidatorStake, }, Subnet: constants.PrimaryNetworkID, }, signer.NewProofOfPossession(sk), - service.vm.ctx.AVAXAssetID, + s.vm.ctx.AVAXAssetID, rewardsOwner, rewardsOwner, 0, @@ -275,17 +299,26 @@ func TestGetTx(t *testing.T) { }), ) require.NoError(t, err) - return walletsigner.SignUnsigned(context.Background(), txSigner, utx) + return tx }, }, { "atomic block", - func(service *Service, factory *txstest.WalletFactory) (*txs.Tx, error) { - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewExportTx( - service.vm.ctx.XChainID, + func(t testing.TB, s *Service) *txs.Tx { + wallet := txstest.NewWallet( + t, + s.vm.ctx, + &s.vm.Config, + s.vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), + nil, // subnetIDs + nil, // chainIDs + ) + + tx, err := wallet.IssueExportTx( + s.vm.ctx.XChainID, []*avax.TransferableOutput{{ - Asset: avax.Asset{ID: service.vm.ctx.AVAXAssetID}, + Asset: avax.Asset{ID: s.vm.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ Amt: 100, OutputOwners: secp256k1fx.OutputOwners{ @@ -301,7 +334,7 @@ func TestGetTx(t *testing.T) { }), ) require.NoError(t, err) - return walletsigner.SignUnsigned(context.Background(), signer, utx) + return tx }, }, } @@ -314,12 +347,10 @@ func TestGetTx(t *testing.T) { ) t.Run(testName, func(t *testing.T) { require := require.New(t) - service, _, txBuilder := defaultService(t) - service.vm.ctx.Lock.Lock() - - tx, err := test.createTx(service, txBuilder) - require.NoError(err) + service, _, _ := defaultService(t) + service.vm.ctx.Lock.Lock() + tx := test.createTx(t, service) service.vm.ctx.Lock.Unlock() arg := &api.GetTxArgs{ @@ -327,7 +358,7 @@ func TestGetTx(t *testing.T) { Encoding: encoding, } var response api.GetTxReply - err = service.GetTx(nil, arg, &response) + err := service.GetTx(nil, arg, &response) require.ErrorIs(err, database.ErrNotFound) // We haven't issued the tx yet require.NoError(service.vm.Network.IssueTxFromRPC(tx)) diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go index d454cda30a78..a955fe15db35 100644 --- a/vms/platformvm/txs/executor/create_chain_test.go +++ b/vms/platformvm/txs/executor/create_chain_test.go @@ -221,12 +221,19 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { env.state.SetTimestamp(test.time) // to duly set fee - cfg := *env.config - - cfg.StaticFeeConfig.CreateBlockchainTxFee = test.fee - factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewCreateChainTx( + config := *env.config + config.StaticFeeConfig.CreateBlockchainTxFee = test.fee + + wallet := txstest.NewWallet( + t, + env.ctx, + &config, + env.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{testSubnet1.ID()}, + nil, // chainIDs + ) + tx, err := wallet.IssueCreateChainTx( testSubnet1.ID(), nil, ids.GenerateTestID(), @@ -234,8 +241,6 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { "", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/create_subnet_test.go b/vms/platformvm/txs/executor/create_subnet_test.go index ad51fdc0b2b0..a4ef092427d2 100644 --- a/vms/platformvm/txs/executor/create_subnet_test.go +++ b/vms/platformvm/txs/executor/create_subnet_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "testing" "time" @@ -19,8 +18,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestCreateSubnetTxAP3FeeChange(t *testing.T) { @@ -66,16 +63,22 @@ func TestCreateSubnetTxAP3FeeChange(t *testing.T) { addrs.Add(key.Address()) } - cfg := *env.config - cfg.StaticFeeConfig.CreateSubnetTxFee = test.fee - factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewCreateSubnetTx( + config := *env.config + config.StaticFeeConfig.CreateSubnetTxFee = test.fee + + wallet := txstest.NewWallet( + t, + env.ctx, + &config, + env.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + tx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{}, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/txstest/wallet.go b/vms/platformvm/txs/txstest/wallet.go new file mode 100644 index 000000000000..8f16b40719b3 --- /dev/null +++ b/vms/platformvm/txs/txstest/wallet.go @@ -0,0 +1,121 @@ +// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package txstest + +import ( + "context" + "math" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/snow" + "github.com/ava-labs/avalanchego/utils/constants" + "github.com/ava-labs/avalanchego/vms/components/avax" + "github.com/ava-labs/avalanchego/vms/platformvm/config" + "github.com/ava-labs/avalanchego/vms/platformvm/fx" + "github.com/ava-labs/avalanchego/vms/platformvm/state" + "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/builder" + "github.com/ava-labs/avalanchego/wallet/chain/p/signer" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" + "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" +) + +func NewWallet( + t testing.TB, + ctx *snow.Context, + config *config.Config, + state state.State, + kc *secp256k1fx.Keychain, + subnetIDs []ids.ID, + chainIDs []ids.ID, +) wallet.Wallet { + var ( + require = require.New(t) + addrs = kc.Addresses() + utxos = common.NewUTXOs() + ) + + pChainUTXOs, err := avax.GetAllUTXOs(state, addrs) + require.NoError(err) + + for _, utxo := range pChainUTXOs { + require.NoError(utxos.AddUTXO( + context.Background(), + constants.PlatformChainID, + constants.PlatformChainID, + utxo, + )) + } + + for _, chainID := range chainIDs { + remoteChainUTXOs, _, _, err := avax.GetAtomicUTXOs( + ctx.SharedMemory, + txs.Codec, + chainID, + addrs, + ids.ShortEmpty, + ids.Empty, + math.MaxInt, + ) + require.NoError(err) + + for _, utxo := range remoteChainUTXOs { + require.NoError(utxos.AddUTXO( + context.Background(), + chainID, + constants.PlatformChainID, + utxo, + )) + } + } + + owners := make(map[ids.ID]fx.Owner, len(subnetIDs)) + for _, subnetID := range subnetIDs { + owner, err := state.GetSubnetOwner(subnetID) + require.NoError(err) + owners[subnetID] = owner + } + + builderContext := newContext(ctx, config, state.GetTimestamp()) + backend := wallet.NewBackend( + builderContext, + common.NewChainUTXOs(constants.PlatformChainID, utxos), + owners, + ) + return wallet.New( + &client{ + backend: backend, + }, + builder.New( + addrs, + builderContext, + backend, + ), + signer.New( + kc, + backend, + ), + ) +} + +type client struct { + backend wallet.Backend +} + +func (c *client) IssueTx( + tx *txs.Tx, + options ...common.Option, +) error { + ops := common.NewOptions(options) + if f := ops.PostIssuanceFunc(); f != nil { + txID := tx.ID() + f(txID) + } + ctx := ops.Context() + return c.backend.AcceptTx(ctx, tx) +} diff --git a/vms/platformvm/validator_set_property_test.go b/vms/platformvm/validator_set_property_test.go index 44ba02e0e1a7..ed10915b5a2f 100644 --- a/vms/platformvm/validator_set_property_test.go +++ b/vms/platformvm/validator_set_property_test.go @@ -15,6 +15,7 @@ import ( "github.com/leanovate/gopter" "github.com/leanovate/gopter/gen" "github.com/leanovate/gopter/prop" + "github.com/stretchr/testify/require" "golang.org/x/exp/maps" "github.com/ava-labs/avalanchego/chains" @@ -46,7 +47,6 @@ import ( blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) @@ -122,10 +122,7 @@ func TestGetValidatorsSetProperty(t *testing.T) { switch ev.eventType { case startSubnetValidator: - currentSubnetValidator, err = addSubnetValidator(vm, ev, subnetID) - if err != nil { - return "could not add subnet validator: " + err.Error() - } + currentSubnetValidator = addSubnetValidator(t, vm, ev, subnetID) if err := takeValidatorsSnapshotAtCurrentHeight(vm, validatorSetByHeightAndSubnet); err != nil { return failedValidatorSnapshotString + err.Error() } @@ -145,10 +142,7 @@ func TestGetValidatorsSetProperty(t *testing.T) { return failedValidatorSnapshotString + err.Error() } } - currentPrimaryValidator, err = addPrimaryValidatorWithBLSKey(vm, ev) - if err != nil { - return "could not add primary validator with BLS key: " + err.Error() - } + currentPrimaryValidator = addPrimaryValidatorWithBLSKey(t, vm, ev) if err := takeValidatorsSnapshotAtCurrentHeight(vm, validatorSetByHeightAndSubnet); err != nil { return failedValidatorSnapshotString + err.Error() } @@ -254,10 +248,19 @@ func takeValidatorsSnapshotAtCurrentHeight(vm *VM, validatorsSetByHeightAndSubne return nil } -func addSubnetValidator(vm *VM, data *validatorInputData, subnetID ids.ID) (*state.Staker, error) { - factory := txstest.NewWalletFactory(vm.ctx, &vm.Config, vm.state) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( +func addSubnetValidator(t testing.TB, vm *VM, data *validatorInputData, subnetID ids.ID) *state.Staker { + require := require.New(t) + + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[:2]...), + []ids.ID{subnetID}, + nil, // chainIDs + ) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: data.nodeID, @@ -272,27 +275,31 @@ func addSubnetValidator(vm *VM, data *validatorInputData, subnetID ids.ID) (*sta Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, }), ) - if err != nil { - return nil, fmt.Errorf("could not build AddSubnetValidatorTx: %w", err) - } - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - if err != nil { - return nil, fmt.Errorf("could not sign AddSubnetValidatorTx: %w", err) - } - return internalAddValidator(vm, tx) + require.NoError(err) + + staker, err := internalAddValidator(vm, tx) + require.NoError(err) + return staker } -func addPrimaryValidatorWithBLSKey(vm *VM, data *validatorInputData) (*state.Staker, error) { +func addPrimaryValidatorWithBLSKey(t testing.TB, vm *VM, data *validatorInputData) *state.Staker { + require := require.New(t) + addr := genesistest.DefaultFundedKeys[0].Address() sk, err := bls.NewSecretKey() - if err != nil { - return nil, fmt.Errorf("failed to generate BLS key: %w", err) - } - - factory := txstest.NewWalletFactory(vm.ctx, &vm.Config, vm.state) - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddPermissionlessValidatorTx( + require.NoError(err) + + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[:2]...), + nil, // subnetIDs + nil, // chainIDs + ) + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: data.nodeID, @@ -318,14 +325,11 @@ func addPrimaryValidatorWithBLSKey(vm *VM, data *validatorInputData) (*state.Sta Addrs: []ids.ShortID{addr}, }), ) - if err != nil { - return nil, fmt.Errorf("could not build AddPermissionlessValidatorTx: %w", err) - } - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - if err != nil { - return nil, fmt.Errorf("could not sign AddPermissionlessValidatorTx: %w", err) - } - return internalAddValidator(vm, tx) + require.NoError(err) + + staker, err := internalAddValidator(vm, tx) + require.NoError(err) + return staker } func internalAddValidator(vm *VM, signedTx *txs.Tx) (*state.Staker, error) { @@ -708,9 +712,16 @@ func buildVM(t *testing.T) (*VM, ids.ID, error) { // Create a subnet and store it in testSubnet1 // Note: following Banff activation, block acceptance will move // chain time ahead - factory := txstest.NewWalletFactory(vm.ctx, &vm.Config, vm.state) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys[len(genesistest.DefaultFundedKeys)-1]) - utx, err := builder.NewCreateSubnetTx( + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[len(genesistest.DefaultFundedKeys)-1]), + nil, // subnetIDs + nil, // chainIDs + ) + testSubnet1, err = wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, @@ -723,10 +734,7 @@ func buildVM(t *testing.T) (*VM, ids.ID, error) { if err != nil { return nil, ids.Empty, err } - testSubnet1, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - if err != nil { - return nil, ids.Empty, err - } + vm.ctx.Lock.Unlock() err = vm.issueTxFromRPC(testSubnet1) vm.ctx.Lock.Lock() diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 9b4d8b19a5a6..be9834d95fbe 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -489,14 +489,16 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { addr0 := key0.Address() addr1 := key1.Address() - factory := txstest.NewWalletFactory( + wallet := txstest.NewWallet( + t, vm.ctx, &vm.Config, vm.state, + secp256k1fx.NewKeychain(key0), + nil, // subnetIDs + nil, // chainIDs ) - - builder, txSigner := factory.NewWallet(key0) - utx0, err := builder.NewCreateSubnetTx( + addSubnetTx0, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{addr0}, @@ -507,11 +509,17 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { }), ) require.NoError(err) - addSubnetTx0, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx0) - require.NoError(err) - builder, txSigner = factory.NewWallet(key1) - utx1, err := builder.NewCreateSubnetTx( + wallet = txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(key1), + nil, // subnetIDs + nil, // chainIDs + ) + addSubnetTx1, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{addr1}, @@ -522,10 +530,17 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { }), ) require.NoError(err) - addSubnetTx1, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx1) - require.NoError(err) - utx2, err := builder.NewCreateSubnetTx( + wallet = txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(key1), + nil, // subnetIDs + nil, // chainIDs + ) + addSubnetTx2, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{addr1}, @@ -536,8 +551,6 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { }), ) require.NoError(err) - addSubnetTx2, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx2) - require.NoError(err) preferredID := vm.manager.Preferred() preferred, err := vm.manager.GetBlock(preferredID) From ef1d3452b3ad1562a5a9e1f4c4aaa4354480e318 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 12:56:47 -0400 Subject: [PATCH 070/114] Simplify --- vms/platformvm/service_test.go | 80 ++++++++++++++++++++-------------- 1 file changed, 48 insertions(+), 32 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index a6e41ecfa0ad..4c5bf0b14c03 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -53,7 +53,6 @@ import ( blockbuilder "github.com/ava-labs/avalanchego/vms/platformvm/block/builder" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) var ( @@ -80,22 +79,21 @@ var ( } ) -func defaultService(t *testing.T) (*Service, *mutableSharedMemory, *txstest.WalletFactory) { - vm, factory, _, mutableSharedMemory := defaultVM(t, upgradetest.Latest) - +func defaultService(t *testing.T) (*Service, *mutableSharedMemory) { + vm, _, _, mutableSharedMemory := defaultVM(t, upgradetest.Latest) return &Service{ vm: vm, addrManager: avax.NewAddressManager(vm.ctx), stakerAttributesCache: &cache.LRU[ids.ID, *stakerAttributes]{ Size: stakerAttributesCacheSize, }, - }, mutableSharedMemory, factory + }, mutableSharedMemory } func TestExportKey(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) service.vm.ctx.Lock.Lock() ks := keystore.New(logging.NoLog{}, memdb.New()) @@ -125,7 +123,7 @@ func TestExportKey(t *testing.T) { // Test issuing a tx and accepted func TestGetTxStatus(t *testing.T) { require := require.New(t) - service, mutableSharedMemory, _ := defaultService(t) + service, mutableSharedMemory := defaultService(t) service.vm.ctx.Lock.Lock() recipientKey, err := secp256k1.NewPrivateKey() @@ -347,7 +345,7 @@ func TestGetTx(t *testing.T) { ) t.Run(testName, func(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) service.vm.ctx.Lock.Lock() tx := test.createTx(t, service) @@ -409,7 +407,7 @@ func TestGetTx(t *testing.T) { func TestGetBalance(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) feeCalculator := state.PickFeeCalculator(&service.vm.Config, service.vm.state) createSubnetFee, err := feeCalculator.CalculateFee(&txs.CreateSubnetTx{}) @@ -448,7 +446,7 @@ func TestGetBalance(t *testing.T) { func TestGetStake(t *testing.T) { require := require.New(t) - service, _, factory := defaultService(t) + service, _ := defaultService(t) // Ensure GetStake is correct for each of the genesis validators genesis := genesistest.New(t, genesistest.Config{}) @@ -534,12 +532,21 @@ func TestGetStake(t *testing.T) { service.vm.ctx.Lock.Lock() + wallet := txstest.NewWallet( + t, + service.vm.ctx, + &service.vm.Config, + service.vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), + nil, // subnetIDs + nil, // chainIDs + ) + // Add a delegator stakeAmount := service.vm.MinDelegatorStake + 12345 delegatorNodeID := genesistest.DefaultNodeIDs[0] delegatorEndTime := genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddDelegatorTx( + tx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: delegatorNodeID, Start: genesistest.DefaultValidatorStartTimeUnix, @@ -556,8 +563,6 @@ func TestGetStake(t *testing.T) { }), ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addDelTx := tx.Unsigned.(*txs.AddDelegatorTx) staker, err := state.NewCurrentStaker( @@ -602,7 +607,7 @@ func TestGetStake(t *testing.T) { stakeAmount = service.vm.MinValidatorStake + 54321 pendingStakerNodeID := ids.GenerateTestNodeID() pendingStakerEndTime := uint64(genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration).Unix()) - utx2, err := builder.NewAddValidatorTx( + tx, err = wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: pendingStakerNodeID, Start: uint64(genesistest.DefaultValidatorStartTime.Unix()), @@ -620,8 +625,6 @@ func TestGetStake(t *testing.T) { }), ) require.NoError(err) - tx, err = walletsigner.SignUnsigned(context.Background(), signer, utx2) - require.NoError(err) staker, err = state.NewPendingStaker( tx.ID(), @@ -655,7 +658,7 @@ func TestGetStake(t *testing.T) { func TestGetCurrentValidators(t *testing.T) { require := require.New(t) - service, _, factory := defaultService(t) + service, _ := defaultService(t) genesis := genesistest.New(t, genesistest.Config{}) @@ -692,8 +695,16 @@ func TestGetCurrentValidators(t *testing.T) { service.vm.ctx.Lock.Lock() - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddDelegatorTx( + wallet := txstest.NewWallet( + t, + service.vm.ctx, + &service.vm.Config, + service.vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), + nil, // subnetIDs + nil, // chainIDs + ) + delTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: validatorNodeID, Start: genesistest.DefaultValidatorStartTimeUnix, @@ -710,8 +721,6 @@ func TestGetCurrentValidators(t *testing.T) { }), ) require.NoError(err) - delTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addDelTx := delTx.Unsigned.(*txs.AddDelegatorTx) staker, err := state.NewCurrentStaker( @@ -793,7 +802,7 @@ func TestGetCurrentValidators(t *testing.T) { func TestGetTimestamp(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) reply := GetTimestampReply{} require.NoError(service.GetTimestamp(nil, nil, &reply)) @@ -829,14 +838,23 @@ func TestGetBlock(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { require := require.New(t) - service, _, factory := defaultService(t) + service, _ := defaultService(t) service.vm.ctx.Lock.Lock() service.vm.Config.CreateAssetTxFee = 100 * defaultTxFee - builder, signer := factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := txstest.NewWallet( + t, + service.vm.ctx, + &service.vm.Config, + service.vm.state, + secp256k1fx.NewKeychain(testSubnet1ControlKeys[:2]...), + []ids.ID{subnetID}, + nil, // chainIDs + ) + tx, err := wallet.IssueCreateChainTx( + subnetID, []byte{}, constants.AVMID, []ids.ID{}, @@ -847,8 +865,6 @@ func TestGetBlock(t *testing.T) { }), ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) preferredID := service.vm.manager.Preferred() preferred, err := service.vm.manager.GetBlock(preferredID) @@ -1121,7 +1137,7 @@ func TestServiceGetBlockByHeight(t *testing.T) { func TestServiceGetSubnets(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) testSubnet1ID := testSubnet1.ID() @@ -1193,7 +1209,7 @@ func TestGetFeeConfig(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) service.vm.Config.UpgradeConfig.EtnaTime = test.etnaTime var reply gas.Config @@ -1207,7 +1223,7 @@ func FuzzGetFeeState(f *testing.F) { f.Fuzz(func(t *testing.T, capacity, excess uint64) { require := require.New(t) - service, _, _ := defaultService(t) + service, _ := defaultService(t) var ( expectedState = gas.State{ From 7048e0f29db40ad5942fa78b96885a9e4ba39a31 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 13:58:27 -0400 Subject: [PATCH 071/114] Update TestAddDelegatorTxOverDelegatedRegression --- vms/platformvm/vm_regression_test.go | 111 ++++++++------------------- 1 file changed, 34 insertions(+), 77 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index be9834d95fbe..593f2c16fd09 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -51,101 +51,81 @@ import ( func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + validatorStartTime := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) nodeID := ids.GenerateTestNodeID() changeAddr := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{changeAddr}, + } // create valid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(validatorStartTime.Unix()), End: uint64(validatorEndTime.Unix()), Wght: vm.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() - addValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addValidatorBlock.Verify(context.Background())) - require.NoError(addValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) + // Advance the time vm.clock.Set(validatorStartTime) - - firstAdvanceTimeBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(firstAdvanceTimeBlock.Verify(context.Background())) - require.NoError(firstAdvanceTimeBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + require.NoError(buildAndAcceptStandardBlock(vm)) firstDelegatorStartTime := validatorStartTime.Add(executor.SyncBound).Add(1 * time.Second) firstDelegatorEndTime := firstDelegatorStartTime.Add(vm.MinStakeDuration) // create valid tx - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - uDelTx1, err := builder.NewAddDelegatorTx( + addFirstDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(firstDelegatorStartTime.Unix()), End: uint64(firstDelegatorEndTime.Unix()), Wght: 4 * vm.MinValidatorStake, // maximum amount of stake this delegator can provide }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addFirstDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx1) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addFirstDelegatorTx)) vm.ctx.Lock.Lock() - addFirstDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addFirstDelegatorBlock.Verify(context.Background())) - require.NoError(addFirstDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addFirstDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) + // Advance the time vm.clock.Set(firstDelegatorStartTime) - - secondAdvanceTimeBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(secondAdvanceTimeBlock.Verify(context.Background())) - require.NoError(secondAdvanceTimeBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + require.NoError(buildAndAcceptStandardBlock(vm)) secondDelegatorStartTime := firstDelegatorEndTime.Add(2 * time.Second) secondDelegatorEndTime := secondDelegatorStartTime.Add(vm.MinStakeDuration) @@ -153,62 +133,39 @@ func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { vm.clock.Set(secondDelegatorStartTime.Add(-10 * executor.SyncBound)) // create valid tx - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[3]) - uDelTx2, err := builder.NewAddDelegatorTx( + addSecondDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(secondDelegatorStartTime.Unix()), End: uint64(secondDelegatorEndTime.Unix()), Wght: vm.MinDelegatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addSecondDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx2) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addSecondDelegatorTx)) vm.ctx.Lock.Lock() - addSecondDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addSecondDelegatorBlock.Verify(context.Background())) - require.NoError(addSecondDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addSecondDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) thirdDelegatorStartTime := firstDelegatorEndTime.Add(-time.Second) thirdDelegatorEndTime := thirdDelegatorStartTime.Add(vm.MinStakeDuration) - // create valid tx - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - uDelTx3, err := builder.NewAddDelegatorTx( + // create invalid tx + addThirdDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(thirdDelegatorStartTime.Unix()), End: uint64(thirdDelegatorEndTime.Unix()), Wght: vm.MinDelegatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addThirdDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx3) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() From e851cfdb4481703a4a3c793f4df8278e7c91537d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:06:19 -0400 Subject: [PATCH 072/114] Update TestAddDelegatorTxHeapCorruption --- vms/platformvm/vm_regression_test.go | 128 ++++++++------------------- 1 file changed, 35 insertions(+), 93 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 593f2c16fd09..281eca7069a0 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -69,10 +69,9 @@ func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) nodeID := ids.GenerateTestNodeID() - changeAddr := genesistest.DefaultFundedKeys[0].Address() rewardsOwner := &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, } // create valid tx @@ -213,185 +212,128 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.ApricotPhase3) + vm, _, _, _ := defaultVM(t, upgradetest.ApricotPhase3) vm.UpgradeConfig.ApricotPhase3Time = test.ap3Time vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - key, err := secp256k1.NewPrivateKey() - require.NoError(err) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[:2]...), + nil, // subnetIDs + nil, // chainIDs + ) - id := key.Address() nodeID := ids.GenerateTestNodeID() - changeAddr := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + } // create valid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(validatorStartTime.Unix()), End: uint64(validatorEndTime.Unix()), Wght: validatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{id}, - }, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // issue the add validator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - addValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addValidatorBlock.Verify(context.Background())) - require.NoError(addValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) // create valid tx - uDelTx1, err := builder.NewAddDelegatorTx( + addFirstDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(delegator1StartTime.Unix()), End: uint64(delegator1EndTime.Unix()), Wght: delegator1Stake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addFirstDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx1) - require.NoError(err) // issue the first add delegator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addFirstDelegatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the first add delegator tx - addFirstDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addFirstDelegatorBlock.Verify(context.Background())) - require.NoError(addFirstDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addFirstDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) // create valid tx - uDelTx2, err := builder.NewAddDelegatorTx( + addSecondDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(delegator2StartTime.Unix()), End: uint64(delegator2EndTime.Unix()), Wght: delegator2Stake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addSecondDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx2) - require.NoError(err) // issue the second add delegator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addSecondDelegatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the second add delegator tx - addSecondDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addSecondDelegatorBlock.Verify(context.Background())) - require.NoError(addSecondDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addSecondDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) // create valid tx - uDelTx3, err := builder.NewAddDelegatorTx( + addThirdDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(delegator3StartTime.Unix()), End: uint64(delegator3EndTime.Unix()), Wght: delegator3Stake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addThirdDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx3) - require.NoError(err) // issue the third add delegator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addThirdDelegatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the third add delegator tx - addThirdDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addThirdDelegatorBlock.Verify(context.Background())) - require.NoError(addThirdDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addThirdDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) // create valid tx - uDelTx4, err := builder.NewAddDelegatorTx( + addFourthDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(delegator4StartTime.Unix()), End: uint64(delegator4EndTime.Unix()), Wght: delegator4Stake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addFourthDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx4) - require.NoError(err) // issue the fourth add delegator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addFourthDelegatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the fourth add delegator tx - addFourthDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addFourthDelegatorBlock.Verify(context.Background())) - require.NoError(addFourthDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addFourthDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) }) } } From 4c3437893c53a18a777ea112e1d34cd96558012d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:09:18 -0400 Subject: [PATCH 073/114] nit --- vms/platformvm/vm_regression_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 281eca7069a0..ea39b6047122 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -223,7 +223,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) { vm.ctx, &vm.Config, vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[:2]...), + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), nil, // subnetIDs nil, // chainIDs ) From 825dbd58c6982f67bf242655168e9d21214d80fa Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:12:07 -0400 Subject: [PATCH 074/114] Update TestRejectedStateRegressionInvalidValidatorTimestamp --- vms/platformvm/vm_regression_test.go | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index ea39b6047122..98ec099516d3 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -503,17 +503,26 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { require := require.New(t) - vm, factory, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) + vm, _, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + nodeID := ids.GenerateTestNodeID() newValidatorStartTime := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) newValidatorEndTime := newValidatorStartTime.Add(defaultMinStakingDuration) // Create the tx to add a new validator - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(newValidatorStartTime.Unix()), @@ -527,8 +536,6 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // Create the standard block to add the new validator preferredID := vm.manager.Preferred() From 902caa002fc4fd328ce78aec213a9c4f1a79a532 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:15:27 -0400 Subject: [PATCH 075/114] Update TestRejectedStateRegressionInvalidValidatorTimestamp --- vms/platformvm/vm_regression_test.go | 38 +++++++++++++++------------- 1 file changed, 20 insertions(+), 18 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 98ec099516d3..c244da068f22 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -704,35 +704,43 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { require := require.New(t) - vm, factory, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) + vm, _, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() vm.state.SetCurrentSupply(constants.PrimaryNetworkID, defaultRewardConfig.SupplyCap/2) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + + nodeID0 := ids.GenerateTestNodeID() newValidatorStartTime0 := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) newValidatorEndTime0 := newValidatorStartTime0.Add(defaultMaxStakingDuration) - nodeID0 := ids.GenerateTestNodeID() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } // Create the tx to add the first new validator - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + addValidatorTx0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID0, Start: uint64(newValidatorStartTime0.Unix()), End: uint64(newValidatorEndTime0.Unix()), Wght: vm.MaxValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - addValidatorTx0, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // Create the standard block to add the first new validator preferredID := vm.manager.Preferred() @@ -885,23 +893,17 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { nodeID1 := ids.GenerateTestNodeID() // Create the tx to add the second new validator - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[1]) - utx1, err := builder.NewAddValidatorTx( + addValidatorTx1, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID1, Start: uint64(newValidatorStartTime1.Unix()), End: uint64(newValidatorEndTime1.Unix()), Wght: vm.MaxValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - addValidatorTx1, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx1) - require.NoError(err) // Create the standard block to add the second new validator preferredChainTime = importBlk.Timestamp() From b44988dd6ec929f573c49c7b7ab1f2472223c532 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:30:57 -0400 Subject: [PATCH 076/114] Update TestAddDelegatorTxAddBeforeRemove --- vms/platformvm/vm_regression_test.go | 94 +++++++++++----------------- 1 file changed, 37 insertions(+), 57 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index c244da068f22..ab7b8f9e2a94 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -1013,7 +1013,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1034,14 +1034,23 @@ func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) { require.Equal(weight, validators[nodeID].Weight) } + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + newValidatorStartTime0 := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) newValidatorEndTime0 := newValidatorStartTime0.Add(defaultMaxStakingDuration) extraNodeID := ids.GenerateTestNodeID() // Create the tx to add the first new validator - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + addValidatorTx0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: extraNodeID, Start: uint64(newValidatorStartTime0.Unix()), @@ -1055,8 +1064,6 @@ func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addValidatorTx0, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // Create the standard block to add the first new validator preferredID := vm.manager.Preferred() @@ -1155,105 +1162,78 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) { delegator2EndTime := delegator2StartTime.Add(3 * defaultMinStakingDuration) delegator2Stake := defaultMaxValidatorStake - validatorStake - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - key, err := secp256k1.NewPrivateKey() - require.NoError(err) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) - id := key.Address() nodeID := ids.GenerateTestNodeID() - changeAddr := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } // create valid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(validatorStartTime.Unix()), End: uint64(validatorEndTime.Unix()), Wght: validatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{id}, - }, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // issue the add validator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - addValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addValidatorBlock.Verify(context.Background())) - require.NoError(addValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) // create valid tx - uDelTx, err := builder.NewAddDelegatorTx( + addFirstDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(delegator1StartTime.Unix()), End: uint64(delegator1EndTime.Unix()), Wght: delegator1Stake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addFirstDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx) - require.NoError(err) // issue the first add delegator tx vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addFirstDelegatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the first add delegator tx - addFirstDelegatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addFirstDelegatorBlock.Verify(context.Background())) - require.NoError(addFirstDelegatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addFirstDelegatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) - // create valid tx - uDelTx, err = builder.NewAddDelegatorTx( + // create invalid tx + addSecondDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(delegator2StartTime.Unix()), End: uint64(delegator2EndTime.Unix()), Wght: delegator2Stake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + rewardsOwner, ) require.NoError(err) - addSecondDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx) - require.NoError(err) // attempting to issue the second add delegator tx should fail because the // total stake weight would go over the limit. From 071bca3dad5a88163e729477b3841701777b3046 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:38:58 -0400 Subject: [PATCH 077/114] Update TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked --- vms/platformvm/vm_regression_test.go | 99 ++++++++++------------------ 1 file changed, 33 insertions(+), 66 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index ab7b8f9e2a94..37b0aff7c16f 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -1249,19 +1249,22 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t validatorStartTime := latestForkTime.Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - key, err := secp256k1.NewPrivateKey() - require.NoError(err) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) - id := key.Address() nodeID := ids.GenerateTestNodeID() - changeAddr := genesistest.DefaultFundedKeys[0].Address() - - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(validatorStartTime.Unix()), @@ -1270,55 +1273,36 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{id}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - addValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addValidatorBlock.Verify(context.Background())) - require.NoError(addValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) - uSubnetTx, err := builder.NewCreateSubnetTx( + createSubnetTx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - createSubnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uSubnetTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(createSubnetTx)) vm.ctx.Lock.Lock() - // trigger block creation for the subnet tx - createSubnetBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(createSubnetBlock.Verify(context.Background())) - require.NoError(createSubnetBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept createSubnetTx + require.NoError(buildAndAcceptStandardBlock(vm)) - uSubnetValTx, err := builder.NewAddSubnetValidatorTx( + subnetID := createSubnetTx.ID() + addSubnetValidatorTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1326,47 +1310,34 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t End: uint64(validatorEndTime.Unix()), Wght: defaultMaxValidatorStake, }, - Subnet: createSubnetTx.ID(), + Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addSubnetValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uSubnetValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addSubnetValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - addSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) + // Accept addSubnetValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) + + addSubnetValidatorHeight, err := vm.GetCurrentHeight(context.Background()) require.NoError(err) - require.NoError(addSubnetValidatorBlock.Verify(context.Background())) - require.NoError(addSubnetValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) emptyValidatorSet, err := vm.GetValidatorSet( context.Background(), - addSubnetValidatorBlock.Height(), - createSubnetTx.ID(), + addSubnetValidatorHeight, + subnetID, ) require.NoError(err) require.Empty(emptyValidatorSet) - uRemoveSubnetValTx, err := builder.NewRemoveSubnetValidatorTx( + removeSubnetValidatorTx, err := wallet.IssueRemoveSubnetValidatorTx( nodeID, - createSubnetTx.ID(), - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + subnetID, ) require.NoError(err) - removeSubnetValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uRemoveSubnetValTx) - require.NoError(err) // Set the clock so that the validator will be moved from the pending // validator set into the current validator set. @@ -1376,17 +1347,13 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t require.NoError(vm.issueTxFromRPC(removeSubnetValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - removeSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(removeSubnetValidatorBlock.Verify(context.Background())) - require.NoError(removeSubnetValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept removeSubnetValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) emptyValidatorSet, err = vm.GetValidatorSet( context.Background(), - addSubnetValidatorBlock.Height(), - createSubnetTx.ID(), + addSubnetValidatorHeight, + subnetID, ) require.NoError(err) require.Empty(emptyValidatorSet) From 06fd2674182e3bc7417a281f06c47531f24b3985 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 14:48:41 -0400 Subject: [PATCH 078/114] Update TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked --- vms/platformvm/vm_regression_test.go | 90 +++++++++------------------- 1 file changed, 27 insertions(+), 63 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 37b0aff7c16f..a6f3fc562570 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -1365,19 +1365,22 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t validatorStartTime := latestForkTime.Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - key, err := secp256k1.NewPrivateKey() - require.NoError(err) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) - id := key.Address() nodeID := ids.GenerateTestNodeID() - changeAddr := genesistest.DefaultFundedKeys[0].Address() - - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(validatorStartTime.Unix()), @@ -1386,55 +1389,36 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{id}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - addValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addValidatorBlock.Verify(context.Background())) - require.NoError(addValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) - uCreateSubnetTx, err := builder.NewCreateSubnetTx( + createSubnetTx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - createSubnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uCreateSubnetTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(createSubnetTx)) vm.ctx.Lock.Lock() - // trigger block creation for the subnet tx - createSubnetBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(createSubnetBlock.Verify(context.Background())) - require.NoError(createSubnetBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept createSubnetTx + require.NoError(buildAndAcceptStandardBlock(vm)) - uAddSubnetValTx, err := builder.NewAddSubnetValidatorTx( + subnetID := createSubnetTx.ID() + addSubnetValidatorTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1442,39 +1426,23 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t End: uint64(validatorEndTime.Unix()), Wght: defaultMaxValidatorStake, }, - Subnet: createSubnetTx.ID(), + Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - addSubnetValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddSubnetValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addSubnetValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - addSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addSubnetValidatorBlock.Verify(context.Background())) - require.NoError(addSubnetValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept addSubnetValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) - uRemoveSubnetValTx, err := builder.NewRemoveSubnetValidatorTx( + removeSubnetValidatorTx, err := wallet.IssueRemoveSubnetValidatorTx( nodeID, - createSubnetTx.ID(), - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + subnetID, ) require.NoError(err) - removeSubnetValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uRemoveSubnetValTx) - require.NoError(err) // Set the clock so that the validator will be moved from the pending // validator set into the current validator set. @@ -1484,12 +1452,8 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t require.NoError(vm.issueTxFromRPC(removeSubnetValidatorTx)) vm.ctx.Lock.Lock() - // trigger block creation for the validator tx - removeSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(removeSubnetValidatorBlock.Verify(context.Background())) - require.NoError(removeSubnetValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + // Accept removeSubnetValidatorTx + require.NoError(buildAndAcceptStandardBlock(vm)) } // GetValidatorSet must return the BLS keys for a given validator correctly when From 86740fd269e35f76151c7efaa9f16841c18cb201 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 15:25:51 -0400 Subject: [PATCH 079/114] Update TestSubnetValidatorBLSKeyDiffAfterExpiry --- vms/platformvm/vm_regression_test.go | 106 +++++++++------------------ 1 file changed, 35 insertions(+), 71 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index a6f3fc562570..77285438251f 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -1461,20 +1461,24 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.TxID - - // setup time - currentTime := genesistest.DefaultValidatorStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{subnetID}, + nil, // chainIDs + ) // A subnet validator stakes and then stops; also its primary network counterpart stops staking var ( - primaryStartTime = currentTime.Add(executor.SyncBound) + primaryStartTime = genesistest.DefaultValidatorStartTime.Add(executor.SyncBound) subnetStartTime = primaryStartTime.Add(executor.SyncBound) subnetEndTime = subnetStartTime.Add(defaultMinStakingDuration) primaryEndTime = subnetEndTime.Add(time.Second) @@ -1484,15 +1488,18 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { // insert primary network validator var ( - nodeID = ids.GenerateTestNodeID() - addr = genesistest.DefaultFundedKeys[0].Address() + nodeID = ids.GenerateTestNodeID() + rewardsOwner = &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } ) sk1, err := bls.NewSecretKey() require.NoError(err) + pk1 := bls.PublicFromSecretKey(sk1) // build primary network validator with BLS key - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys...) - uPrimaryTx, err := builder.NewAddPermissionlessValidatorTx( + primaryTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1504,23 +1511,11 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { }, signer.NewProofOfPossession(sk1), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uPrimaryTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryTx)) @@ -1528,9 +1523,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting primary validator to current - currentTime = primaryStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(primaryStartTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) @@ -1540,8 +1533,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { require.NoError(err) // insert the subnet validator - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - uAddSubnetValTx, err := builder.NewAddSubnetValidatorTx( + subnetTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1551,14 +1543,8 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { }, Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - subnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddSubnetValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(subnetTx)) @@ -1566,9 +1552,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting the subnet validator to current - currentTime = subnetStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(subnetStartTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(subnetID, nodeID) @@ -1578,9 +1562,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { require.NoError(err) // move time ahead, terminating the subnet validator - currentTime = subnetEndTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(subnetEndTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(subnetID, nodeID) @@ -1590,10 +1572,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { require.NoError(err) // move time ahead, terminating primary network validator - currentTime = primaryEndTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) - + vm.clock.Set(primaryEndTime) blk, err := vm.Builder.BuildBlock(context.Background()) // must be a proposal block rewarding the primary validator require.NoError(err) require.NoError(blk.Verify(context.Background())) @@ -1619,10 +1598,9 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { // reinsert primary validator with a different BLS key sk2, err := bls.NewSecretKey() require.NoError(err) - require.NotEqual(sk1, sk2) + pk2 := bls.PublicFromSecretKey(sk2) - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys...) - uPrimaryRestartTx, err := builder.NewAddPermissionlessValidatorTx( + primaryRestartTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1634,23 +1612,11 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { }, signer.NewProofOfPossession(sk2), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryRestartTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uPrimaryRestartTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryRestartTx)) @@ -1658,9 +1624,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting restarted primary validator to current - currentTime = primaryReStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(primaryReStartTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) @@ -1676,7 +1640,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { nodeID, constants.PrimaryNetworkID, height, - uPrimaryTx.Signer.Key(), + pk1, )) } for height := primaryEndHeight; height < primaryRestartHeight; height++ { @@ -1685,7 +1649,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { nodeID, constants.PrimaryNetworkID, primaryEndHeight, - uPrimaryTx.Signer.Key(), + pk1, ) require.ErrorIs(err, database.ErrNotFound) } @@ -1694,7 +1658,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { nodeID, constants.PrimaryNetworkID, primaryRestartHeight, - uPrimaryRestartTx.Signer.Key(), + pk2, )) for height := subnetStartHeight; height < subnetEndHeight; height++ { @@ -1703,7 +1667,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { nodeID, subnetID, height, - uPrimaryTx.Signer.Key(), + pk1, )) } @@ -1713,7 +1677,7 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { nodeID, subnetID, primaryEndHeight, - uPrimaryTx.Signer.Key(), + pk1, ) require.ErrorIs(err, database.ErrNotFound) } From e0f7f8b0fe5bbbe0e6550190c1cc185df1e5f6e9 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 15:30:52 -0400 Subject: [PATCH 080/114] Update TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff --- vms/platformvm/vm_regression_test.go | 75 ++++++++++------------------ 1 file changed, 26 insertions(+), 49 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 77285438251f..c2a0753c3d04 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -1690,18 +1690,23 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - // setup time - currentTime := genesistest.DefaultValidatorStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) // A primary network validator stake twice var ( - primaryStartTime1 = currentTime.Add(executor.SyncBound) + primaryStartTime1 = genesistest.DefaultValidatorStartTime.Add(executor.SyncBound) primaryEndTime1 = primaryStartTime1.Add(defaultMinStakingDuration) primaryStartTime2 = primaryEndTime1.Add(executor.SyncBound) primaryEndTime2 = primaryStartTime2.Add(defaultMinStakingDuration) @@ -1709,29 +1714,22 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // Add a primary network validator with no BLS key nodeID := ids.GenerateTestNodeID() - addr := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uAddValTx1, err := builder.NewAddValidatorTx( + primaryTx1, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(primaryStartTime1.Unix()), End: uint64(primaryEndTime1.Unix()), Wght: vm.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryTx1, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddValTx1) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryTx1)) @@ -1739,9 +1737,7 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting primary validator to current - currentTime = primaryStartTime1 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(primaryStartTime1) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) @@ -1751,10 +1747,7 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(err) // move time ahead, terminating primary network validator - currentTime = primaryEndTime1 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) - + vm.clock.Set(primaryEndTime1) blk, err := vm.Builder.BuildBlock(context.Background()) // must be a proposal block rewarding the primary validator require.NoError(err) require.NoError(blk.Verify(context.Background())) @@ -1778,11 +1771,10 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(err) // reinsert primary validator with a different BLS key - sk2, err := bls.NewSecretKey() + sk, err := bls.NewSecretKey() require.NoError(err) - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys...) - uPrimaryRestartTx, err := builder.NewAddPermissionlessValidatorTx( + primaryRestartTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1792,25 +1784,13 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { }, Subnet: constants.PrimaryNetworkID, }, - signer.NewProofOfPossession(sk2), + signer.NewProofOfPossession(sk), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryRestartTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uPrimaryRestartTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryRestartTx)) @@ -1818,22 +1798,19 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting restarted primary validator to current - currentTime = primaryStartTime2 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(primaryStartTime2) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) require.NoError(err) - emptySigner := &signer.Empty{} for height := primaryStartHeight; height < primaryEndHeight; height++ { require.NoError(checkValidatorBlsKeyIsSet( vm.State, nodeID, constants.PrimaryNetworkID, height, - emptySigner.Key(), + nil, )) } } From 38c74582023cdb401d5860efcddbf85e5f1f7697 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 15:35:49 -0400 Subject: [PATCH 081/114] Update TestSubnetValidatorPopulatedToEmptyBLSKeyDiff --- vms/platformvm/vm_regression_test.go | 93 +++++++++------------------- 1 file changed, 29 insertions(+), 64 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index c2a0753c3d04..95a0972de2d7 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -1823,20 +1823,24 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.TxID - - // setup time - currentTime := genesistest.DefaultValidatorStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{subnetID}, + nil, // chainIDs + ) // A primary network validator stake twice var ( - primaryStartTime1 = currentTime.Add(executor.SyncBound) + primaryStartTime1 = genesistest.DefaultValidatorStartTime.Add(executor.SyncBound) subnetStartTime = primaryStartTime1.Add(executor.SyncBound) subnetEndTime = subnetStartTime.Add(defaultMinStakingDuration) primaryEndTime1 = subnetEndTime.Add(time.Second) @@ -1846,29 +1850,22 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // Add a primary network validator with no BLS key nodeID := ids.GenerateTestNodeID() - addr := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uPrimaryTx1, err := builder.NewAddValidatorTx( + primaryTx1, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(primaryStartTime1.Unix()), End: uint64(primaryEndTime1.Unix()), Wght: vm.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryTx1, err := walletsigner.SignUnsigned(context.Background(), txSigner, uPrimaryTx1) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryTx1)) @@ -1876,9 +1873,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting primary validator to current - currentTime = primaryStartTime1 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(primaryStartTime1) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) @@ -1888,8 +1883,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(err) // insert the subnet validator - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - uAddSubnetValTx, err := builder.NewAddSubnetValidatorTx( + subnetTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1899,14 +1893,8 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { }, Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - subnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddSubnetValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(subnetTx)) @@ -1914,9 +1902,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting the subnet validator to current - currentTime = subnetStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(subnetStartTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(subnetID, nodeID) @@ -1926,9 +1912,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(err) // move time ahead, terminating the subnet validator - currentTime = subnetEndTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(subnetEndTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(subnetID, nodeID) @@ -1938,10 +1922,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(err) // move time ahead, terminating primary network validator - currentTime = primaryEndTime1 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) - + vm.clock.Set(primaryEndTime1) blk, err := vm.Builder.BuildBlock(context.Background()) // must be a proposal block rewarding the primary validator require.NoError(err) require.NoError(blk.Verify(context.Background())) @@ -1968,8 +1949,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { sk2, err := bls.NewSecretKey() require.NoError(err) - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys...) - uPrimaryRestartTx, err := builder.NewAddPermissionlessValidatorTx( + primaryRestartTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1981,23 +1961,11 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { }, signer.NewProofOfPossession(sk2), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryRestartTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uPrimaryRestartTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryRestartTx)) @@ -2005,22 +1973,19 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting restarted primary validator to current - currentTime = primaryStartTime2 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) - + vm.clock.Set(primaryStartTime2) require.NoError(buildAndAcceptStandardBlock(vm)) + _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) require.NoError(err) - emptySigner := &signer.Empty{} for height := primaryStartHeight; height < primaryEndHeight; height++ { require.NoError(checkValidatorBlsKeyIsSet( vm.State, nodeID, constants.PrimaryNetworkID, height, - emptySigner.Key(), + nil, )) } for height := subnetStartHeight; height < subnetEndHeight; height++ { @@ -2029,7 +1994,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { nodeID, subnetID, height, - emptySigner.Key(), + nil, )) } } From 7ec49508714f2c11c2e62a86f48cce6364dfd0b2 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 15:50:49 -0400 Subject: [PATCH 082/114] Update TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval --- vms/platformvm/vm_regression_test.go | 57 +++++++++------------------- 1 file changed, 18 insertions(+), 39 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 95a0972de2d7..e8f2a3e16e8f 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -45,7 +45,6 @@ import ( "github.com/ava-labs/avalanchego/vms/secp256k1fx" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) @@ -2007,20 +2006,24 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { // setup require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.TxID - - // setup time - currentTime := genesistest.DefaultValidatorStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{subnetID}, + nil, // chainIDs + ) // A primary network validator stake twice var ( - primaryStartTime1 = currentTime.Add(executor.SyncBound) + primaryStartTime1 = genesistest.DefaultValidatorStartTime.Add(executor.SyncBound) subnetStartTime = primaryStartTime1.Add(executor.SyncBound) subnetEndTime = subnetStartTime.Add(defaultMinStakingDuration) primaryEndTime1 = subnetEndTime.Add(time.Second) @@ -2028,10 +2031,8 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { // Add a primary network validator with no BLS key nodeID := ids.GenerateTestNodeID() - addr := genesistest.DefaultFundedKeys[0].Address() - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uPrimaryTx1, err := builder.NewAddValidatorTx( + primaryTx1, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(primaryStartTime1.Unix()), @@ -2040,17 +2041,11 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{addr}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - primaryTx1, err := walletsigner.SignUnsigned(context.Background(), txSigner, uPrimaryTx1) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(primaryTx1)) @@ -2058,17 +2053,14 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting primary validator to current - currentTime = primaryStartTime1 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(primaryStartTime1) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(constants.PrimaryNetworkID, nodeID) require.NoError(err) // insert the subnet validator - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - uAddSubnetValTx, err := builder.NewAddSubnetValidatorTx( + subnetTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -2078,14 +2070,8 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { }, Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) - subnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddSubnetValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(subnetTx)) @@ -2093,9 +2079,7 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { require.NoError(buildAndAcceptStandardBlock(vm)) // move time ahead, promoting the subnet validator to current - currentTime = subnetStartTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(subnetStartTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(subnetID, nodeID) @@ -2105,19 +2089,14 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { require.NoError(err) // move time ahead, terminating the subnet validator - currentTime = subnetEndTime - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) + vm.clock.Set(subnetEndTime) require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetCurrentValidator(subnetID, nodeID) require.ErrorIs(err, database.ErrNotFound) // move time ahead, terminating primary network validator - currentTime = primaryEndTime1 - vm.clock.Set(currentTime) - vm.state.SetTimestamp(currentTime) - + vm.clock.Set(primaryEndTime1) blk, err := vm.Builder.BuildBlock(context.Background()) // must be a proposal block rewarding the primary validator require.NoError(err) require.NoError(blk.Verify(context.Background())) From cdd06ee01c3d29c8acf8246472ed5f68cc6e71af Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 15:56:58 -0400 Subject: [PATCH 083/114] Update TestAddValidatorCommit --- vms/platformvm/vm_test.go | 45 +++++++++++++++++++-------------------- 1 file changed, 22 insertions(+), 23 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index e6cfada5e7f7..e747838a2eb2 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -290,23 +290,35 @@ func TestGenesis(t *testing.T) { // accept proposal to add validator to primary network func TestAddValidatorCommit(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + var ( - startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) - endTime = startTime.Add(defaultMinStakingDuration) - nodeID = ids.GenerateTestNodeID() - rewardAddress = ids.GenerateTestShortID() + startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) + endTime = startTime.Add(defaultMinStakingDuration) + nodeID = ids.GenerateTestNodeID() + rewardsOwner = &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } ) sk, err := bls.NewSecretKey() require.NoError(err) // create valid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddPermissionlessValidatorTx( + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -318,30 +330,17 @@ func TestAddValidatorCommit(t *testing.T) { }, signer.NewProofOfPossession(sk), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(tx)) vm.ctx.Lock.Lock() - - blk, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - require.NoError(blk.Verify(context.Background())) - require.NoError(blk.Accept(context.Background())) + require.NoError(buildAndAcceptStandardBlock(vm)) _, txStatus, err := vm.state.GetTx(tx.ID()) require.NoError(err) From 348d9274124be6e0710ba827ad5b9d58ba255885 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 15:58:51 -0400 Subject: [PATCH 084/114] Update TestInvalidAddValidatorCommit --- vms/platformvm/vm_test.go | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index e747838a2eb2..1c9bab74aca3 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -354,17 +354,26 @@ func TestAddValidatorCommit(t *testing.T) { // verify invalid attempt to add validator to primary network func TestInvalidAddValidatorCommit(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + nodeID := ids.GenerateTestNodeID() startTime := genesistest.DefaultValidatorStartTime.Add(-txexecutor.SyncBound).Add(-1 * time.Second) endTime := startTime.Add(defaultMinStakingDuration) // create invalid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), @@ -378,8 +387,6 @@ func TestInvalidAddValidatorCommit(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) preferredID := vm.manager.Preferred() preferred, err := vm.manager.GetBlock(preferredID) From 24e7268b9205362ad5a2f5f67421cdd172915222 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:00:19 -0400 Subject: [PATCH 085/114] Update TestAddValidatorReject --- vms/platformvm/vm_test.go | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 1c9bab74aca3..d655e3f4f78d 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -417,10 +417,20 @@ func TestInvalidAddValidatorCommit(t *testing.T) { // Reject attempt to add validator to primary network func TestAddValidatorReject(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) endTime = startTime.Add(defaultMinStakingDuration) @@ -429,8 +439,7 @@ func TestAddValidatorReject(t *testing.T) { ) // create valid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), @@ -444,8 +453,6 @@ func TestAddValidatorReject(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() From d3bba26807b9e7a1340e053754fa0bc1b8584908 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:01:59 -0400 Subject: [PATCH 086/114] Update TestAddValidatorInvalidNotReissued --- vms/platformvm/vm_test.go | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index d655e3f4f78d..f2b6e7abae17 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -475,10 +475,20 @@ func TestAddValidatorReject(t *testing.T) { // Reject proposal to add validator to primary network func TestAddValidatorInvalidNotReissued(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + // Use nodeID that is already in the genesis repeatNodeID := genesistest.DefaultNodeIDs[0] @@ -488,9 +498,13 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) { sk, err := bls.NewSecretKey() require.NoError(err) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + // create valid tx - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddPermissionlessValidatorTx( + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: repeatNodeID, @@ -502,19 +516,11 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) { }, signer.NewProofOfPossession(sk), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() From 4daa47a5b2346268c77957bce707720a6130306f Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:04:05 -0400 Subject: [PATCH 087/114] Update TestAddSubnetValidatorAccept --- vms/platformvm/vm_test.go | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index f2b6e7abae17..7f798f981dcc 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -532,10 +532,21 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) { // Accept proposal to add validator to subnet func TestAddSubnetValidatorAccept(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + subnetID := testSubnet1.ID() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{subnetID}, + nil, // chainIDs + ) + var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) endTime = startTime.Add(defaultMinStakingDuration) @@ -545,8 +556,7 @@ func TestAddSubnetValidatorAccept(t *testing.T) { // create valid tx // note that [startTime, endTime] is a subset of time that keys[0] // validates primary network ([genesistest.DefaultValidatorStartTime, genesistest.DefaultValidatorEndTime]) - builder, txSigner := factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -554,30 +564,23 @@ func TestAddSubnetValidatorAccept(t *testing.T) { End: uint64(endTime.Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(tx)) vm.ctx.Lock.Lock() - - blk, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - require.NoError(blk.Verify(context.Background())) - require.NoError(blk.Accept(context.Background())) + require.NoError(buildAndAcceptStandardBlock(vm)) _, txStatus, err := vm.state.GetTx(tx.ID()) require.NoError(err) require.Equal(status.Committed, txStatus) // Verify that new validator is in current validator set - _, err = vm.state.GetCurrentValidator(testSubnet1.ID(), nodeID) + _, err = vm.state.GetCurrentValidator(subnetID, nodeID) require.NoError(err) } From 23f9722c494f3559c597acc4aee1067a2ecf08e3 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:05:22 -0400 Subject: [PATCH 088/114] Update TestAddSubnetValidatorReject --- vms/platformvm/vm_test.go | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 7f798f981dcc..6f4c990e549e 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -587,10 +587,21 @@ func TestAddSubnetValidatorAccept(t *testing.T) { // Reject proposal to add validator to subnet func TestAddSubnetValidatorReject(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() + subnetID := testSubnet1.ID() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{subnetID}, + nil, // chainIDs + ) + var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) endTime = startTime.Add(defaultMinStakingDuration) @@ -600,8 +611,7 @@ func TestAddSubnetValidatorReject(t *testing.T) { // create valid tx // note that [startTime, endTime] is a subset of time that keys[0] // validates primary network ([genesistest.DefaultValidatorStartTime, genesistest.DefaultValidatorEndTime]) - builder, txSigner := factory.NewWallet(testSubnet1ControlKeys[1], testSubnet1ControlKeys[2]) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -613,8 +623,6 @@ func TestAddSubnetValidatorReject(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // trigger block creation vm.ctx.Lock.Unlock() From afc428791ef27fe3cc99edce8ee128f89c0dd00e Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:11:43 -0400 Subject: [PATCH 089/114] Update TestCreateChain --- vms/platformvm/vm_test.go | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 6f4c990e549e..b8bef3cea837 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -795,39 +795,41 @@ func TestUnneededBuildBlock(t *testing.T) { // test acceptance of proposal to create a new chain func TestCreateChain(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - builder, txSigner := factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + []ids.ID{subnetID}, + nil, // chainIDs + ) + + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, ids.ID{'t', 'e', 's', 't', 'v', 'm'}, nil, "name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(tx)) vm.ctx.Lock.Lock() - - blk, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) // should contain proposal to create chain - - require.NoError(blk.Verify(context.Background())) - - require.NoError(blk.Accept(context.Background())) + require.NoError(buildAndAcceptStandardBlock(vm)) _, txStatus, err := vm.state.GetTx(tx.ID()) require.NoError(err) require.Equal(status.Committed, txStatus) // Verify chain was created - chains, err := vm.state.GetChains(testSubnet1.ID()) + chains, err := vm.state.GetChains(subnetID) require.NoError(err) foundNewChain := false From faa2b1ebc7fbf1ad20bfe87f3c99c0ada75992e0 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:18:18 -0400 Subject: [PATCH 090/114] Update TestCreateSubnet --- vms/platformvm/vm_test.go | 53 ++++++++++++++------------------------- 1 file changed, 19 insertions(+), 34 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index b8bef3cea837..218466b4620c 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -847,12 +847,21 @@ func TestCreateChain(t *testing.T) { // 3) Advance timestamp to validator's end time (removing validator from current) func TestCreateSubnet(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uCreateSubnetTx, err := builder.NewCreateSubnetTx( + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) + + createSubnetTx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{ @@ -860,28 +869,15 @@ func TestCreateSubnet(t *testing.T) { genesistest.DefaultFundedKeys[1].Address(), }, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) - createSubnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uCreateSubnetTx) - require.NoError(err) - subnetID := createSubnetTx.ID() vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(createSubnetTx)) vm.ctx.Lock.Lock() + require.NoError(buildAndAcceptStandardBlock(vm)) - // should contain the CreateSubnetTx - blk, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - require.NoError(blk.Verify(context.Background())) - require.NoError(blk.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) - + subnetID := createSubnetTx.ID() _, txStatus, err := vm.state.GetTx(subnetID) require.NoError(err) require.Equal(status.Committed, txStatus) @@ -895,7 +891,7 @@ func TestCreateSubnet(t *testing.T) { startTime := vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) endTime := startTime.Add(defaultMinStakingDuration) // [startTime, endTime] is subset of time keys[0] validates default subnet so tx is valid - uAddValTx, err := builder.NewAddSubnetValidatorTx( + addValidatorTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -907,21 +903,13 @@ func TestCreateSubnet(t *testing.T) { }, ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() + require.NoError(buildAndAcceptStandardBlock(vm)) - blk, err = vm.Builder.BuildBlock(context.Background()) // should add validator to the new subnet - require.NoError(err) - - require.NoError(blk.Verify(context.Background())) - require.NoError(blk.Accept(context.Background())) // add the validator to current validator set - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) - - txID := blk.(block.Block).Txs()[0].ID() + txID := addValidatorTx.ID() _, txStatus, err = vm.state.GetTx(txID) require.NoError(err) require.Equal(status.Committed, txStatus) @@ -932,12 +920,9 @@ func TestCreateSubnet(t *testing.T) { _, err = vm.state.GetCurrentValidator(subnetID, nodeID) require.NoError(err) - // fast forward clock to time validator should stop validating + // remove validator from current validator set vm.clock.Set(endTime) - blk, err = vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(blk.Verify(context.Background())) - require.NoError(blk.Accept(context.Background())) // remove validator from current validator set + require.NoError(buildAndAcceptStandardBlock(vm)) _, err = vm.state.GetPendingValidator(subnetID, nodeID) require.ErrorIs(err, database.ErrNotFound) From 4e2f005d5d208002089420ebf3ffceea3f2b7da0 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:33:47 -0400 Subject: [PATCH 091/114] Update TestAtomicImport --- vms/platformvm/vm_test.go | 71 ++++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 35 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 218466b4620c..16cebc2d1a0a 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -934,43 +934,46 @@ func TestCreateSubnet(t *testing.T) { // test asset import func TestAtomicImport(t *testing.T) { require := require.New(t) - vm, factory, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Latest) + vm, _, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - utxoID := avax.UTXOID{ - TxID: ids.Empty.Prefix(1), - OutputIndex: 1, - } - amount := uint64(50000) recipientKey := genesistest.DefaultFundedKeys[1] + importOwners := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{recipientKey.Address()}, + } m := atomic.NewMemory(prefixdb.New([]byte{5}, baseDB)) - mutableSharedMemory.SharedMemory = m.NewSharedMemory(vm.ctx.ChainID) - peerSharedMemory := m.NewSharedMemory(vm.ctx.XChainID) - builder, _ := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - _, err := builder.NewImportTx( + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + []ids.ID{vm.ctx.XChainID}, + ) + _, err := wallet.IssueImportTx( vm.ctx.XChainID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{recipientKey.Address()}, - }, + importOwners, ) require.ErrorIs(err, walletbuilder.ErrInsufficientFunds) // Provide the avm UTXO - + peerSharedMemory := m.NewSharedMemory(vm.ctx.XChainID) + utxoID := avax.UTXOID{ + TxID: ids.GenerateTestID(), + OutputIndex: 1, + } utxo := &avax.UTXO{ UTXOID: utxoID, Asset: avax.Asset{ID: vm.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ - Amt: amount, - OutputOwners: secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{recipientKey.Address()}, - }, + Amt: 50 * units.MicroAvax, + OutputOwners: *importOwners, }, } utxoBytes, err := txs.Codec.Marshal(txs.CodecVersion, utxo) @@ -991,28 +994,26 @@ func TestAtomicImport(t *testing.T) { }, })) - builder, txSigner := factory.NewWallet(recipientKey) - utx, err := builder.NewImportTx( + // The wallet must be re-loaded because the shared memory has changed + wallet = txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + []ids.ID{vm.ctx.XChainID}, + ) + tx, err := wallet.IssueImportTx( vm.ctx.XChainID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{recipientKey.Address()}, - }, + importOwners, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(tx)) vm.ctx.Lock.Lock() - - blk, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - require.NoError(blk.Verify(context.Background())) - - require.NoError(blk.Accept(context.Background())) + require.NoError(buildAndAcceptStandardBlock(vm)) _, txStatus, err := vm.state.GetTx(tx.ID()) require.NoError(err) From 2b6e50168b82ad99d970474d040580e2a14ebf6e Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:42:54 -0400 Subject: [PATCH 092/114] Update TestRemovePermissionedValidatorDuringAddPending --- vms/platformvm/vm_test.go | 96 +++++++++++++-------------------------- 1 file changed, 32 insertions(+), 64 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 16cebc2d1a0a..20d44333f3b1 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -39,7 +39,6 @@ import ( "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/math/meter" "github.com/ava-labs/avalanchego/utils/resource" @@ -1962,20 +1961,29 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { validatorStartTime := latestForkTime.Add(txexecutor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - key, err := secp256k1.NewPrivateKey() - require.NoError(err) + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) - id := key.Address() nodeID := ids.GenerateTestNodeID() sk, err := bls.NewSecretKey() require.NoError(err) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uAddValTx, err := builder.NewAddPermissionlessValidatorTx( + addValidatorTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1987,62 +1995,32 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { }, signer.NewProofOfPossession(sk), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{id}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{id}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() + require.NoError(buildAndAcceptStandardBlock(vm)) - // trigger block creation for the validator tx - addValidatorBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(addValidatorBlock.Verify(context.Background())) - require.NoError(addValidatorBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) - - uCreateSubnetTx, err := builder.NewCreateSubnetTx( + createSubnetTx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{id}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), + }, ) require.NoError(err) - createSubnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uCreateSubnetTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(createSubnetTx)) vm.ctx.Lock.Lock() + require.NoError(buildAndAcceptStandardBlock(vm)) - // trigger block creation for the subnet tx - createSubnetBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(createSubnetBlock.Verify(context.Background())) - require.NoError(createSubnetBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) - - builder, txSigner = factory.NewWallet(key, genesistest.DefaultFundedKeys[1]) - uAddSubnetValTx, err := builder.NewAddSubnetValidatorTx( + subnetID := createSubnetTx.ID() + addSubnetValidatorTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -2050,34 +2028,24 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { End: uint64(validatorEndTime.Unix()), Wght: defaultMaxValidatorStake, }, - Subnet: createSubnetTx.ID(), + Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[1].Address()}, - }), ) require.NoError(err) - addSubnetValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddSubnetValTx) - require.NoError(err) - builder, txSigner = factory.NewWallet(key, genesistest.DefaultFundedKeys[2]) - uRemoveSubnetValTx, err := builder.NewRemoveSubnetValidatorTx( + removeSubnetValidatorTx, err := wallet.IssueRemoveSubnetValidatorTx( nodeID, - createSubnetTx.ID(), - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[2].Address()}, - }), + subnetID, ) require.NoError(err) - removeSubnetValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uRemoveSubnetValTx) - require.NoError(err) + lastAcceptedID := vm.state.GetLastAccepted() + lastAcceptedHeight, err := vm.GetCurrentHeight(context.Background()) + require.NoError(err) statelessBlock, err := block.NewBanffStandardBlock( vm.state.GetTimestamp(), - createSubnetBlock.ID(), - createSubnetBlock.Height()+1, + lastAcceptedID, + lastAcceptedHeight+1, []*txs.Tx{ addSubnetValidatorTx, removeSubnetValidatorTx, @@ -2092,7 +2060,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { require.NoError(block.Accept(context.Background())) require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) - _, err = vm.state.GetPendingValidator(createSubnetTx.ID(), nodeID) + _, err = vm.state.GetPendingValidator(subnetID, nodeID) require.ErrorIs(err, database.ErrNotFound) } From 37b81adce23ebbd7e97565a3dcb59f50b58633ff Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 16:54:00 -0400 Subject: [PATCH 093/114] Update TestTransferSubnetOwnershipTx --- vms/platformvm/vm_test.go | 88 ++++++++++++--------------------------- 1 file changed, 27 insertions(+), 61 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 20d44333f3b1..5d0fdc002ded 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -2066,91 +2066,57 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { func TestTransferSubnetOwnershipTx(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uCreateSubnetTx, err := builder.NewCreateSubnetTx( - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs ) - require.NoError(err) - createSubnetTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uCreateSubnetTx) - require.NoError(err) - subnetID := createSubnetTx.ID() + expectedSubnetOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + } + createSubnetTx, err := wallet.IssueCreateSubnetTx( + expectedSubnetOwner, + ) + require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(createSubnetTx)) vm.ctx.Lock.Lock() - createSubnetBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - createSubnetRawBlock := createSubnetBlock.(*blockexecutor.Block).Block - require.IsType(&block.BanffStandardBlock{}, createSubnetRawBlock) - require.Contains(createSubnetRawBlock.Txs(), createSubnetTx) - - require.NoError(createSubnetBlock.Verify(context.Background())) - require.NoError(createSubnetBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + require.NoError(buildAndAcceptStandardBlock(vm)) + subnetID := createSubnetTx.ID() subnetOwner, err := vm.state.GetSubnetOwner(subnetID) require.NoError(err) - expectedOwner := &secp256k1fx.OutputOwners{ - Locktime: 0, + require.Equal(expectedSubnetOwner, subnetOwner) + + expectedSubnetOwner = &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{ - genesistest.DefaultFundedKeys[0].Address(), - }, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[1].Address()}, } - ctx, err := walletbuilder.NewSnowContext(vm.ctx.NetworkID, vm.ctx.AVAXAssetID) - require.NoError(err) - expectedOwner.InitCtx(ctx) - require.Equal(expectedOwner, subnetOwner) - - uTransferSubnetOwnershipTx, err := builder.NewTransferSubnetOwnershipTx( + transferSubnetOwnershipTx, err := wallet.IssueTransferSubnetOwnershipTx( subnetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[1].Address()}, - }, + expectedSubnetOwner, ) require.NoError(err) - transferSubnetOwnershipTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uTransferSubnetOwnershipTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(transferSubnetOwnershipTx)) vm.ctx.Lock.Lock() - transferSubnetOwnershipBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - transferSubnetOwnershipRawBlock := transferSubnetOwnershipBlock.(*blockexecutor.Block).Block - require.IsType(&block.BanffStandardBlock{}, transferSubnetOwnershipRawBlock) - require.Contains(transferSubnetOwnershipRawBlock.Txs(), transferSubnetOwnershipTx) - - require.NoError(transferSubnetOwnershipBlock.Verify(context.Background())) - require.NoError(transferSubnetOwnershipBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + require.NoError(buildAndAcceptStandardBlock(vm)) subnetOwner, err = vm.state.GetSubnetOwner(subnetID) require.NoError(err) - expectedOwner = &secp256k1fx.OutputOwners{ - Locktime: 0, - Threshold: 1, - Addrs: []ids.ShortID{ - genesistest.DefaultFundedKeys[1].Address(), - }, - } - expectedOwner.InitCtx(ctx) - require.Equal(expectedOwner, subnetOwner) + require.Equal(expectedSubnetOwner, subnetOwner) } func TestBaseTx(t *testing.T) { From 994eb894dc407121ae5def41d1fe84c4fb4f33a2 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 17:00:31 -0400 Subject: [PATCH 094/114] Update TestBaseTx --- vms/platformvm/vm_test.go | 76 +++++++++------------------------------ 1 file changed, 17 insertions(+), 59 deletions(-) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 5d0fdc002ded..51f96bf0651a 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -2121,88 +2121,46 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { func TestBaseTx(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - sendAmt := uint64(100000) - changeAddr := ids.ShortEmpty + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewBaseTx( + baseTx, err := wallet.IssueBaseTx( []*avax.TransferableOutput{ { Asset: avax.Asset{ID: vm.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ - Amt: sendAmt, + Amt: 100 * units.MicroAvax, OutputOwners: secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{ - genesistest.DefaultFundedKeys[1].Address(), + ids.GenerateTestShortID(), }, }, }, }, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), ) require.NoError(err) - baseTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) - - totalInputAmt := uint64(0) - key0InputAmt := uint64(0) - for inputID := range baseTx.Unsigned.InputIDs() { - utxo, err := vm.state.GetUTXO(inputID) - require.NoError(err) - require.IsType(&secp256k1fx.TransferOutput{}, utxo.Out) - castOut := utxo.Out.(*secp256k1fx.TransferOutput) - if castOut.AddressesSet().Equals(set.Of(genesistest.DefaultFundedKeys[0].Address())) { - key0InputAmt += castOut.Amt - } - totalInputAmt += castOut.Amt - } - require.Equal(totalInputAmt, key0InputAmt) - - totalOutputAmt := uint64(0) - key0OutputAmt := uint64(0) - key1OutputAmt := uint64(0) - changeAddrOutputAmt := uint64(0) - for _, output := range baseTx.Unsigned.Outputs() { - require.IsType(&secp256k1fx.TransferOutput{}, output.Out) - castOut := output.Out.(*secp256k1fx.TransferOutput) - if castOut.AddressesSet().Equals(set.Of(genesistest.DefaultFundedKeys[0].Address())) { - key0OutputAmt += castOut.Amt - } - if castOut.AddressesSet().Equals(set.Of(genesistest.DefaultFundedKeys[1].Address())) { - key1OutputAmt += castOut.Amt - } - if castOut.AddressesSet().Equals(set.Of(changeAddr)) { - changeAddrOutputAmt += castOut.Amt - } - totalOutputAmt += castOut.Amt - } - require.Equal(totalOutputAmt, key0OutputAmt+key1OutputAmt+changeAddrOutputAmt) - - require.Equal(vm.StaticFeeConfig.TxFee, totalInputAmt-totalOutputAmt) - require.Equal(sendAmt, key1OutputAmt) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(baseTx)) vm.ctx.Lock.Lock() - baseTxBlock, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - - baseTxRawBlock := baseTxBlock.(*blockexecutor.Block).Block - require.IsType(&block.BanffStandardBlock{}, baseTxRawBlock) - require.Contains(baseTxRawBlock.Txs(), baseTx) + require.NoError(buildAndAcceptStandardBlock(vm)) - require.NoError(baseTxBlock.Verify(context.Background())) - require.NoError(baseTxBlock.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + _, txStatus, err := vm.state.GetTx(baseTx.ID()) + require.NoError(err) + require.Equal(status.Committed, txStatus) } func TestPruneMempool(t *testing.T) { From abbc394ba2bd4a0533eac10c0f13714c7940269b Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 17:13:48 -0400 Subject: [PATCH 095/114] Remove return value --- vms/platformvm/service_test.go | 2 +- vms/platformvm/vm_regression_test.go | 26 +++--- vms/platformvm/vm_test.go | 124 +++++++++++++-------------- 3 files changed, 73 insertions(+), 79 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 4c5bf0b14c03..5cd18c0b0f80 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -80,7 +80,7 @@ var ( ) func defaultService(t *testing.T) (*Service, *mutableSharedMemory) { - vm, _, _, mutableSharedMemory := defaultVM(t, upgradetest.Latest) + vm, _, mutableSharedMemory := defaultVM(t, upgradetest.Latest) return &Service{ vm: vm, addrManager: avax.NewAddressManager(vm.ctx), diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index e8f2a3e16e8f..e78914855589 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -50,7 +50,7 @@ import ( func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -211,7 +211,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) { t.Run(test.name, func(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.ApricotPhase3) + vm, _, _ := defaultVM(t, upgradetest.ApricotPhase3) vm.UpgradeConfig.ApricotPhase3Time = test.ap3Time vm.ctx.Lock.Lock() @@ -502,7 +502,7 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { require := require.New(t) - vm, _, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) + vm, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -703,7 +703,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { require := require.New(t) - vm, _, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) + vm, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1012,7 +1012,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1161,7 +1161,7 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) { delegator2EndTime := delegator2StartTime.Add(3 * defaultMinStakingDuration) delegator2Stake := defaultMaxValidatorStake - validatorStake - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1248,7 +1248,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t validatorStartTime := latestForkTime.Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1364,7 +1364,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t validatorStartTime := latestForkTime.Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1460,7 +1460,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { // setup require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1689,7 +1689,7 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // setup require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1822,7 +1822,7 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { // setup require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2006,7 +2006,7 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { // setup require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2124,7 +2124,7 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { func TestValidatorSetRaceCondition(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 51f96bf0651a..5b6c8be18e10 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -68,7 +68,6 @@ import ( blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" walletbuilder "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) @@ -124,7 +123,7 @@ type mutableSharedMemory struct { atomic.SharedMemory } -func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, database.Database, *mutableSharedMemory) { +func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, database.Database, *mutableSharedMemory) { require := require.New(t) // always reset latestForkTime (a package level variable) @@ -189,17 +188,21 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d require.NoError(vm.SetState(context.Background(), snow.NormalOp)) - factory := txstest.NewWalletFactory( - ctx, + wallet := txstest.NewWallet( + t, + vm.ctx, &vm.Config, vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), + nil, // subnetIDs + nil, // chainIDs ) // Create a subnet and store it in testSubnet1 // Note: following Banff activation, block acceptance will move // chain time ahead - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewCreateSubnetTx( + var err error + testSubnet1, err = wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 2, Addrs: []ids.ShortID{ @@ -208,23 +211,13 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d genesistest.DefaultFundedKeys[2].Address(), }, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) - testSubnet1, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(testSubnet1)) vm.ctx.Lock.Lock() - blk, err := vm.Builder.BuildBlock(context.Background()) - require.NoError(err) - require.NoError(blk.Verify(context.Background())) - require.NoError(blk.Accept(context.Background())) - require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted())) + require.NoError(buildAndAcceptStandardBlock(vm)) t.Cleanup(func() { vm.ctx.Lock.Lock() @@ -233,13 +226,13 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, *txstest.WalletFactory, d require.NoError(vm.Shutdown(context.Background())) }) - return vm, factory, db, msm + return vm, db, msm } // Ensure genesis state is parsed from bytes and stored correctly func TestGenesis(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -289,7 +282,7 @@ func TestGenesis(t *testing.T) { // accept proposal to add validator to primary network func TestAddValidatorCommit(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -353,7 +346,7 @@ func TestAddValidatorCommit(t *testing.T) { // verify invalid attempt to add validator to primary network func TestInvalidAddValidatorCommit(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -416,7 +409,7 @@ func TestInvalidAddValidatorCommit(t *testing.T) { // Reject attempt to add validator to primary network func TestAddValidatorReject(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Cortina) + vm, _, _ := defaultVM(t, upgradetest.Cortina) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -474,7 +467,7 @@ func TestAddValidatorReject(t *testing.T) { // Reject proposal to add validator to primary network func TestAddValidatorInvalidNotReissued(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -531,7 +524,7 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) { // Accept proposal to add validator to subnet func TestAddSubnetValidatorAccept(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -586,7 +579,7 @@ func TestAddSubnetValidatorAccept(t *testing.T) { // Reject proposal to add validator to subnet func TestAddSubnetValidatorReject(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -645,7 +638,7 @@ func TestAddSubnetValidatorReject(t *testing.T) { // Test case where primary network validator rewarded func TestRewardValidatorAccept(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -713,7 +706,7 @@ func TestRewardValidatorAccept(t *testing.T) { // Test case where primary network validator not rewarded func TestRewardValidatorReject(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -783,7 +776,7 @@ func TestRewardValidatorReject(t *testing.T) { // Ensure BuildBlock errors when there is no block to build func TestUnneededBuildBlock(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -794,7 +787,7 @@ func TestUnneededBuildBlock(t *testing.T) { // test acceptance of proposal to create a new chain func TestCreateChain(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -846,7 +839,7 @@ func TestCreateChain(t *testing.T) { // 3) Advance timestamp to validator's end time (removing validator from current) func TestCreateSubnet(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -933,7 +926,7 @@ func TestCreateSubnet(t *testing.T) { // test asset import func TestAtomicImport(t *testing.T) { require := require.New(t) - vm, _, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Latest) + vm, baseDB, mutableSharedMemory := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1026,7 +1019,7 @@ func TestAtomicImport(t *testing.T) { // test optimistic asset import func TestOptimisticAtomicImport(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.ApricotPhase3) + vm, _, _ := defaultVM(t, upgradetest.ApricotPhase3) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1665,7 +1658,7 @@ func TestUnverifiedParent(t *testing.T) { } func TestMaxStakeAmount(t *testing.T) { - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -1961,7 +1954,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { validatorStartTime := latestForkTime.Add(txexecutor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2066,7 +2059,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { func TestTransferSubnetOwnershipTx(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2121,7 +2114,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { func TestBaseTx(t *testing.T) { require := require.New(t) - vm, _, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() @@ -2165,21 +2158,27 @@ func TestBaseTx(t *testing.T) { func TestPruneMempool(t *testing.T) { require := require.New(t) - vm, factory, _, _ := defaultVM(t, upgradetest.Latest) + vm, _, _ := defaultVM(t, upgradetest.Latest) vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - // Create a tx that will be valid regardless of timestamp. - sendAmt := uint64(100000) - changeAddr := ids.ShortEmpty + wallet := txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), + nil, // subnetIDs + nil, // chainIDs + ) - builder, txSigner := factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewBaseTx( + // Create a tx that will be valid regardless of timestamp. + baseTx, err := wallet.IssueBaseTx( []*avax.TransferableOutput{ { Asset: avax.Asset{ID: vm.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ - Amt: sendAmt, + Amt: 100 * units.MicroAvax, OutputOwners: secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{ @@ -2189,14 +2188,11 @@ func TestPruneMempool(t *testing.T) { }, }, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{changeAddr}, - }), + walletcommon.WithCustomAddresses(set.Of( + genesistest.DefaultFundedKeys[0].Address(), + )), ) require.NoError(err) - baseTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(baseTx)) @@ -2216,8 +2212,11 @@ func TestPruneMempool(t *testing.T) { sk, err := bls.NewSecretKey() require.NoError(err) - builder, txSigner = factory.NewWallet(genesistest.DefaultFundedKeys[1]) - uAddValTx, err := builder.NewAddPermissionlessValidatorTx( + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + addValidatorTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: ids.GenerateTestNodeID(), @@ -2229,34 +2228,29 @@ func TestPruneMempool(t *testing.T) { }, signer.NewProofOfPossession(sk), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[2].Address()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[2].Address()}, - }, + rewardsOwner, + rewardsOwner, 20000, + walletcommon.WithCustomAddresses(set.Of( + genesistest.DefaultFundedKeys[1].Address(), + )), ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uAddValTx) - require.NoError(err) vm.ctx.Lock.Unlock() require.NoError(vm.issueTxFromRPC(addValidatorTx)) vm.ctx.Lock.Lock() - // Advance clock to [endTime], making [addValidatorTx] invalid. - vm.clock.Set(endTime) - - // [addValidatorTx] and [baseTx] should still be in the mempool. + // [addValidatorTx] and [baseTx] should be in the mempool. addValidatorTxID := addValidatorTx.ID() _, ok = vm.Builder.Get(addValidatorTxID) require.True(ok) _, ok = vm.Builder.Get(baseTxID) require.True(ok) + // Advance clock to [endTime], making [addValidatorTx] invalid. + vm.clock.Set(endTime) + vm.ctx.Lock.Unlock() require.NoError(vm.pruneMempool()) vm.ctx.Lock.Lock() From 832db704969d1a94c27456fcb1fec8c5bf93ee0d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 17:45:27 -0400 Subject: [PATCH 096/114] implement helper --- vms/platformvm/validator_set_property_test.go | 57 ++++--------------- vms/platformvm/vm_regression_test.go | 20 +------ vms/platformvm/vm_test.go | 25 ++++++++ 3 files changed, 39 insertions(+), 63 deletions(-) diff --git a/vms/platformvm/validator_set_property_test.go b/vms/platformvm/validator_set_property_test.go index ed10915b5a2f..f491a0bc17c9 100644 --- a/vms/platformvm/validator_set_property_test.go +++ b/vms/platformvm/validator_set_property_test.go @@ -42,7 +42,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/secp256k1fx" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" @@ -251,15 +250,9 @@ func takeValidatorsSnapshotAtCurrentHeight(vm *VM, validatorsSetByHeightAndSubne func addSubnetValidator(t testing.TB, vm *VM, data *validatorInputData, subnetID ids.ID) *state.Staker { require := require.New(t) - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[:2]...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ @@ -270,10 +263,6 @@ func addSubnetValidator(t testing.TB, vm *VM, data *validatorInputData, subnetID }, Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) @@ -285,20 +274,16 @@ func addSubnetValidator(t testing.TB, vm *VM, data *validatorInputData, subnetID func addPrimaryValidatorWithBLSKey(t testing.TB, vm *VM, data *validatorInputData) *state.Staker { require := require.New(t) - addr := genesistest.DefaultFundedKeys[0].Address() + wallet := newWallet(t, vm, walletConfig{}) sk, err := bls.NewSecretKey() require.NoError(err) - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[:2]...), - nil, // subnetIDs - nil, // chainIDs - ) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ @@ -311,19 +296,9 @@ func addPrimaryValidatorWithBLSKey(t testing.TB, vm *VM, data *validatorInputDat }, signer.NewProofOfPossession(sk), vm.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr}, - }), ) require.NoError(err) @@ -712,15 +687,7 @@ func buildVM(t *testing.T) (*VM, ids.ID, error) { // Create a subnet and store it in testSubnet1 // Note: following Banff activation, block acceptance will move // chain time ahead - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[len(genesistest.DefaultFundedKeys)-1]), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) testSubnet1, err = wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index e78914855589..33a3ba883e5b 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -54,15 +54,7 @@ func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) validatorStartTime := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) validatorEndTime := validatorStartTime.Add(360 * 24 * time.Hour) @@ -217,15 +209,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() rewardsOwner := &secp256k1fx.OutputOwners{ diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 5b6c8be18e10..fc74f753440a 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -39,6 +39,7 @@ import ( "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" + "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/math/meter" "github.com/ava-labs/avalanchego/utils/resource" @@ -58,6 +59,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" p2ppb "github.com/ava-labs/avalanchego/proto/pb/p2p" smcon "github.com/ava-labs/avalanchego/snow/consensus/snowman" @@ -229,6 +231,29 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, database.Database, *mutab return vm, db, msm } +type walletConfig struct { + keys []*secp256k1.PrivateKey + subnetIDs []ids.ID +} + +func newWallet(t testing.TB, vm *VM, c walletConfig) wallet.Wallet { + if len(c.keys) == 0 { + c.keys = genesistest.DefaultFundedKeys + } + if len(c.keys) == 0 { + c.keys = genesistest.DefaultFundedKeys + } + return txstest.NewWallet( + t, + vm.ctx, + &vm.Config, + vm.state, + secp256k1fx.NewKeychain(c.keys...), + c.subnetIDs, + []ids.ID{vm.ctx.CChainID, vm.ctx.XChainID}, + ) +} + // Ensure genesis state is parsed from bytes and stored correctly func TestGenesis(t *testing.T) { require := require.New(t) From b415d917b1f073c5dc4245c6d86f239472a34aa6 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 17:57:31 -0400 Subject: [PATCH 097/114] reduce diff --- vms/platformvm/vm_regression_test.go | 191 +++++++-------------------- vms/platformvm/vm_test.go | 162 ++++------------------- 2 files changed, 69 insertions(+), 284 deletions(-) diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index 33a3ba883e5b..b0aff6359730 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -31,6 +31,7 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" + "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/version" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/block" @@ -41,7 +42,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/state/statetest" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/secp256k1fx" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" @@ -366,71 +366,46 @@ func TestUnverifiedParentPanicRegression(t *testing.T) { vm.clock.Set(latestForkTime.Add(time.Second)) vm.state.SetTimestamp(latestForkTime.Add(time.Second)) - key0 := genesistest.DefaultFundedKeys[0] - key1 := genesistest.DefaultFundedKeys[1] - addr0 := key0.Address() - addr1 := key1.Address() - - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(key0), - nil, // subnetIDs - nil, // chainIDs - ) - addSubnetTx0, err := wallet.IssueCreateSubnetTx( - &secp256k1fx.OutputOwners{ + var ( + key0 = genesistest.DefaultFundedKeys[0] + addr0 = key0.Address() + owners0 = &secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{addr0}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ + } + + key1 = genesistest.DefaultFundedKeys[1] + addr1 = key1.Address() + owners1 = &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{addr0}, - }), + Addrs: []ids.ShortID{addr1}, + } ) - require.NoError(err) - wallet = txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(key1), - nil, // subnetIDs - nil, // chainIDs + wallet := newWallet(t, vm, walletConfig{}) + addSubnetTx0, err := wallet.IssueCreateSubnetTx( + owners0, + walletcommon.WithCustomAddresses(set.Of( + addr0, + )), ) + require.NoError(err) + addSubnetTx1, err := wallet.IssueCreateSubnetTx( - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr1}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr1}, - }), + owners1, + walletcommon.WithCustomAddresses(set.Of( + addr1, + )), ) require.NoError(err) - wallet = txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(key1), - nil, // subnetIDs - nil, // chainIDs - ) + // Wallet needs to be re-created to generate a conflicting transaction + wallet = newWallet(t, vm, walletConfig{}) addSubnetTx2, err := wallet.IssueCreateSubnetTx( - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr1}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{addr0}, - }), + owners1, + walletcommon.WithCustomAddresses(set.Of( + addr0, + )), ) require.NoError(err) @@ -490,15 +465,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() newValidatorStartTime := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) @@ -693,15 +660,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) { vm.state.SetCurrentSupply(constants.PrimaryNetworkID, defaultRewardConfig.SupplyCap/2) - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID0 := ids.GenerateTestNodeID() newValidatorStartTime0 := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) @@ -1017,15 +976,7 @@ func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) { require.Equal(weight, validators[nodeID].Weight) } - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) newValidatorStartTime0 := vm.clock.Time().Add(executor.SyncBound).Add(1 * time.Second) newValidatorEndTime0 := newValidatorStartTime0.Add(defaultMaxStakingDuration) @@ -1149,15 +1100,7 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() rewardsOwner := &secp256k1fx.OutputOwners{ @@ -1236,15 +1179,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() addValidatorTx, err := wallet.IssueAddValidatorTx( @@ -1352,15 +1287,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() addValidatorTx, err := wallet.IssueAddValidatorTx( @@ -1449,15 +1376,9 @@ func TestSubnetValidatorBLSKeyDiffAfterExpiry(t *testing.T) { defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.TxID - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) // A subnet validator stakes and then stops; also its primary network counterpart stops staking var ( @@ -1677,15 +1598,7 @@ func TestPrimaryNetworkValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) // A primary network validator stake twice var ( @@ -1811,15 +1724,9 @@ func TestSubnetValidatorPopulatedToEmptyBLSKeyDiff(t *testing.T) { defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.TxID - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) // A primary network validator stake twice var ( @@ -1995,15 +1902,9 @@ func TestSubnetValidatorSetAfterPrimaryNetworkValidatorRemoval(t *testing.T) { defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.TxID - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) // A primary network validator stake twice var ( diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index fc74f753440a..a546de9af221 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -190,15 +190,9 @@ func defaultVM(t *testing.T, f upgradetest.Fork) (*VM, database.Database, *mutab require.NoError(vm.SetState(context.Background(), snow.NormalOp)) - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + keys: []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, + }) // Create a subnet and store it in testSubnet1 // Note: following Banff activation, block acceptance will move @@ -237,9 +231,6 @@ type walletConfig struct { } func newWallet(t testing.TB, vm *VM, c walletConfig) wallet.Wallet { - if len(c.keys) == 0 { - c.keys = genesistest.DefaultFundedKeys - } if len(c.keys) == 0 { c.keys = genesistest.DefaultFundedKeys } @@ -311,15 +302,7 @@ func TestAddValidatorCommit(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) @@ -375,15 +358,7 @@ func TestInvalidAddValidatorCommit(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() startTime := genesistest.DefaultValidatorStartTime.Add(-txexecutor.SyncBound).Add(-1 * time.Second) @@ -438,15 +413,7 @@ func TestAddValidatorReject(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) @@ -496,15 +463,7 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) // Use nodeID that is already in the genesis repeatNodeID := genesistest.DefaultNodeIDs[0] @@ -554,15 +513,9 @@ func TestAddSubnetValidatorAccept(t *testing.T) { defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.ID() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) @@ -609,15 +562,9 @@ func TestAddSubnetValidatorReject(t *testing.T) { defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.ID() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) var ( startTime = vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second) @@ -817,15 +764,9 @@ func TestCreateChain(t *testing.T) { defer vm.ctx.Lock.Unlock() subnetID := testSubnet1.ID() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) tx, err := wallet.IssueCreateChainTx( subnetID, @@ -868,16 +809,7 @@ func TestCreateSubnet(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) - + wallet := newWallet(t, vm, walletConfig{}) createSubnetTx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 1, @@ -964,15 +896,7 @@ func TestAtomicImport(t *testing.T) { m := atomic.NewMemory(prefixdb.New([]byte{5}, baseDB)) mutableSharedMemory.SharedMemory = m.NewSharedMemory(vm.ctx.ChainID) - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - []ids.ID{vm.ctx.XChainID}, - ) + wallet := newWallet(t, vm, walletConfig{}) _, err := wallet.IssueImportTx( vm.ctx.XChainID, importOwners, @@ -1012,15 +936,7 @@ func TestAtomicImport(t *testing.T) { })) // The wallet must be re-loaded because the shared memory has changed - wallet = txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - []ids.ID{vm.ctx.XChainID}, - ) + wallet = newWallet(t, vm, walletConfig{}) tx, err := wallet.IssueImportTx( vm.ctx.XChainID, importOwners, @@ -1983,15 +1899,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) nodeID := ids.GenerateTestNodeID() sk, err := bls.NewSecretKey() @@ -2088,15 +1996,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) expectedSubnetOwner := &secp256k1fx.OutputOwners{ Threshold: 1, @@ -2143,15 +2043,7 @@ func TestBaseTx(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) baseTx, err := wallet.IssueBaseTx( []*avax.TransferableOutput{ @@ -2187,15 +2079,7 @@ func TestPruneMempool(t *testing.T) { vm.ctx.Lock.Lock() defer vm.ctx.Lock.Unlock() - wallet := txstest.NewWallet( - t, - vm.ctx, - &vm.Config, - vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, vm, walletConfig{}) // Create a tx that will be valid regardless of timestamp. baseTx, err := wallet.IssueBaseTx( From d0cf8d5a97d0a1148dbf6ef44c770175c61ee5ae Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 18:11:16 -0400 Subject: [PATCH 098/114] fix flaky test --- vms/platformvm/service_test.go | 121 +++++++-------------------------- vms/platformvm/vm_test.go | 7 +- 2 files changed, 27 insertions(+), 101 deletions(-) diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go index 5cd18c0b0f80..ba337593d48b 100644 --- a/vms/platformvm/service_test.go +++ b/vms/platformvm/service_test.go @@ -43,7 +43,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" @@ -171,15 +170,9 @@ func TestGetTxStatus(t *testing.T) { mutableSharedMemory.SharedMemory = sm - wallet := txstest.NewWallet( - t, - service.vm.ctx, - &service.vm.Config, - service.vm.state, - secp256k1fx.NewKeychain(recipientKey), - nil, // subnetIDs - []ids.ID{service.vm.ctx.XChainID}, - ) + wallet := newWallet(t, service.vm, walletConfig{ + keys: []*secp256k1.PrivateKey{recipientKey}, + }) tx, err := wallet.IssueImportTx( service.vm.ctx.XChainID, &secp256k1fx.OutputOwners{ @@ -231,15 +224,9 @@ func TestGetTx(t *testing.T) { "standard block", func(t testing.TB, s *Service) *txs.Tx { subnetID := testSubnet1.ID() - wallet := txstest.NewWallet( - t, - s.vm.ctx, - &s.vm.Config, - s.vm.state, - secp256k1fx.NewKeychain(testSubnet1ControlKeys[:2]...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, s.vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) tx, err := wallet.IssueCreateChainTx( subnetID, @@ -247,10 +234,6 @@ func TestGetTx(t *testing.T) { constants.AVMID, []ids.ID{}, "chain name", - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(t, err) return tx @@ -259,15 +242,7 @@ func TestGetTx(t *testing.T) { { "proposal block", func(t testing.TB, s *Service) *txs.Tx { - wallet := txstest.NewWallet( - t, - s.vm.ctx, - &s.vm.Config, - s.vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, s.vm, walletConfig{}) sk, err := bls.NewSecretKey() require.NoError(t, err) @@ -291,10 +266,6 @@ func TestGetTx(t *testing.T) { rewardsOwner, rewardsOwner, 0, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(t, err) return tx @@ -303,15 +274,7 @@ func TestGetTx(t *testing.T) { { "atomic block", func(t testing.TB, s *Service) *txs.Tx { - wallet := txstest.NewWallet( - t, - s.vm.ctx, - &s.vm.Config, - s.vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, s.vm, walletConfig{}) tx, err := wallet.IssueExportTx( s.vm.ctx.XChainID, @@ -326,10 +289,6 @@ func TestGetTx(t *testing.T) { }, }, }}, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(t, err) return tx @@ -532,20 +491,20 @@ func TestGetStake(t *testing.T) { service.vm.ctx.Lock.Lock() - wallet := txstest.NewWallet( - t, - service.vm.ctx, - &service.vm.Config, - service.vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, service.vm, walletConfig{}) // Add a delegator stakeAmount := service.vm.MinDelegatorStake + 12345 delegatorNodeID := genesistest.DefaultNodeIDs[0] delegatorEndTime := genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + changeOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + } tx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: delegatorNodeID, @@ -553,14 +512,8 @@ func TestGetStake(t *testing.T) { End: uint64(delegatorEndTime.Unix()), Wght: stakeAmount, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), + rewardsOwner, + common.WithChangeOwner(changeOwner), ) require.NoError(err) @@ -614,15 +567,9 @@ func TestGetStake(t *testing.T) { End: pendingStakerEndTime, Wght: stakeAmount, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, 0, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), + common.WithChangeOwner(changeOwner), ) require.NoError(err) @@ -695,15 +642,7 @@ func TestGetCurrentValidators(t *testing.T) { service.vm.ctx.Lock.Lock() - wallet := txstest.NewWallet( - t, - service.vm.ctx, - &service.vm.Config, - service.vm.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys[0]), - nil, // subnetIDs - nil, // chainIDs - ) + wallet := newWallet(t, service.vm, walletConfig{}) delTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: validatorNodeID, @@ -844,25 +783,15 @@ func TestGetBlock(t *testing.T) { service.vm.Config.CreateAssetTxFee = 100 * defaultTxFee subnetID := testSubnet1.ID() - wallet := txstest.NewWallet( - t, - service.vm.ctx, - &service.vm.Config, - service.vm.state, - secp256k1fx.NewKeychain(testSubnet1ControlKeys[:2]...), - []ids.ID{subnetID}, - nil, // chainIDs - ) + wallet := newWallet(t, service.vm, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) tx, err := wallet.IssueCreateChainTx( subnetID, []byte{}, constants.AVMID, []ids.ID{}, "chain name", - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index a546de9af221..5c9c166abc76 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -115,10 +115,7 @@ var ( } // subnet that exists at genesis in defaultVM - // Its controlKeys are keys[0], keys[1], keys[2] - // Its threshold is 2 - testSubnet1 *txs.Tx - testSubnet1ControlKeys = genesistest.DefaultFundedKeys[0:3] + testSubnet1 *txs.Tx ) type mutableSharedMemory struct { @@ -2091,7 +2088,7 @@ func TestPruneMempool(t *testing.T) { OutputOwners: secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{ - genesistest.DefaultFundedKeys[1].Address(), + genesistest.DefaultFundedKeys[0].Address(), }, }, }, From 762678c79ba9cf45dd8a5e7e94def7d1fbf31b2d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 18:20:23 -0400 Subject: [PATCH 099/114] nits --- vms/platformvm/validator_set_property_test.go | 14 ++++++-------- vms/platformvm/vm_regression_test.go | 4 ++-- vms/platformvm/vm_test.go | 2 +- 3 files changed, 9 insertions(+), 11 deletions(-) diff --git a/vms/platformvm/validator_set_property_test.go b/vms/platformvm/validator_set_property_test.go index f491a0bc17c9..9a3e84392724 100644 --- a/vms/platformvm/validator_set_property_test.go +++ b/vms/platformvm/validator_set_property_test.go @@ -688,15 +688,13 @@ func buildVM(t *testing.T) (*VM, ids.ID, error) { // Note: following Banff activation, block acceptance will move // chain time ahead wallet := newWallet(t, vm, walletConfig{}) + owner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + } testSubnet1, err = wallet.IssueCreateSubnetTx( - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), + owner, + walletcommon.WithChangeOwner(owner), ) if err != nil { return nil, ids.Empty, err diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index b0aff6359730..811dc2dfb91a 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -62,7 +62,7 @@ func TestAddDelegatorTxOverDelegatedRegression(t *testing.T) { nodeID := ids.GenerateTestNodeID() rewardsOwner := &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, } // create valid tx @@ -214,7 +214,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) { nodeID := ids.GenerateTestNodeID() rewardsOwner := &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, } // create valid tx diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go index 5c9c166abc76..00449f26f585 100644 --- a/vms/platformvm/vm_test.go +++ b/vms/platformvm/vm_test.go @@ -2016,7 +2016,7 @@ func TestTransferSubnetOwnershipTx(t *testing.T) { expectedSubnetOwner = &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[1].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, } transferSubnetOwnershipTx, err := wallet.IssueTransferSubnetOwnershipTx( subnetID, From b15c103eaf94be2b46243c370a3f5e4073b02240 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 18:25:11 -0400 Subject: [PATCH 100/114] Reduce diff --- .../txs/executor/create_chain_test.go | 21 +++++++---------- .../txs/executor/create_subnet_test.go | 23 ++++++++----------- 2 files changed, 18 insertions(+), 26 deletions(-) diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go index a955fe15db35..d454cda30a78 100644 --- a/vms/platformvm/txs/executor/create_chain_test.go +++ b/vms/platformvm/txs/executor/create_chain_test.go @@ -221,19 +221,12 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { env.state.SetTimestamp(test.time) // to duly set fee - config := *env.config - config.StaticFeeConfig.CreateBlockchainTxFee = test.fee - - wallet := txstest.NewWallet( - t, - env.ctx, - &config, - env.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - []ids.ID{testSubnet1.ID()}, - nil, // chainIDs - ) - tx, err := wallet.IssueCreateChainTx( + cfg := *env.config + + cfg.StaticFeeConfig.CreateBlockchainTxFee = test.fee + factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) + builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys...) + utx, err := builder.NewCreateChainTx( testSubnet1.ID(), nil, ids.GenerateTestID(), @@ -241,6 +234,8 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { "", ) require.NoError(err) + tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) + require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/create_subnet_test.go b/vms/platformvm/txs/executor/create_subnet_test.go index a4ef092427d2..ad51fdc0b2b0 100644 --- a/vms/platformvm/txs/executor/create_subnet_test.go +++ b/vms/platformvm/txs/executor/create_subnet_test.go @@ -4,6 +4,7 @@ package executor import ( + "context" "testing" "time" @@ -18,6 +19,8 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + + walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestCreateSubnetTxAP3FeeChange(t *testing.T) { @@ -63,22 +66,16 @@ func TestCreateSubnetTxAP3FeeChange(t *testing.T) { addrs.Add(key.Address()) } - config := *env.config - config.StaticFeeConfig.CreateSubnetTxFee = test.fee - - wallet := txstest.NewWallet( - t, - env.ctx, - &config, - env.state, - secp256k1fx.NewKeychain(genesistest.DefaultFundedKeys...), - nil, // subnetIDs - nil, // chainIDs - ) - tx, err := wallet.IssueCreateSubnetTx( + cfg := *env.config + cfg.StaticFeeConfig.CreateSubnetTxFee = test.fee + factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) + builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys...) + utx, err := builder.NewCreateSubnetTx( &secp256k1fx.OutputOwners{}, ) require.NoError(err) + tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) + require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) From 9a0c1b8247c4863abaa7dbcb83bfb8e509b75f25 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Fri, 23 Aug 2024 23:35:44 -0400 Subject: [PATCH 101/114] finish first pass --- vms/platformvm/block/builder/builder_test.go | 125 ++++++++--------- vms/platformvm/block/builder/helpers_test.go | 43 ++++-- .../block/builder/standard_block_test.go | 24 ++-- vms/platformvm/block/executor/helpers_test.go | 107 +++++++-------- .../block/executor/proposal_block_test.go | 128 +++++++----------- .../block/executor/standard_block_test.go | 52 ++++--- 6 files changed, 226 insertions(+), 253 deletions(-) diff --git a/vms/platformvm/block/builder/builder_test.go b/vms/platformvm/block/builder/builder_test.go index 2d83b37615d0..951dc9b87fa1 100644 --- a/vms/platformvm/block/builder/builder_test.go +++ b/vms/platformvm/block/builder/builder_test.go @@ -18,6 +18,7 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/iterator/iteratormock" + "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/platformvm/block" @@ -31,7 +32,6 @@ import ( blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestBuildBlockBasic(t *testing.T) { @@ -41,24 +41,27 @@ func TestBuildBlockBasic(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + // Create a valid transaction - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) - txID := tx.ID() // Issue the transaction env.ctx.Lock.Unlock() require.NoError(env.network.IssueTxFromRPC(tx)) env.ctx.Lock.Lock() + + txID := tx.ID() _, ok := env.mempool.Get(txID) require.True(ok) @@ -101,6 +104,8 @@ func TestBuildBlockShouldReward(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() + wallet := newWallet(t, env, walletConfig{}) + var ( now = env.backend.Clk.Time() nodeID = ids.GenerateTestNodeID() @@ -113,9 +118,13 @@ func TestBuildBlockShouldReward(t *testing.T) { sk, err := bls.NewSecretKey() require.NoError(err) + rewardOwners := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + // Create a valid [AddPermissionlessValidatorTx] - builder, txSigner := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddPermissionlessValidatorTx( + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -127,29 +136,18 @@ func TestBuildBlockShouldReward(t *testing.T) { }, signer.NewProofOfPossession(sk), env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, + rewardOwners, + rewardOwners, reward.PercentDenominator, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) - txID := tx.ID() // Issue the transaction env.ctx.Lock.Unlock() require.NoError(env.network.IssueTxFromRPC(tx)) env.ctx.Lock.Lock() + + txID := tx.ID() _, ok := env.mempool.Get(txID) require.True(ok) @@ -253,24 +251,27 @@ func TestBuildBlockForceAdvanceTime(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + // Create a valid transaction - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) - txID := tx.ID() // Issue the transaction env.ctx.Lock.Unlock() require.NoError(env.network.IssueTxFromRPC(tx)) env.ctx.Lock.Lock() + + txID := tx.ID() _, ok := env.mempool.Get(txID) require.True(ok) @@ -312,6 +313,8 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { // based on the current chain timestamp and must be validated. env.config.UpgradeConfig.DurangoTime = time.Time{} + wallet := newWallet(t, env, walletConfig{}) + var ( now = env.backend.Clk.Time() defaultValidatorStake = 100 * units.MilliAvax @@ -323,8 +326,11 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { sk, err := bls.NewSecretKey() require.NoError(err) - builder1, signer1 := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx1, err := builder1.NewAddPermissionlessValidatorTx( + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + tx1, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: ids.GenerateTestNodeID(), @@ -336,24 +342,16 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { }, signer.NewProofOfPossession(sk), env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), + common.WithCustomAddresses(set.Of( + genesistest.DefaultFundedKeys[0].Address(), + )), ) require.NoError(err) - tx1, err := walletsigner.SignUnsigned(context.Background(), signer1, utx1) - require.NoError(err) require.NoError(env.mempool.Add(tx1)) + tx1ID := tx1.ID() _, ok := env.mempool.Get(tx1ID) require.True(ok) @@ -364,8 +362,7 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { sk, err = bls.NewSecretKey() require.NoError(err) - builder2, signer2 := env.factory.NewWallet(genesistest.DefaultFundedKeys[2]) - utx2, err := builder2.NewAddPermissionlessValidatorTx( + tx2, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: ids.GenerateTestNodeID(), @@ -377,24 +374,16 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { }, signer.NewProofOfPossession(sk), env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[2].Address()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[2].Address()}, - }, + rewardsOwner, + rewardsOwner, reward.PercentDenominator, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[2].Address()}, - }), + common.WithCustomAddresses(set.Of( + genesistest.DefaultFundedKeys[2].Address(), + )), ) require.NoError(err) - tx2, err := walletsigner.SignUnsigned(context.Background(), signer2, utx2) - require.NoError(err) require.NoError(env.mempool.Add(tx2)) + tx2ID := tx2.ID() _, ok = env.mempool.Get(tx2ID) require.True(ok) @@ -428,9 +417,13 @@ func TestPreviouslyDroppedTxsCannotBeReAddedToMempool(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + // Create a valid transaction - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( + tx, err := wallet.IssueCreateChainTx( testSubnet1.ID(), nil, constants.AVMID, @@ -438,12 +431,10 @@ func TestPreviouslyDroppedTxsCannotBeReAddedToMempool(t *testing.T) { "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) - txID := tx.ID() // Transaction should not be marked as dropped before being added to the // mempool + txID := tx.ID() require.NoError(env.mempool.GetDropReason(txID)) // Mark the transaction as dropped diff --git a/vms/platformvm/block/builder/helpers_test.go b/vms/platformvm/block/builder/helpers_test.go index 79b4453f6aa0..a8e311ebdf3c 100644 --- a/vms/platformvm/block/builder/helpers_test.go +++ b/vms/platformvm/block/builder/helpers_test.go @@ -28,6 +28,7 @@ import ( "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" + "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/utils/units" @@ -46,12 +47,11 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" pvalidators "github.com/ava-labs/avalanchego/vms/platformvm/validators" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" - walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) const ( @@ -61,10 +61,7 @@ const ( defaultTxFee = 100 * units.NanoAvax ) -var ( - testSubnet1 *txs.Tx - testSubnet1ControlKeys = genesistest.DefaultFundedKeys[0:3] -) +var testSubnet1 *txs.Tx type mutableSharedMemory struct { atomic.SharedMemory @@ -207,11 +204,35 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { //nolint:un return res } +type walletConfig struct { + keys []*secp256k1.PrivateKey + subnetIDs []ids.ID +} + +func newWallet(t testing.TB, e *environment, c walletConfig) wallet.Wallet { + if len(c.keys) == 0 { + c.keys = genesistest.DefaultFundedKeys + } + return txstest.NewWallet( + t, + e.ctx, + e.config, + e.state, + secp256k1fx.NewKeychain(c.keys...), + c.subnetIDs, + []ids.ID{e.ctx.CChainID, e.ctx.XChainID}, + ) +} + func addSubnet(t *testing.T, env *environment) { require := require.New(t) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewCreateSubnetTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + + var err error + testSubnet1, err = wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 2, Addrs: []ids.ShortID{ @@ -220,14 +241,8 @@ func addSubnet(t *testing.T, env *environment) { genesistest.DefaultFundedKeys[2].Address(), }, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) - testSubnet1, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) genesisID := env.state.GetLastAccepted() stateDiff, err := state.NewDiff(genesisID, env.blkManager) diff --git a/vms/platformvm/block/builder/standard_block_test.go b/vms/platformvm/block/builder/standard_block_test.go index e97cbee313fd..6d6d3f0dc750 100644 --- a/vms/platformvm/block/builder/standard_block_test.go +++ b/vms/platformvm/block/builder/standard_block_test.go @@ -13,13 +13,12 @@ import ( "github.com/ava-labs/avalanchego/database/prefixdb" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/upgrade/upgradetest" + "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestAtomicTxImports(t *testing.T) { @@ -29,11 +28,6 @@ func TestAtomicTxImports(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - utxoID := avax.UTXOID{ - TxID: ids.Empty.Prefix(1), - OutputIndex: 1, - } - amount := uint64(70000) recipientKey := genesistest.DefaultFundedKeys[1] m := atomic.NewMemory(prefixdb.New([]byte{5}, env.baseDB)) @@ -41,10 +35,13 @@ func TestAtomicTxImports(t *testing.T) { env.msm.SharedMemory = m.NewSharedMemory(env.ctx.ChainID) peerSharedMemory := m.NewSharedMemory(env.ctx.XChainID) utxo := &avax.UTXO{ - UTXOID: utxoID, - Asset: avax.Asset{ID: env.ctx.AVAXAssetID}, + UTXOID: avax.UTXOID{ + TxID: ids.GenerateTestID(), + OutputIndex: 1, + }, + Asset: avax.Asset{ID: env.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ - Amt: amount, + Amt: 70 * units.MicroAvax, OutputOwners: secp256k1fx.OutputOwners{ Threshold: 1, Addrs: []ids.ShortID{recipientKey.Address()}, @@ -65,8 +62,9 @@ func TestAtomicTxImports(t *testing.T) { }}}, })) - builder, signer := env.factory.NewWallet(recipientKey) - utx, err := builder.NewImportTx( + wallet := newWallet(t, env, walletConfig{}) + + tx, err := wallet.IssueImportTx( env.ctx.XChainID, &secp256k1fx.OutputOwners{ Threshold: 1, @@ -74,8 +72,6 @@ func TestAtomicTxImports(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) require.NoError(env.Builder.Add(tx)) b, err := env.Builder.BuildBlock(context.Background()) diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index 947fd15a8691..dc0d5823408a 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "fmt" "testing" "time" @@ -48,10 +47,9 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" pvalidators "github.com/ava-labs/avalanchego/vms/platformvm/validators" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" - walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) const ( @@ -181,7 +179,7 @@ func newEnvironment(t *testing.T, ctrl *gomock.Controller, f upgradetest.Fork) * res.backend, pvalidators.TestManager, ) - addSubnet(res) + addSubnet(t, res) } else { res.blkManager = NewManager( res.mempool, @@ -222,9 +220,35 @@ func newEnvironment(t *testing.T, ctrl *gomock.Controller, f upgradetest.Fork) * return res } -func addSubnet(env *environment) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewCreateSubnetTx( +type walletConfig struct { + keys []*secp256k1.PrivateKey + subnetIDs []ids.ID +} + +func newWallet(t testing.TB, e *environment, c walletConfig) wallet.Wallet { + if len(c.keys) == 0 { + c.keys = genesistest.DefaultFundedKeys + } + return txstest.NewWallet( + t, + e.ctx, + e.config, + e.state, + secp256k1fx.NewKeychain(c.keys...), + c.subnetIDs, + []ids.ID{e.ctx.CChainID, e.ctx.XChainID}, + ) +} + +func addSubnet(t testing.TB, env *environment) { + require := require.New(t) + + wallet := newWallet(nil, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + + var err error + testSubnet1, err = wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 2, Addrs: []ids.ShortID{ @@ -233,24 +257,13 @@ func addSubnet(env *environment) { genesistest.DefaultFundedKeys[2].Address(), }, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) - if err != nil { - panic(err) - } - testSubnet1, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - if err != nil { - panic(err) - } + require.NoError(err) genesisID := env.state.GetLastAccepted() stateDiff, err := state.NewDiff(genesisID, env.blkManager) - if err != nil { - panic(err) - } + require.NoError(err) + feeCalculator := state.PickFeeCalculator(env.config, stateDiff) executor := executor.StandardTxExecutor{ Backend: env.backend, @@ -258,18 +271,11 @@ func addSubnet(env *environment) { FeeCalculator: feeCalculator, Tx: testSubnet1, } - err = testSubnet1.Unsigned.Visit(&executor) - if err != nil { - panic(err) - } + require.NoError(testSubnet1.Unsigned.Visit(&executor)) stateDiff.AddTx(testSubnet1, status.Committed) - if err := stateDiff.Apply(env.state); err != nil { - panic(err) - } - if err := env.state.Commit(); err != nil { - panic(err) - } + require.NoError(stateDiff.Apply(env.state)) + require.NoError(env.state.Commit()) } func defaultConfig(f upgradetest.Fork) *config.Config { @@ -348,15 +354,21 @@ func defaultFx(clk *mockable.Clock, log logging.Logger, isBootstrapped bool) fx. } func addPendingValidator( + t testing.TB, env *environment, startTime time.Time, endTime time.Time, nodeID ids.NodeID, rewardAddress ids.ShortID, keys []*secp256k1.PrivateKey, -) (*txs.Tx, error) { - builder, signer := env.factory.NewWallet(keys...) - utx, err := builder.NewAddValidatorTx( +) *txs.Tx { + require := require.New(t) + + wallet := newWallet(nil, env, walletConfig{ + keys: keys, + }) + + addValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), @@ -369,28 +381,17 @@ func addPendingValidator( }, reward.PercentDenominator, ) - if err != nil { - return nil, err - } - addPendingValidatorTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - if err != nil { - return nil, err - } + require.NoError(err) staker, err := state.NewPendingStaker( - addPendingValidatorTx.ID(), - addPendingValidatorTx.Unsigned.(*txs.AddValidatorTx), + addValidatorTx.ID(), + addValidatorTx.Unsigned.(*txs.AddValidatorTx), ) - if err != nil { - return nil, err - } + require.NoError(err) env.state.PutPendingValidator(staker) - env.state.AddTx(addPendingValidatorTx, status.Committed) - dummyHeight := uint64(1) - env.state.SetHeight(dummyHeight) - if err := env.state.Commit(); err != nil { - return nil, err - } - return addPendingValidatorTx, nil + env.state.AddTx(addValidatorTx, status.Committed) + env.state.SetHeight(1) + require.NoError(env.state.Commit()) + return addValidatorTx } diff --git a/vms/platformvm/block/executor/proposal_block_test.go b/vms/platformvm/block/executor/proposal_block_test.go index 1060c1c59be0..975d36d7a299 100644 --- a/vms/platformvm/block/executor/proposal_block_test.go +++ b/vms/platformvm/block/executor/proposal_block_test.go @@ -33,7 +33,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" walletcommon "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" ) @@ -521,8 +520,11 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) for _, staker := range test.stakers { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: staker.nodeID, Start: uint64(staker.startTime.Unix()), @@ -534,14 +536,8 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { Addrs: []ids.ShortID{staker.rewardAddress}, }, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }), ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -555,8 +551,12 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { } for _, subStaker := range test.subnetStakers { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:2], + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subStaker.nodeID, @@ -566,14 +566,8 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { }, Subnet: subnetID, }, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }), ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) subnetStaker, err := state.NewPendingStaker( tx.ID(), @@ -592,8 +586,12 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { // add Staker0 (with the right end time) to state // so to allow proposalBlk issuance staker0.endTime = newTime - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:2], + }) + + addStaker0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: staker0.nodeID, Start: uint64(staker0.startTime.Unix()), @@ -605,14 +603,8 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { Addrs: []ids.ShortID{staker0.rewardAddress}, }, reward.PercentDenominator, - walletcommon.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }), ) require.NoError(err) - addStaker0, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // store Staker0 to state addValTx := addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -696,13 +688,17 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { env := newEnvironment(t, nil, upgradetest.Banff) subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:2], + subnetIDs: []ids.ID{subnetID}, + }) + env.config.TrackedSubnets.Add(subnetID) // Add a subnet validator to the staker set subnetValidatorNodeID := genesistest.DefaultNodeIDs[0] subnetVdr1EndTime := genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetValidatorNodeID, @@ -714,8 +710,6 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addSubnetValTx := tx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err := state.NewCurrentStaker( @@ -734,7 +728,7 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { // Queue a staker that joins the staker set after the above validator leaves subnetVdr2NodeID := genesistest.DefaultNodeIDs[1] - utx, err = builder.NewAddSubnetValidatorTx( + tx, err = wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetVdr2NodeID, @@ -746,8 +740,6 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { }, ) require.NoError(err) - tx, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err = state.NewPendingStaker( tx.ID(), @@ -767,7 +759,7 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { // add Staker0 (with the right end time) to state // so to allow proposalBlk issuance staker0EndTime := subnetVdr1EndTime - uVdrTx, err := builder.NewAddValidatorTx( + addStaker0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: genesistest.DefaultValidatorStartTimeUnix, @@ -785,8 +777,6 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { }), ) require.NoError(err) - addStaker0, err := walletsigner.SignUnsigned(context.Background(), signer, uVdrTx) - require.NoError(err) // store Staker0 to state addValTx := addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -855,13 +845,17 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) } + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:2], + subnetIDs: []ids.ID{subnetID}, + }) + // Add a subnet validator to the staker set subnetValidatorNodeID := genesistest.DefaultNodeIDs[0] subnetVdr1StartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Minute) subnetVdr1EndTime := genesistest.DefaultValidatorStartTime.Add(10 * defaultMinStakingDuration).Add(1 * time.Minute) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetValidatorNodeID, @@ -873,8 +867,6 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -894,7 +886,7 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { staker0StartTime := genesistest.DefaultValidatorStartTime staker0EndTime := subnetVdr1StartTime - uVdrTx, err := builder.NewAddValidatorTx( + addStaker0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: uint64(staker0StartTime.Unix()), @@ -908,8 +900,6 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addStaker0, err := walletsigner.SignUnsigned(context.Background(), signer, uVdrTx) - require.NoError(err) // store Staker0 to state addValTx := addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -970,7 +960,8 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMaxStakingDuration) nodeID := ids.GenerateTestNodeID() rewardAddress := ids.GenerateTestShortID() - _, err := addPendingValidator( + addPendingValidator( + t, env, pendingValidatorStartTime, pendingValidatorEndTime, @@ -978,14 +969,14 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { rewardAddress, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) + + wallet := newWallet(t, env, walletConfig{}) // add Staker0 (with the right end time) to state // just to allow proposalBlk issuance (with a reward Tx) staker0StartTime := genesistest.DefaultValidatorStartTime staker0EndTime := pendingValidatorStartTime - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + addStaker0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: uint64(staker0StartTime.Unix()), @@ -999,8 +990,6 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addStaker0, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // store Staker0 to state addValTx := addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -1054,9 +1043,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { // Add delegator pendingDelegatorStartTime := pendingValidatorStartTime.Add(1 * time.Second) pendingDelegatorEndTime := pendingDelegatorStartTime.Add(1 * time.Second) - - builder, signer = env.factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - uDelTx, err := builder.NewAddDelegatorTx( + addDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(pendingDelegatorStartTime.Unix()), @@ -1069,8 +1056,6 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { }, ) require.NoError(err) - addDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), signer, uDelTx) - require.NoError(err) staker, err = state.NewPendingStaker( addDelegatorTx.ID(), @@ -1086,8 +1071,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { // add Staker0 (with the right end time) to state // so to allow proposalBlk issuance staker0EndTime = pendingDelegatorStartTime - builder, signer = env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err = builder.NewAddValidatorTx( + addStaker0, err = wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: uint64(staker0StartTime.Unix()), @@ -1101,8 +1085,6 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addStaker0, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // store Staker0 to state addValTx = addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -1167,7 +1149,8 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { rewardAddress := nodeIDKey.Address() nodeID := ids.BuildTestNodeID(rewardAddress[:]) - _, err := addPendingValidator( + addPendingValidator( + t, env, pendingValidatorStartTime, pendingValidatorEndTime, @@ -1175,14 +1158,14 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { rewardAddress, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) + + wallet := newWallet(t, env, walletConfig{}) // add Staker0 (with the right end time) to state // so to allow proposalBlk issuance staker0StartTime := genesistest.DefaultValidatorStartTime staker0EndTime := pendingValidatorStartTime - builder, txSigner := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddValidatorTx( + addStaker0, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: uint64(staker0StartTime.Unix()), @@ -1196,8 +1179,6 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addStaker0, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // store Staker0 to state addValTx := addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -1251,8 +1232,7 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { // Add delegator pendingDelegatorStartTime := pendingValidatorStartTime.Add(1 * time.Second) pendingDelegatorEndTime := pendingDelegatorStartTime.Add(defaultMinStakingDuration) - builder, txSigner = env.factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - uDelTx, err := builder.NewAddDelegatorTx( + addDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(pendingDelegatorStartTime.Unix()), @@ -1265,8 +1245,6 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { }, ) require.NoError(err) - addDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, uDelTx) - require.NoError(err) staker, err = state.NewPendingStaker( addDelegatorTx.ID(), @@ -1282,8 +1260,7 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { // add Staker0 (with the right end time) to state // so to allow proposalBlk issuance staker0EndTime = pendingDelegatorStartTime - builder, txSigner = env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err = builder.NewAddValidatorTx( + addStaker0, err = wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: uint64(staker0StartTime.Unix()), @@ -1297,8 +1274,6 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addStaker0, err = walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // store Staker0 to state addValTx = addStaker0.Unsigned.(*txs.AddValidatorTx) @@ -1354,6 +1329,8 @@ func TestAddValidatorProposalBlock(t *testing.T) { require := require.New(t) env := newEnvironment(t, nil, upgradetest.Durango) + wallet := newWallet(t, env, walletConfig{}) + now := env.clk.Time() // Create validator tx @@ -1366,8 +1343,7 @@ func TestAddValidatorProposalBlock(t *testing.T) { sk, err := bls.NewSecretKey() require.NoError(err) - builder, txSigner := env.factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - utx, err := builder.NewAddPermissionlessValidatorTx( + addValidatorTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1390,8 +1366,6 @@ func TestAddValidatorProposalBlock(t *testing.T) { 10000, ) require.NoError(err) - addValidatorTx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(err) // Add validator through a [StandardBlock] preferredID := env.blkManager.Preferred() @@ -1451,7 +1425,7 @@ func TestAddValidatorProposalBlock(t *testing.T) { sk, err = bls.NewSecretKey() require.NoError(err) - utx2, err := builder.NewAddPermissionlessValidatorTx( + addValidatorTx2, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1474,8 +1448,6 @@ func TestAddValidatorProposalBlock(t *testing.T) { 10000, ) require.NoError(err) - addValidatorTx2, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx2) - require.NoError(err) // Add validator through a [ProposalBlock] and reward the last one preferredID = env.blkManager.Preferred() diff --git a/vms/platformvm/block/executor/standard_block_test.go b/vms/platformvm/block/executor/standard_block_test.go index 3b9b55408ef1..70e499215da8 100644 --- a/vms/platformvm/block/executor/standard_block_test.go +++ b/vms/platformvm/block/executor/standard_block_test.go @@ -28,8 +28,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestApricotStandardBlockTimeVerification(t *testing.T) { @@ -302,7 +300,8 @@ func TestBanffStandardBlockUpdatePrimaryNetworkStakers(t *testing.T) { pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMinStakingDuration) nodeID := ids.GenerateTestNodeID() rewardAddress := ids.GenerateTestShortID() - addPendingValidatorTx, err := addPendingValidator( + addPendingValidatorTx := addPendingValidator( + t, env, pendingValidatorStartTime, pendingValidatorEndTime, @@ -310,7 +309,6 @@ func TestBanffStandardBlockUpdatePrimaryNetworkStakers(t *testing.T) { rewardAddress, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) // build standard block moving ahead chain time preferredID := env.state.GetLastAccepted() @@ -501,7 +499,8 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) for _, staker := range test.stakers { - _, err := addPendingValidator( + addPendingValidator( + t, env, staker.startTime, staker.endTime, @@ -509,12 +508,14 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) { staker.rewardAddress, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) } for _, staker := range test.subnetStakers { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: staker.nodeID, @@ -526,8 +527,6 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -603,11 +602,14 @@ func TestBanffStandardBlockRemoveSubnetValidator(t *testing.T) { subnetID := testSubnet1.ID() env.config.TrackedSubnets.Add(subnetID) + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + // Add a subnet validator to the staker set subnetValidatorNodeID := genesistest.DefaultNodeIDs[0] subnetVdr1EndTime := genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetValidatorNodeID, @@ -619,8 +621,6 @@ func TestBanffStandardBlockRemoveSubnetValidator(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addSubnetValTx := tx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err := state.NewCurrentStaker( @@ -639,7 +639,7 @@ func TestBanffStandardBlockRemoveSubnetValidator(t *testing.T) { // Queue a staker that joins the staker set after the above validator leaves subnetVdr2NodeID := genesistest.DefaultNodeIDs[1] - utx, err = builder.NewAddSubnetValidatorTx( + tx, err = wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetVdr2NodeID, @@ -651,8 +651,6 @@ func TestBanffStandardBlockRemoveSubnetValidator(t *testing.T) { }, ) require.NoError(err) - tx, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err = state.NewPendingStaker( tx.ID(), @@ -708,12 +706,15 @@ func TestBanffStandardBlockTrackedSubnet(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) } + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + // Add a subnet validator to the staker set subnetValidatorNodeID := genesistest.DefaultNodeIDs[0] subnetVdr1StartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Minute) subnetVdr1EndTime := genesistest.DefaultValidatorStartTime.Add(10 * defaultMinStakingDuration).Add(1 * time.Minute) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetValidatorNodeID, @@ -725,8 +726,6 @@ func TestBanffStandardBlockTrackedSubnet(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -773,7 +772,8 @@ func TestBanffStandardBlockDelegatorStakerWeight(t *testing.T) { pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMaxStakingDuration) nodeID := ids.GenerateTestNodeID() rewardAddress := ids.GenerateTestShortID() - _, err := addPendingValidator( + addPendingValidator( + t, env, pendingValidatorStartTime, pendingValidatorEndTime, @@ -781,7 +781,6 @@ func TestBanffStandardBlockDelegatorStakerWeight(t *testing.T) { rewardAddress, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) // build standard block moving ahead chain time preferredID := env.state.GetLastAccepted() @@ -803,12 +802,13 @@ func TestBanffStandardBlockDelegatorStakerWeight(t *testing.T) { vdrWeight := env.config.Validators.GetWeight(constants.PrimaryNetworkID, nodeID) require.Equal(env.config.MinValidatorStake, vdrWeight) + wallet := newWallet(t, env, walletConfig{}) + // Add delegator pendingDelegatorStartTime := pendingValidatorStartTime.Add(1 * time.Second) pendingDelegatorEndTime := pendingDelegatorStartTime.Add(1 * time.Second) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - utx, err := builder.NewAddDelegatorTx( + addDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(pendingDelegatorStartTime.Unix()), @@ -821,8 +821,6 @@ func TestBanffStandardBlockDelegatorStakerWeight(t *testing.T) { }, ) require.NoError(err) - addDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( addDelegatorTx.ID(), From d57f852439ebd7fdf35e3a09c764ef24477f36e3 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:21:00 -0400 Subject: [PATCH 102/114] nit --- vms/platformvm/block/builder/builder_test.go | 9 --------- 1 file changed, 9 deletions(-) diff --git a/vms/platformvm/block/builder/builder_test.go b/vms/platformvm/block/builder/builder_test.go index 951dc9b87fa1..e691c6f6ce2e 100644 --- a/vms/platformvm/block/builder/builder_test.go +++ b/vms/platformvm/block/builder/builder_test.go @@ -18,17 +18,14 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/avalanchego/utils/crypto/bls" "github.com/ava-labs/avalanchego/utils/iterator/iteratormock" - "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/platformvm/block" - "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/reward" "github.com/ava-labs/avalanchego/vms/platformvm/signer" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor" txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor" @@ -345,9 +342,6 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { rewardsOwner, rewardsOwner, reward.PercentDenominator, - common.WithCustomAddresses(set.Of( - genesistest.DefaultFundedKeys[0].Address(), - )), ) require.NoError(err) require.NoError(env.mempool.Add(tx1)) @@ -377,9 +371,6 @@ func TestBuildBlockInvalidStakingDurations(t *testing.T) { rewardsOwner, rewardsOwner, reward.PercentDenominator, - common.WithCustomAddresses(set.Of( - genesistest.DefaultFundedKeys[2].Address(), - )), ) require.NoError(err) require.NoError(env.mempool.Add(tx2)) From fbba8b69192b1cbfe763ede64eab5d1473aca0de Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:24:27 -0400 Subject: [PATCH 103/114] nit --- .../block/builder/standard_block_test.go | 20 +++++++++---------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/vms/platformvm/block/builder/standard_block_test.go b/vms/platformvm/block/builder/standard_block_test.go index 6d6d3f0dc750..12adfe6ff0d9 100644 --- a/vms/platformvm/block/builder/standard_block_test.go +++ b/vms/platformvm/block/builder/standard_block_test.go @@ -28,7 +28,11 @@ func TestAtomicTxImports(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - recipientKey := genesistest.DefaultFundedKeys[1] + addr := genesistest.DefaultFundedKeys[0].Address() + owner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{addr}, + } m := atomic.NewMemory(prefixdb.New([]byte{5}, env.baseDB)) @@ -41,11 +45,8 @@ func TestAtomicTxImports(t *testing.T) { }, Asset: avax.Asset{ID: env.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ - Amt: 70 * units.MicroAvax, - OutputOwners: secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{recipientKey.Address()}, - }, + Amt: 70 * units.MicroAvax, + OutputOwners: *owner, }, } utxoBytes, err := txs.Codec.Marshal(txs.CodecVersion, utxo) @@ -57,7 +58,7 @@ func TestAtomicTxImports(t *testing.T) { Key: inputID[:], Value: utxoBytes, Traits: [][]byte{ - recipientKey.Address().Bytes(), + addr.Bytes(), }, }}}, })) @@ -66,10 +67,7 @@ func TestAtomicTxImports(t *testing.T) { tx, err := wallet.IssueImportTx( env.ctx.XChainID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{recipientKey.Address()}, - }, + owner, ) require.NoError(err) From 598234049f96a71da4ee2b9a0994dc30d9ff7823 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:25:33 -0400 Subject: [PATCH 104/114] nit --- vms/platformvm/block/executor/helpers_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index dc0d5823408a..b6c54d2d642b 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -243,7 +243,7 @@ func newWallet(t testing.TB, e *environment, c walletConfig) wallet.Wallet { func addSubnet(t testing.TB, env *environment) { require := require.New(t) - wallet := newWallet(nil, env, walletConfig{ + wallet := newWallet(t, env, walletConfig{ keys: genesistest.DefaultFundedKeys[:1], }) @@ -364,7 +364,7 @@ func addPendingValidator( ) *txs.Tx { require := require.New(t) - wallet := newWallet(nil, env, walletConfig{ + wallet := newWallet(t, env, walletConfig{ keys: keys, }) From 0bb0459492bd4e6d2263770c0ad6568112774b7e Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:29:27 -0400 Subject: [PATCH 105/114] nit --- vms/platformvm/block/executor/proposal_block_test.go | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/vms/platformvm/block/executor/proposal_block_test.go b/vms/platformvm/block/executor/proposal_block_test.go index 975d36d7a299..2f00a4389f2c 100644 --- a/vms/platformvm/block/executor/proposal_block_test.go +++ b/vms/platformvm/block/executor/proposal_block_test.go @@ -520,9 +520,7 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) for _, staker := range test.stakers { - wallet := newWallet(t, env, walletConfig{ - keys: genesistest.DefaultFundedKeys[:1], - }) + wallet := newWallet(t, env, walletConfig{}) tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ @@ -552,7 +550,6 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { for _, subStaker := range test.subnetStakers { wallet := newWallet(t, env, walletConfig{ - keys: genesistest.DefaultFundedKeys[:2], subnetIDs: []ids.ID{subnetID}, }) @@ -587,9 +584,7 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) { // so to allow proposalBlk issuance staker0.endTime = newTime - wallet := newWallet(t, env, walletConfig{ - keys: genesistest.DefaultFundedKeys[:2], - }) + wallet := newWallet(t, env, walletConfig{}) addStaker0, err := wallet.IssueAddValidatorTx( &txs.Validator{ @@ -689,7 +684,6 @@ func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) { subnetID := testSubnet1.ID() wallet := newWallet(t, env, walletConfig{ - keys: genesistest.DefaultFundedKeys[:2], subnetIDs: []ids.ID{subnetID}, }) @@ -846,7 +840,6 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) { } wallet := newWallet(t, env, walletConfig{ - keys: genesistest.DefaultFundedKeys[:2], subnetIDs: []ids.ID{subnetID}, }) From 4703496a20f831dc23eaf2524cfd044efea21e05 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:33:00 -0400 Subject: [PATCH 106/114] nit --- .../block/executor/proposal_block_test.go | 30 +++++++++---------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/vms/platformvm/block/executor/proposal_block_test.go b/vms/platformvm/block/executor/proposal_block_test.go index 2f00a4389f2c..ce3b04fca11f 100644 --- a/vms/platformvm/block/executor/proposal_block_test.go +++ b/vms/platformvm/block/executor/proposal_block_test.go @@ -965,6 +965,11 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { wallet := newWallet(t, env, walletConfig{}) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + // add Staker0 (with the right end time) to state // just to allow proposalBlk issuance (with a reward Tx) staker0StartTime := genesistest.DefaultValidatorStartTime @@ -976,10 +981,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { End: uint64(staker0EndTime.Unix()), Wght: 10, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) @@ -1071,10 +1073,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { End: uint64(staker0EndTime.Unix()), Wght: 10, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) @@ -1154,6 +1153,11 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { wallet := newWallet(t, env, walletConfig{}) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + // add Staker0 (with the right end time) to state // so to allow proposalBlk issuance staker0StartTime := genesistest.DefaultValidatorStartTime @@ -1165,10 +1169,7 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { End: uint64(staker0EndTime.Unix()), Wght: 10, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) @@ -1260,10 +1261,7 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { End: uint64(staker0EndTime.Unix()), Wght: 10, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) From 3e3e9cdde14e5a0e60427b603abdbe3d91bf4f0a Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:35:15 -0400 Subject: [PATCH 107/114] Delete moar --- .../block/executor/proposal_block_test.go | 25 +++++++------------ 1 file changed, 9 insertions(+), 16 deletions(-) diff --git a/vms/platformvm/block/executor/proposal_block_test.go b/vms/platformvm/block/executor/proposal_block_test.go index ce3b04fca11f..820a122b5375 100644 --- a/vms/platformvm/block/executor/proposal_block_test.go +++ b/vms/platformvm/block/executor/proposal_block_test.go @@ -1334,6 +1334,11 @@ func TestAddValidatorProposalBlock(t *testing.T) { sk, err := bls.NewSecretKey() require.NoError(err) + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + } + addValidatorTx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ @@ -1346,14 +1351,8 @@ func TestAddValidatorProposalBlock(t *testing.T) { }, signer.NewProofOfPossession(sk), env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, + rewardsOwner, + rewardsOwner, 10000, ) require.NoError(err) @@ -1428,14 +1427,8 @@ func TestAddValidatorProposalBlock(t *testing.T) { }, signer.NewProofOfPossession(sk), env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, + rewardsOwner, + rewardsOwner, 10000, ) require.NoError(err) From 241abadaf91fad4e0580f382cf9f5097d7fb4f1d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 10:38:00 -0400 Subject: [PATCH 108/114] Delete moar --- vms/platformvm/block/executor/proposal_block_test.go | 12 +++--------- vms/platformvm/block/executor/standard_block_test.go | 2 +- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/vms/platformvm/block/executor/proposal_block_test.go b/vms/platformvm/block/executor/proposal_block_test.go index 820a122b5375..397802cf0faa 100644 --- a/vms/platformvm/block/executor/proposal_block_test.go +++ b/vms/platformvm/block/executor/proposal_block_test.go @@ -1045,10 +1045,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) { End: uint64(pendingDelegatorEndTime.Unix()), Wght: env.config.MinDelegatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, + rewardsOwner, ) require.NoError(err) @@ -1233,10 +1230,7 @@ func TestBanffProposalBlockDelegatorStakers(t *testing.T) { End: uint64(pendingDelegatorEndTime.Unix()), Wght: env.config.MinDelegatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }, + rewardsOwner, ) require.NoError(err) @@ -1336,7 +1330,7 @@ func TestAddValidatorProposalBlock(t *testing.T) { rewardsOwner := &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, } addValidatorTx, err := wallet.IssueAddPermissionlessValidatorTx( diff --git a/vms/platformvm/block/executor/standard_block_test.go b/vms/platformvm/block/executor/standard_block_test.go index 70e499215da8..15cc43cdad93 100644 --- a/vms/platformvm/block/executor/standard_block_test.go +++ b/vms/platformvm/block/executor/standard_block_test.go @@ -817,7 +817,7 @@ func TestBanffStandardBlockDelegatorStakerWeight(t *testing.T) { }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, ) require.NoError(err) From 946f52218534583f2526255de2cd6fb9d3342fa2 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 13:14:56 -0400 Subject: [PATCH 109/114] Finish first pass --- vms/platformvm/block/builder/helpers_test.go | 2 - vms/platformvm/block/executor/helpers_test.go | 11 - .../txs/executor/advance_time_test.go | 99 ++- .../txs/executor/create_chain_test.go | 83 +-- .../txs/executor/create_subnet_test.go | 18 +- vms/platformvm/txs/executor/export_test.go | 26 +- vms/platformvm/txs/executor/helpers_test.go | 52 +- vms/platformvm/txs/executor/import_test.go | 18 +- .../txs/executor/proposal_tx_executor_test.go | 229 ++++--- .../txs/executor/reward_validator_test.go | 47 +- .../txs/executor/standard_tx_executor_test.go | 578 ++++++++---------- vms/platformvm/txs/txstest/backend.go | 81 --- vms/platformvm/txs/txstest/builder.go | 43 -- 13 files changed, 532 insertions(+), 755 deletions(-) delete mode 100644 vms/platformvm/txs/txstest/backend.go delete mode 100644 vms/platformvm/txs/txstest/builder.go diff --git a/vms/platformvm/block/builder/helpers_test.go b/vms/platformvm/block/builder/helpers_test.go index a8e311ebdf3c..02f7102a562c 100644 --- a/vms/platformvm/block/builder/helpers_test.go +++ b/vms/platformvm/block/builder/helpers_test.go @@ -84,7 +84,6 @@ type environment struct { state state.State uptimes uptime.Manager utxosVerifier utxo.Verifier - factory *txstest.WalletFactory backend txexecutor.Backend } @@ -124,7 +123,6 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { //nolint:un res.uptimes = uptime.NewManager(res.state, res.clk) res.utxosVerifier = utxo.NewVerifier(res.ctx, res.clk, res.fx) - res.factory = txstest.NewWalletFactory(res.ctx, res.config, res.state) genesisID := res.state.GetLastAccepted() res.backend = txexecutor.Backend{ diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index b6c54d2d642b..f066b1fc13c7 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -96,7 +96,6 @@ type environment struct { mockedState *state.MockState uptimes uptime.Manager utxosVerifier utxo.Verifier - factory *txstest.WalletFactory backend *executor.Backend } @@ -130,20 +129,10 @@ func newEnvironment(t *testing.T, ctrl *gomock.Controller, f upgradetest.Fork) * res.uptimes = uptime.NewManager(res.state, res.clk) res.utxosVerifier = utxo.NewVerifier(res.ctx, res.clk, res.fx) - res.factory = txstest.NewWalletFactory( - res.ctx, - res.config, - res.state, - ) } else { res.mockedState = state.NewMockState(ctrl) res.uptimes = uptime.NewManager(res.mockedState, res.clk) res.utxosVerifier = utxo.NewVerifier(res.ctx, res.clk, res.fx) - res.factory = txstest.NewWalletFactory( - res.ctx, - res.config, - res.mockedState, - ) // setup expectations strictly needed for environment creation res.mockedState.EXPECT().GetLastAccepted().Return(ids.GenerateTestID()).Times(1) diff --git a/vms/platformvm/txs/executor/advance_time_test.go b/vms/platformvm/txs/executor/advance_time_test.go index c10c76ec7bac..aadf84136615 100644 --- a/vms/platformvm/txs/executor/advance_time_test.go +++ b/vms/platformvm/txs/executor/advance_time_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "fmt" "testing" "time" @@ -23,8 +22,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func newAdvanceTimeTx(t testing.TB, timestamp time.Time) (*txs.Tx, error) { @@ -50,14 +47,14 @@ func TestAdvanceTimeTxUpdatePrimaryNetworkStakers(t *testing.T) { pendingValidatorStartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMinStakingDuration) nodeID := ids.GenerateTestNodeID() - addPendingValidatorTx, err := addPendingValidator( + addPendingValidatorTx := addPendingValidator( + t, env, pendingValidatorStartTime, pendingValidatorEndTime, nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) tx, err := newAdvanceTimeTx(t, pendingValidatorStartTime) require.NoError(err) @@ -140,8 +137,7 @@ func TestAdvanceTimeTxTimestampTooLate(t *testing.T) { pendingValidatorStartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMinStakingDuration) nodeID := ids.GenerateTestNodeID() - _, err := addPendingValidator(env, pendingValidatorStartTime, pendingValidatorEndTime, nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}) - require.NoError(err) + addPendingValidator(t, env, pendingValidatorStartTime, pendingValidatorEndTime, nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}) { tx, err := newAdvanceTimeTx(t, pendingValidatorStartTime.Add(1*time.Second)) @@ -378,19 +374,22 @@ func TestAdvanceTimeTxUpdateStakers(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) for _, staker := range test.stakers { - _, err := addPendingValidator( + addPendingValidator( + t, env, staker.startTime, staker.endTime, staker.nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) } for _, staker := range test.subnetStakers { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: staker.nodeID, @@ -402,8 +401,6 @@ func TestAdvanceTimeTxUpdateStakers(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -485,13 +482,16 @@ func TestAdvanceTimeTxRemoveSubnetValidator(t *testing.T) { subnetID := testSubnet1.ID() env.config.TrackedSubnets.Add(subnetID) + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + dummyHeight := uint64(1) // Add a subnet validator to the staker set subnetValidatorNodeID := genesistest.DefaultNodeIDs[0] subnetVdr1EndTime := genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetValidatorNodeID, @@ -503,8 +503,6 @@ func TestAdvanceTimeTxRemoveSubnetValidator(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addSubnetValTx := tx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err := state.NewCurrentStaker( @@ -524,7 +522,7 @@ func TestAdvanceTimeTxRemoveSubnetValidator(t *testing.T) { // Queue a staker that joins the staker set after the above validator leaves subnetVdr2NodeID := genesistest.DefaultNodeIDs[1] - utx, err = builder.NewAddSubnetValidatorTx( + tx, err = wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetVdr2NodeID, @@ -536,8 +534,6 @@ func TestAdvanceTimeTxRemoveSubnetValidator(t *testing.T) { }, ) require.NoError(err) - tx, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err = state.NewPendingStaker( tx.ID(), @@ -601,13 +597,16 @@ func TestTrackedSubnet(t *testing.T) { env.config.TrackedSubnets.Add(subnetID) } + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + // Add a subnet validator to the staker set subnetValidatorNodeID := genesistest.DefaultNodeIDs[0] subnetVdr1StartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Minute) subnetVdr1EndTime := genesistest.DefaultValidatorStartTime.Add(10 * defaultMinStakingDuration).Add(1 * time.Minute) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewAddSubnetValidatorTx( + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: subnetValidatorNodeID, @@ -619,8 +618,6 @@ func TestTrackedSubnet(t *testing.T) { }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -676,14 +673,14 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) { pendingValidatorStartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMaxStakingDuration) nodeID := ids.GenerateTestNodeID() - _, err := addPendingValidator( + addPendingValidator( + t, env, pendingValidatorStartTime, pendingValidatorEndTime, nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}, ) - require.NoError(err) tx, err := newAdvanceTimeTx(t, pendingValidatorStartTime) require.NoError(err) @@ -709,6 +706,8 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) { env.state.SetHeight(dummyHeight) require.NoError(env.state.Commit()) + wallet := newWallet(t, env, walletConfig{}) + // Test validator weight before delegation vdrWeight := env.config.Validators.GetWeight(constants.PrimaryNetworkID, nodeID) require.Equal(env.config.MinValidatorStake, vdrWeight) @@ -717,8 +716,7 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) { pendingDelegatorStartTime := pendingValidatorStartTime.Add(1 * time.Second) pendingDelegatorEndTime := pendingDelegatorStartTime.Add(1 * time.Second) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - utx, err := builder.NewAddDelegatorTx( + addDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(pendingDelegatorStartTime.Unix()), @@ -727,12 +725,10 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) { }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, ) require.NoError(err) - addDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( addDelegatorTx.ID(), @@ -786,8 +782,7 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) { pendingValidatorStartTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) pendingValidatorEndTime := pendingValidatorStartTime.Add(defaultMinStakingDuration) nodeID := ids.GenerateTestNodeID() - _, err := addPendingValidator(env, pendingValidatorStartTime, pendingValidatorEndTime, nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}) - require.NoError(err) + addPendingValidator(t, env, pendingValidatorStartTime, pendingValidatorEndTime, nodeID, []*secp256k1.PrivateKey{genesistest.DefaultFundedKeys[0]}) tx, err := newAdvanceTimeTx(t, pendingValidatorStartTime) require.NoError(err) @@ -813,6 +808,8 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) { env.state.SetHeight(dummyHeight) require.NoError(env.state.Commit()) + wallet := newWallet(t, env, walletConfig{}) + // Test validator weight before delegation vdrWeight := env.config.Validators.GetWeight(constants.PrimaryNetworkID, nodeID) require.Equal(env.config.MinValidatorStake, vdrWeight) @@ -820,8 +817,7 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) { // Add delegator pendingDelegatorStartTime := pendingValidatorStartTime.Add(1 * time.Second) pendingDelegatorEndTime := pendingDelegatorStartTime.Add(defaultMinStakingDuration) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0], genesistest.DefaultFundedKeys[1], genesistest.DefaultFundedKeys[4]) - utx, err := builder.NewAddDelegatorTx( + addDelegatorTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(pendingDelegatorStartTime.Unix()), @@ -830,12 +826,10 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) { }, &secp256k1fx.OutputOwners{ Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, ) require.NoError(err) - addDelegatorTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( addDelegatorTx.ID(), @@ -935,14 +929,19 @@ func TestAdvanceTimeTxUnmarshal(t *testing.T) { } func addPendingValidator( + t testing.TB, env *environment, startTime time.Time, endTime time.Time, nodeID ids.NodeID, keys []*secp256k1.PrivateKey, -) (*txs.Tx, error) { - builder, signer := env.factory.NewWallet(keys...) - utx, err := builder.NewAddValidatorTx( +) *txs.Tx { + require := require.New(t) + + wallet := newWallet(t, env, walletConfig{ + keys: keys, + }) + addPendingValidatorTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), @@ -955,28 +954,18 @@ func addPendingValidator( }, reward.PercentDenominator, ) - if err != nil { - return nil, err - } - addPendingValidatorTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - if err != nil { - return nil, err - } + require.NoError(err) staker, err := state.NewPendingStaker( addPendingValidatorTx.ID(), addPendingValidatorTx.Unsigned.(*txs.AddValidatorTx), ) - if err != nil { - return nil, err - } + require.NoError(err) env.state.PutPendingValidator(staker) env.state.AddTx(addPendingValidatorTx, status.Committed) dummyHeight := uint64(1) env.state.SetHeight(dummyHeight) - if err := env.state.Commit(); err != nil { - return nil, err - } - return addPendingValidatorTx, nil + require.NoError(env.state.Commit()) + return addPendingValidatorTx } diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go index d454cda30a78..61fead2677a7 100644 --- a/vms/platformvm/txs/executor/create_chain_test.go +++ b/vms/platformvm/txs/executor/create_chain_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "testing" "time" @@ -21,11 +20,8 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/txs" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) // Ensure Execute fails when there are not enough control sigs @@ -35,17 +31,19 @@ func TestCreateChainTxInsufficientControlSigs(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[:2]...) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Remove a signature tx.Creds[0].(*secp256k1fx.Credential).Sigs = tx.Creds[0].(*secp256k1fx.Credential).Sigs[1:] @@ -71,17 +69,19 @@ func TestCreateChainTxWrongControlSig(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Generate new, random key to sign tx with key, err := secp256k1.NewPrivateKey() @@ -114,17 +114,19 @@ func TestCreateChainTxNoSuchSubnet(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) tx.Unsigned.(*txs.CreateChainTx).SubnetID = ids.GenerateTestID() @@ -152,17 +154,19 @@ func TestCreateChainTxValid(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -221,21 +225,22 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) { env.state.SetTimestamp(test.time) // to duly set fee - cfg := *env.config + config := *env.config + config.StaticFeeConfig.CreateBlockchainTxFee = test.fee + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + config: &config, + subnetIDs: []ids.ID{subnetID}, + }) - cfg.StaticFeeConfig.CreateBlockchainTxFee = test.fee - factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, ids.GenerateTestID(), nil, "", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -261,17 +266,19 @@ func TestEtnaCreateChainTxInvalidWithManagedSubnet(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewCreateChainTx( - testSubnet1.ID(), + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueCreateChainTx( + subnetID, nil, constants.AVMID, nil, "chain name", ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -279,7 +286,7 @@ func TestEtnaCreateChainTxInvalidWithManagedSubnet(t *testing.T) { builderDiff, err := state.NewDiffOn(stateDiff) require.NoError(err) - stateDiff.SetSubnetManager(testSubnet1.ID(), ids.GenerateTestID(), []byte{'a', 'd', 'd', 'r', 'e', 's', 's'}) + stateDiff.SetSubnetManager(subnetID, ids.GenerateTestID(), []byte{'a', 'd', 'd', 'r', 'e', 's', 's'}) feeCalculator := state.PickFeeCalculator(env.config, builderDiff) executor := StandardTxExecutor{ diff --git a/vms/platformvm/txs/executor/create_subnet_test.go b/vms/platformvm/txs/executor/create_subnet_test.go index ad51fdc0b2b0..0290d1811401 100644 --- a/vms/platformvm/txs/executor/create_subnet_test.go +++ b/vms/platformvm/txs/executor/create_subnet_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "testing" "time" @@ -16,11 +15,8 @@ import ( "github.com/ava-labs/avalanchego/utils/units" "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/state" - "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestCreateSubnetTxAP3FeeChange(t *testing.T) { @@ -66,16 +62,16 @@ func TestCreateSubnetTxAP3FeeChange(t *testing.T) { addrs.Add(key.Address()) } - cfg := *env.config - cfg.StaticFeeConfig.CreateSubnetTxFee = test.fee - factory := txstest.NewWalletFactory(env.ctx, &cfg, env.state) - builder, signer := factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewCreateSubnetTx( + config := *env.config + config.StaticFeeConfig.CreateSubnetTxFee = test.fee + wallet := newWallet(t, env, walletConfig{ + config: &config, + }) + + tx, err := wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{}, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/export_test.go b/vms/platformvm/txs/executor/export_test.go index a6f292c92c33..34b1e8046454 100644 --- a/vms/platformvm/txs/executor/export_test.go +++ b/vms/platformvm/txs/executor/export_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "testing" "time" @@ -12,13 +11,10 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/upgrade/upgradetest" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/vms/components/avax" "github.com/ava-labs/avalanchego/vms/platformvm/genesis/genesistest" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestNewExportTx(t *testing.T) { @@ -26,53 +22,43 @@ func TestNewExportTx(t *testing.T) { env.ctx.Lock.Lock() defer env.ctx.Lock.Unlock() - type test struct { + tests := []struct { description string destinationChainID ids.ID - sourceKeys []*secp256k1.PrivateKey timestamp time.Time - } - - sourceKey := genesistest.DefaultFundedKeys[0] - - tests := []test{ + }{ { description: "P->X export", destinationChainID: env.ctx.XChainID, - sourceKeys: []*secp256k1.PrivateKey{sourceKey}, timestamp: genesistest.DefaultValidatorStartTime, }, { description: "P->C export", destinationChainID: env.ctx.CChainID, - sourceKeys: []*secp256k1.PrivateKey{sourceKey}, timestamp: env.config.UpgradeConfig.ApricotPhase5Time, }, } - to := ids.GenerateTestShortID() for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { require := require.New(t) - builder, signer := env.factory.NewWallet(tt.sourceKeys...) - utx, err := builder.NewExportTx( + wallet := newWallet(t, env, walletConfig{}) + + tx, err := wallet.IssueExportTx( tt.destinationChainID, []*avax.TransferableOutput{{ Asset: avax.Asset{ID: env.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ Amt: genesistest.DefaultInitialBalance - defaultTxFee, OutputOwners: secp256k1fx.OutputOwners{ - Locktime: 0, Threshold: 1, - Addrs: []ids.ShortID{to}, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, }, }, }}, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/helpers_test.go b/vms/platformvm/txs/executor/helpers_test.go index e740178fbe48..595f4cc2ae62 100644 --- a/vms/platformvm/txs/executor/helpers_test.go +++ b/vms/platformvm/txs/executor/helpers_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "math" "testing" "time" @@ -25,6 +24,7 @@ import ( "github.com/ava-labs/avalanchego/upgrade/upgradetest" "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/avalanchego/utils/constants" + "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/timer/mockable" "github.com/ava-labs/avalanchego/utils/units" @@ -40,9 +40,7 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs/txstest" "github.com/ava-labs/avalanchego/vms/platformvm/utxo" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" + "github.com/ava-labs/avalanchego/wallet/chain/p/wallet" ) const ( @@ -57,8 +55,7 @@ const ( var ( lastAcceptedID = ids.GenerateTestID() - testSubnet1 *txs.Tx - testSubnet1ControlKeys = genesistest.DefaultFundedKeys[0:3] + testSubnet1 *txs.Tx ) type mutableSharedMemory struct { @@ -77,7 +74,6 @@ type environment struct { states map[ids.ID]state.Chain uptimes uptime.Manager utxosHandler utxo.Verifier - factory *txstest.WalletFactory backend Backend } @@ -124,8 +120,6 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { uptimes := uptime.NewManager(baseState, clk) utxosVerifier := utxo.NewVerifier(ctx, clk, fx) - factory := txstest.NewWalletFactory(ctx, config, baseState) - backend := Backend{ Config: config, Ctx: ctx, @@ -149,7 +143,6 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { states: make(map[ids.ID]state.Chain), uptimes: uptimes, utxosHandler: utxosVerifier, - factory: factory, backend: backend, } @@ -182,11 +175,40 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { return env } +type walletConfig struct { + config *config.Config + keys []*secp256k1.PrivateKey + subnetIDs []ids.ID + chainIDs []ids.ID +} + +func newWallet(t testing.TB, e *environment, c walletConfig) wallet.Wallet { + if c.config == nil { + c.config = e.config + } + if len(c.keys) == 0 { + c.keys = genesistest.DefaultFundedKeys + } + return txstest.NewWallet( + t, + e.ctx, + c.config, + e.state, + secp256k1fx.NewKeychain(c.keys...), + c.subnetIDs, + c.chainIDs, + ) +} + func addSubnet(t *testing.T, env *environment) { require := require.New(t) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewCreateSubnetTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + + var err error + testSubnet1, err = wallet.IssueCreateSubnetTx( &secp256k1fx.OutputOwners{ Threshold: 2, Addrs: []ids.ShortID{ @@ -195,14 +217,8 @@ func addSubnet(t *testing.T, env *environment) { genesistest.DefaultFundedKeys[2].Address(), }, }, - common.WithChangeOwner(&secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{genesistest.DefaultFundedKeys[0].Address()}, - }), ) require.NoError(err) - testSubnet1, err = walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) diff --git a/vms/platformvm/txs/executor/import_test.go b/vms/platformvm/txs/executor/import_test.go index 6cc5c8a0cb38..d3c48f17e186 100644 --- a/vms/platformvm/txs/executor/import_test.go +++ b/vms/platformvm/txs/executor/import_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "math/rand" "testing" "time" @@ -21,8 +20,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) var fundedSharedMemoryCalls byte @@ -34,7 +31,6 @@ func TestNewImportTx(t *testing.T) { description string sourceChainID ids.ID sharedMemory atomic.SharedMemory - sourceKeys []*secp256k1.PrivateKey timestamp time.Time expectedErr error } @@ -59,7 +55,6 @@ func TestNewImportTx(t *testing.T) { }, randSrc, ), - sourceKeys: []*secp256k1.PrivateKey{sourceKey}, expectedErr: builder.ErrInsufficientFunds, }, { @@ -75,7 +70,6 @@ func TestNewImportTx(t *testing.T) { }, randSrc, ), - sourceKeys: []*secp256k1.PrivateKey{sourceKey}, expectedErr: nil, }, { @@ -91,7 +85,6 @@ func TestNewImportTx(t *testing.T) { }, randSrc, ), - sourceKeys: []*secp256k1.PrivateKey{sourceKey}, timestamp: env.config.UpgradeConfig.ApricotPhase5Time, expectedErr: nil, }, @@ -109,7 +102,6 @@ func TestNewImportTx(t *testing.T) { }, randSrc, ), - sourceKeys: []*secp256k1.PrivateKey{sourceKey}, timestamp: env.config.UpgradeConfig.ApricotPhase5Time, expectedErr: nil, }, @@ -125,8 +117,12 @@ func TestNewImportTx(t *testing.T) { env.msm.SharedMemory = tt.sharedMemory - builder, signer := env.factory.NewWallet(tt.sourceKeys...) - utx, err := builder.NewImportTx( + wallet := newWallet(t, env, walletConfig{ + keys: []*secp256k1.PrivateKey{sourceKey}, + chainIDs: []ids.ID{tt.sourceChainID}, + }) + + tx, err := wallet.IssueImportTx( tt.sourceChainID, to, ) @@ -134,8 +130,6 @@ func TestNewImportTx(t *testing.T) { if tt.expectedErr != nil { return } - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) unsignedTx := tx.Unsigned.(*txs.ImportTx) require.NotEmpty(unsignedTx.ImportedInputs) diff --git a/vms/platformvm/txs/executor/proposal_tx_executor_test.go b/vms/platformvm/txs/executor/proposal_tx_executor_test.go index e7d79ca58eba..70687a965836 100644 --- a/vms/platformvm/txs/executor/proposal_tx_executor_test.go +++ b/vms/platformvm/txs/executor/proposal_tx_executor_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "math" "testing" "time" @@ -22,13 +21,14 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func TestProposalTxExecuteAddDelegator(t *testing.T) { dummyHeight := uint64(1) - rewardAddress := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } nodeID := genesistest.DefaultNodeIDs[0] newValidatorID := ids.GenerateTestNodeID() @@ -40,23 +40,21 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) { addMinStakeValidator := func(env *environment) { require := require.New(t) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: newValidatorID, Start: newValidatorStartTime, End: newValidatorEndTime, Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addValTx := tx.Unsigned.(*txs.AddValidatorTx) staker, err := state.NewCurrentStaker( @@ -78,23 +76,21 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) { addMaxStakeValidator := func(env *environment) { require := require.New(t) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: newValidatorID, Start: newValidatorStartTime, End: newValidatorEndTime, Wght: env.config.MaxValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addValTx := tx.Unsigned.(*txs.AddValidatorTx) staker, err := state.NewCurrentStaker( @@ -246,22 +242,20 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) { env := newEnvironment(t, upgradetest.ApricotPhase5) env.config.UpgradeConfig.ApricotPhase3Time = tt.AP3Time - builder, signer := env.factory.NewWallet(tt.feeKeys...) - utx, err := builder.NewAddDelegatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: tt.feeKeys, + }) + + tx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: tt.nodeID, Start: tt.startTime, End: tt.endTime, Wght: tt.stakeAmount, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) if tt.setup != nil { tt.setup(env) @@ -294,12 +288,15 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { defer env.ctx.Lock.Unlock() nodeID := genesistest.DefaultNodeIDs[0] + subnetID := testSubnet1.ID() { // Case: Proposed validator currently validating primary network // but stops validating subnet after stops validating primary network // (note that keys[0] is a genesis validator) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -307,12 +304,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -337,8 +332,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { // and proposed subnet validation period is subset of // primary network validation period // (note that keys[0] is a genesis validator) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -346,12 +343,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -376,8 +371,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { dsStartTime := genesistest.DefaultValidatorStartTime.Add(10 * time.Second) dsEndTime := dsStartTime.Add(5 * defaultMinStakingDuration) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + addDSTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: pendingDSValidatorID, Start: uint64(dsStartTime.Unix()), @@ -391,13 +388,13 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addDSTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) { // Case: Proposed validator isn't in pending or current validator sets - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -405,12 +402,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -450,8 +445,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Case: Proposed validator is pending validator of primary network // but starts validating subnet before primary network - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -459,12 +456,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -487,8 +482,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Case: Proposed validator is pending validator of primary network // but stops validating subnet after primary network - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -496,12 +493,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()) + 1, // stop validating subnet after stopping validating primary network Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -524,8 +519,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Case: Proposed validator is pending validator of primary network and // period validating subnet is subset of time validating primary network - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -533,12 +530,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()), // same end time as for primary network Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -563,8 +558,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { env.state.SetTimestamp(newTimestamp) { - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -572,12 +569,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(newTimestamp.Add(defaultMinStakingDuration).Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -602,8 +597,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { // Case: Proposed validator already validating the subnet // First, add validator as validator of subnet - builder, signer = env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - uSubnetTx, err := builder.NewAddSubnetValidatorTx( + wallet = newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + subnetTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -611,12 +608,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - subnetTx, err := walletsigner.SignUnsigned(context.Background(), signer, uSubnetTx) - require.NoError(err) addSubnetValTx := subnetTx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err = state.NewCurrentStaker( @@ -634,8 +629,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Node with ID nodeIDKey.Address() now validating subnet with ID testSubnet1.ID - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet = newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + duplicateSubnetTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -643,12 +640,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - duplicateSubnetTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -674,8 +669,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Case: Too few signatures - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet = newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -683,12 +680,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration).Unix()) + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Remove a signature addSubnetValidatorTx := tx.Unsigned.(*txs.AddSubnetValidatorTx) @@ -717,8 +712,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Case: Control Signature from invalid key (keys[3] is not a control key) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], genesistest.DefaultFundedKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet = newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -726,12 +723,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration).Unix()) + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Replace a valid signature with one from keys[3] sig, err := genesistest.DefaultFundedKeys[3].SignHash(hashing.ComputeHash256(tx.Unsigned.Bytes())) @@ -759,8 +754,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { { // Case: Proposed validator in pending validator set for subnet // First, add validator to pending validator set of subnet - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet = newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -768,12 +765,10 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) { End: uint64(genesistest.DefaultValidatorStartTime.Add(defaultMinStakingDuration).Unix()) + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addSubnetValTx := subnetTx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err = state.NewCurrentStaker( @@ -816,26 +811,25 @@ func TestProposalTxExecuteAddValidator(t *testing.T) { nodeID := ids.GenerateTestNodeID() chainTime := env.state.GetTimestamp() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } { // Case: Validator's start time too early - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(chainTime.Unix()), End: genesistest.DefaultValidatorEndTimeUnix, Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -859,23 +853,18 @@ func TestProposalTxExecuteAddValidator(t *testing.T) { nodeID := genesistest.DefaultNodeIDs[0] // Case: Validator already validating primary network - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: genesistest.DefaultValidatorStartTimeUnix + 1, End: genesistest.DefaultValidatorEndTimeUnix, Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onCommitState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -898,23 +887,18 @@ func TestProposalTxExecuteAddValidator(t *testing.T) { { // Case: Validator in pending validator set of primary network startTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), End: uint64(startTime.Add(defaultMinStakingDuration).Unix()), Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addValTx := tx.Unsigned.(*txs.AddValidatorTx) staker, err := state.NewCurrentStaker( @@ -951,23 +935,20 @@ func TestProposalTxExecuteAddValidator(t *testing.T) { { // Case: Validator doesn't have enough tokens to cover stake amount - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.GenerateTestNodeID(), Start: genesistest.DefaultValidatorStartTimeUnix + 1, End: genesistest.DefaultValidatorEndTimeUnix, Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Remove all UTXOs owned by preFundedKeys[0] utxoIDs, err := env.state.UTXOIDs(genesistest.DefaultFundedKeys[0].Address().Bytes(), ids.Empty, math.MaxInt32) diff --git a/vms/platformvm/txs/executor/reward_validator_test.go b/vms/platformvm/txs/executor/reward_validator_test.go index 27dd9d304937..55f210ebc95f 100644 --- a/vms/platformvm/txs/executor/reward_validator_test.go +++ b/vms/platformvm/txs/executor/reward_validator_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "testing" "time" @@ -24,8 +23,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" "github.com/ava-labs/avalanchego/vms/secp256k1fx" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) func newRewardValidatorTx(t testing.TB, txID ids.ID) (*txs.Tx, error) { @@ -244,6 +241,8 @@ func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) { env := newEnvironment(t, upgradetest.ApricotPhase5) dummyHeight := uint64(1) + wallet := newWallet(t, env, walletConfig{}) + vdrRewardAddress := ids.GenerateTestShortID() delRewardAddress := ids.GenerateTestShortID() @@ -251,8 +250,7 @@ func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) { vdrEndTime := uint64(genesistest.DefaultValidatorStartTime.Add(2 * defaultMinStakingDuration).Unix()) vdrNodeID := ids.GenerateTestNodeID() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uVdrTx, err := builder.NewAddValidatorTx( + vdrTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: vdrStartTime, @@ -266,13 +264,11 @@ func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) { reward.PercentDenominator/4, ) require.NoError(err) - vdrTx, err := walletsigner.SignUnsigned(context.Background(), signer, uVdrTx) - require.NoError(err) delStartTime := vdrStartTime delEndTime := vdrEndTime - uDelTx, err := builder.NewAddDelegatorTx( + delTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: delStartTime, @@ -285,8 +281,6 @@ func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) { }, ) require.NoError(err) - delTx, err := walletsigner.SignUnsigned(context.Background(), signer, uDelTx) - require.NoError(err) addValTx := vdrTx.Unsigned.(*txs.AddValidatorTx) vdrStaker, err := state.NewCurrentStaker( @@ -378,6 +372,8 @@ func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { env := newEnvironment(t, upgradetest.Cortina) dummyHeight := uint64(1) + wallet := newWallet(t, env, walletConfig{}) + vdrRewardAddress := ids.GenerateTestShortID() delRewardAddress := ids.GenerateTestShortID() @@ -385,8 +381,7 @@ func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { vdrEndTime := uint64(genesistest.DefaultValidatorStartTime.Add(2 * defaultMinStakingDuration).Unix()) vdrNodeID := ids.GenerateTestNodeID() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uVdrTx, err := builder.NewAddValidatorTx( + vdrTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: vdrStartTime, @@ -400,13 +395,11 @@ func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { reward.PercentDenominator/4, ) require.NoError(err) - vdrTx, err := walletsigner.SignUnsigned(context.Background(), signer, uVdrTx) - require.NoError(err) delStartTime := vdrStartTime delEndTime := vdrEndTime - uDelTx, err := builder.NewAddDelegatorTx( + delTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: delStartTime, @@ -419,8 +412,6 @@ func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) { }, ) require.NoError(err) - delTx, err := walletsigner.SignUnsigned(context.Background(), signer, uDelTx) - require.NoError(err) addValTx := vdrTx.Unsigned.(*txs.AddValidatorTx) vdrRewardAmt := uint64(2000000) @@ -608,6 +599,8 @@ func TestRewardDelegatorTxAndValidatorTxExecuteOnCommitPostDelegateeDeferral(t * env := newEnvironment(t, upgradetest.Cortina) dummyHeight := uint64(1) + wallet := newWallet(t, env, walletConfig{}) + vdrRewardAddress := ids.GenerateTestShortID() delRewardAddress := ids.GenerateTestShortID() @@ -615,8 +608,7 @@ func TestRewardDelegatorTxAndValidatorTxExecuteOnCommitPostDelegateeDeferral(t * vdrEndTime := uint64(genesistest.DefaultValidatorStartTime.Add(2 * defaultMinStakingDuration).Unix()) vdrNodeID := ids.GenerateTestNodeID() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uVdrTx, err := builder.NewAddValidatorTx( + vdrTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: vdrStartTime, @@ -630,13 +622,11 @@ func TestRewardDelegatorTxAndValidatorTxExecuteOnCommitPostDelegateeDeferral(t * reward.PercentDenominator/4, ) require.NoError(err) - vdrTx, err := walletsigner.SignUnsigned(context.Background(), signer, uVdrTx) - require.NoError(err) delStartTime := vdrStartTime delEndTime := vdrEndTime - uDelTx, err := builder.NewAddDelegatorTx( + delTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: delStartTime, @@ -649,8 +639,6 @@ func TestRewardDelegatorTxAndValidatorTxExecuteOnCommitPostDelegateeDeferral(t * }, ) require.NoError(err) - delTx, err := walletsigner.SignUnsigned(context.Background(), signer, uDelTx) - require.NoError(err) addValTx := vdrTx.Unsigned.(*txs.AddValidatorTx) vdrRewardAmt := uint64(2000000) @@ -781,6 +769,8 @@ func TestRewardDelegatorTxExecuteOnAbort(t *testing.T) { env := newEnvironment(t, upgradetest.ApricotPhase5) dummyHeight := uint64(1) + wallet := newWallet(t, env, walletConfig{}) + initialSupply, err := env.state.GetCurrentSupply(constants.PrimaryNetworkID) require.NoError(err) @@ -791,8 +781,7 @@ func TestRewardDelegatorTxExecuteOnAbort(t *testing.T) { vdrEndTime := uint64(genesistest.DefaultValidatorStartTime.Add(2 * defaultMinStakingDuration).Unix()) vdrNodeID := ids.GenerateTestNodeID() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - uVdrTx, err := builder.NewAddValidatorTx( + vdrTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: vdrStartTime, @@ -806,13 +795,11 @@ func TestRewardDelegatorTxExecuteOnAbort(t *testing.T) { reward.PercentDenominator/4, ) require.NoError(err) - vdrTx, err := walletsigner.SignUnsigned(context.Background(), signer, uVdrTx) - require.NoError(err) delStartTime := vdrStartTime delEndTime := vdrEndTime - uDelTx, err := builder.NewAddDelegatorTx( + delTx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: vdrNodeID, Start: delStartTime, @@ -825,8 +812,6 @@ func TestRewardDelegatorTxExecuteOnAbort(t *testing.T) { }, ) require.NoError(err) - delTx, err := walletsigner.SignUnsigned(context.Background(), signer, uDelTx) - require.NoError(err) addValTx := vdrTx.Unsigned.(*txs.AddValidatorTx) vdrStaker, err := state.NewCurrentStaker( diff --git a/vms/platformvm/txs/executor/standard_tx_executor_test.go b/vms/platformvm/txs/executor/standard_tx_executor_test.go index d0652e6bd419..2b01148a7f76 100644 --- a/vms/platformvm/txs/executor/standard_tx_executor_test.go +++ b/vms/platformvm/txs/executor/standard_tx_executor_test.go @@ -4,7 +4,6 @@ package executor import ( - "context" "errors" "math" "math/rand" @@ -37,8 +36,6 @@ import ( "github.com/ava-labs/avalanchego/vms/platformvm/utxo/utxomock" "github.com/ava-labs/avalanchego/vms/secp256k1fx" "github.com/ava-labs/avalanchego/wallet/subnet/primary/common" - - walletsigner "github.com/ava-labs/avalanchego/wallet/chain/p/signer" ) // This tests that the math performed during TransformSubnetTx execution can @@ -57,28 +54,25 @@ func TestStandardTxExecutorAddValidatorTxEmptyID(t *testing.T) { startTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) tests := []struct { - banffTime time.Time - expectedError error + banffTime time.Time }{ { // Case: Before banff - banffTime: chainTime.Add(1), - expectedError: errEmptyNodeID, + banffTime: chainTime.Add(1), }, { // Case: At banff - banffTime: chainTime, - expectedError: errEmptyNodeID, + banffTime: chainTime, }, { // Case: After banff - banffTime: chainTime.Add(-1), - expectedError: errEmptyNodeID, + banffTime: chainTime.Add(-1), }, } for _, test := range tests { // Case: Empty validator node ID after banff env.config.UpgradeConfig.BanffTime = test.banffTime - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: ids.EmptyNodeID, Start: uint64(startTime.Unix()), @@ -92,8 +86,6 @@ func TestStandardTxExecutorAddValidatorTxEmptyID(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) stateDiff, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -106,13 +98,16 @@ func TestStandardTxExecutorAddValidatorTxEmptyID(t *testing.T) { Tx: tx, } err = tx.Unsigned.Visit(&executor) - require.ErrorIs(err, test.expectedError) + require.ErrorIs(err, errEmptyNodeID) } } func TestStandardTxExecutorAddDelegator(t *testing.T) { dummyHeight := uint64(1) - rewardAddress := genesistest.DefaultFundedKeys[0].Address() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } nodeID := genesistest.DefaultNodeIDs[0] newValidatorID := ids.GenerateTestNodeID() @@ -124,23 +119,20 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) { addMinStakeValidator := func(env *environment) { require := require.New(t) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: newValidatorID, Start: uint64(newValidatorStartTime.Unix()), End: uint64(newValidatorEndTime.Unix()), Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addValTx := tx.Unsigned.(*txs.AddValidatorTx) staker, err := state.NewCurrentStaker( @@ -162,23 +154,20 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) { addMaxStakeValidator := func(env *environment) { require := require.New(t) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: newValidatorID, Start: uint64(newValidatorStartTime.Unix()), End: uint64(newValidatorEndTime.Unix()), Wght: env.config.MaxValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addValTx := tx.Unsigned.(*txs.AddValidatorTx) staker, err := state.NewCurrentStaker( @@ -330,22 +319,19 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) { env := newEnvironment(t, upgradetest.ApricotPhase5) env.config.UpgradeConfig.ApricotPhase3Time = tt.AP3Time - builder, signer := env.factory.NewWallet(tt.feeKeys...) - utx, err := builder.NewAddDelegatorTx( + wallet := newWallet(t, env, walletConfig{ + keys: tt.feeKeys, + }) + tx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: tt.nodeID, Start: uint64(tt.startTime.Unix()), End: uint64(tt.endTime.Unix()), Wght: tt.stakeAmount, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{rewardAddress}, - }, + rewardsOwner, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) if tt.setup != nil { tt.setup(env) @@ -376,14 +362,18 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { defer env.ctx.Lock.Unlock() nodeID := genesistest.DefaultNodeIDs[0] + subnetID := testSubnet1.ID() { // Case: Proposed validator currently validating primary network // but stops validating subnet after stops validating primary network // (note that keys[0] is a genesis validator) startTime := genesistest.DefaultValidatorStartTime.Add(time.Second) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -391,12 +381,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -417,8 +405,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { // and proposed subnet validation period is subset of // primary network validation period // (note that keys[0] is a genesis validator) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -426,12 +416,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -452,8 +440,8 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { dsStartTime := genesistest.DefaultValidatorStartTime.Add(10 * time.Second) dsEndTime := dsStartTime.Add(5 * defaultMinStakingDuration) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + addDSTx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: pendingDSValidatorID, Start: uint64(dsStartTime.Unix()), @@ -467,13 +455,13 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { reward.PercentDenominator, ) require.NoError(err) - addDSTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) { // Case: Proposed validator isn't in pending or current validator sets - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -481,12 +469,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -522,8 +508,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Case: Proposed validator is pending validator of primary network // but starts validating subnet before primary network - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -531,12 +519,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -555,8 +541,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Case: Proposed validator is pending validator of primary network // but stops validating subnet after primary network - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -564,12 +552,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()) + 1, // stop validating subnet after stopping validating primary network Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -588,8 +574,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Case: Proposed validator is pending validator of primary network and // period validating subnet is subset of time validating primary network - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: pendingDSValidatorID, @@ -597,12 +585,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(dsEndTime.Unix()), // same end time as for primary network Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -623,8 +609,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { env.state.SetTimestamp(newTimestamp) { - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -632,12 +620,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(newTimestamp.Add(defaultMinStakingDuration).Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -658,8 +644,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { // Case: Proposed validator already validating the subnet // First, add validator as validator of subnet - builder, signer = env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - uSubnetTx, err := builder.NewAddSubnetValidatorTx( + wallet = newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + subnetTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -667,12 +655,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - subnetTx, err := walletsigner.SignUnsigned(context.Background(), signer, uSubnetTx) - require.NoError(err) addSubnetValTx := subnetTx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err = state.NewCurrentStaker( @@ -691,8 +677,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Node with ID nodeIDKey.Address() now validating subnet with ID testSubnet1.ID startTime := genesistest.DefaultValidatorStartTime.Add(time.Second) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -700,12 +688,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -728,8 +714,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Case: Duplicate signatures startTime := genesistest.DefaultValidatorStartTime.Add(time.Second) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1], testSubnet1ControlKeys[2]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -737,12 +725,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(startTime.Add(defaultMinStakingDuration).Unix()) + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Duplicate a signature addSubnetValidatorTx := tx.Unsigned.(*txs.AddSubnetValidatorTx) @@ -768,8 +754,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Case: Too few signatures startTime := genesistest.DefaultValidatorStartTime.Add(time.Second) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[2]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -777,12 +765,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(startTime.Add(defaultMinStakingDuration).Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Remove a signature addSubnetValidatorTx := tx.Unsigned.(*txs.AddSubnetValidatorTx) @@ -808,8 +794,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { { // Case: Control Signature from invalid key (keys[3] is not a control key) startTime := genesistest.DefaultValidatorStartTime.Add(time.Second) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], genesistest.DefaultFundedKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -817,12 +805,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(startTime.Add(defaultMinStakingDuration).Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Replace a valid signature with one from keys[3] sig, err := genesistest.DefaultFundedKeys[3].SignHash(hashing.ComputeHash256(tx.Unsigned.Bytes())) @@ -847,8 +833,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { // Case: Proposed validator in pending validator set for subnet // First, add validator to pending validator set of subnet startTime := genesistest.DefaultValidatorStartTime.Add(time.Second) - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -856,12 +844,10 @@ func TestApricotStandardTxExecutorAddSubnetValidator(t *testing.T) { End: uint64(startTime.Add(defaultMinStakingDuration).Unix()) + 1, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addSubnetValTx := subnetTx.Unsigned.(*txs.AddSubnetValidatorTx) staker, err = state.NewCurrentStaker( @@ -899,9 +885,12 @@ func TestEtnaStandardTxExecutorAddSubnetValidator(t *testing.T) { defer env.ctx.Lock.Unlock() nodeID := genesistest.DefaultNodeIDs[0] + subnetID := testSubnet1.ID() - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -909,17 +898,15 @@ func TestEtnaStandardTxExecutorAddSubnetValidator(t *testing.T) { End: genesistest.DefaultValidatorEndTimeUnix, Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) - onAcceptState.SetSubnetManager(testSubnet1.ID(), ids.GenerateTestID(), []byte{'a', 'd', 'd', 'r', 'e', 's', 's'}) + onAcceptState.SetSubnetManager(subnetID, ids.GenerateTestID(), []byte{'a', 'd', 'd', 'r', 'e', 's', 's'}) executor := StandardTxExecutor{ Backend: &env.backend, @@ -937,26 +924,25 @@ func TestBanffStandardTxExecutorAddValidator(t *testing.T) { defer env.ctx.Lock.Unlock() nodeID := ids.GenerateTestNodeID() + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } { // Case: Validator's start time too early - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: genesistest.DefaultValidatorStartTimeUnix - 1, End: genesistest.DefaultValidatorEndTimeUnix, Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) onAcceptState, err := state.NewDiff(lastAcceptedID, env) require.NoError(err) @@ -974,24 +960,20 @@ func TestBanffStandardTxExecutorAddValidator(t *testing.T) { { // Case: Validator in current validator set of primary network + wallet := newWallet(t, env, walletConfig{}) + startTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), End: uint64(startTime.Add(defaultMinStakingDuration).Unix()), Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) addValTx := tx.Unsigned.(*txs.AddValidatorTx) staker, err := state.NewCurrentStaker( @@ -1021,24 +1003,20 @@ func TestBanffStandardTxExecutorAddValidator(t *testing.T) { { // Case: Validator in pending validator set of primary network + wallet := newWallet(t, env, walletConfig{}) + startTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), End: uint64(startTime.Add(defaultMinStakingDuration).Unix()), Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) staker, err := state.NewPendingStaker( tx.ID(), @@ -1065,24 +1043,22 @@ func TestBanffStandardTxExecutorAddValidator(t *testing.T) { { // Case: Validator doesn't have enough tokens to cover stake amount + wallet := newWallet(t, env, walletConfig{ + keys: genesistest.DefaultFundedKeys[:1], + }) + startTime := genesistest.DefaultValidatorStartTime.Add(1 * time.Second) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys[0]) - utx, err := builder.NewAddValidatorTx( + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: uint64(startTime.Unix()), End: uint64(startTime.Add(defaultMinStakingDuration).Unix()), Wght: env.config.MinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(err) // Remove all UTXOs owned by preFundedKeys[0] utxoIDs, err := env.state.UTXOIDs(genesistest.DefaultFundedKeys[0].Address().Bytes(), ids.Empty, math.MaxInt32) @@ -1111,37 +1087,37 @@ func TestBanffStandardTxExecutorAddValidator(t *testing.T) { func TestDurangoDisabledTransactions(t *testing.T) { type test struct { name string - buildTx func(*environment) *txs.Tx + buildTx func(t *testing.T, env *environment) *txs.Tx expectedErr error } + rewardsOwner := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, + } + tests := []test{ { name: "AddValidatorTx", - buildTx: func(env *environment) *txs.Tx { + buildTx: func(t *testing.T, env *environment) *txs.Tx { var ( nodeID = ids.GenerateTestNodeID() chainTime = env.state.GetTimestamp() endTime = chainTime.Add(defaultMaxStakingDuration) ) - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewAddValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddValidatorTx( &txs.Validator{ NodeID: nodeID, Start: 0, End: uint64(endTime.Unix()), Wght: defaultMinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + rewardsOwner, reward.PercentDenominator, ) require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) return tx }, @@ -1149,10 +1125,12 @@ func TestDurangoDisabledTransactions(t *testing.T) { }, { name: "AddDelegatorTx", - buildTx: func(env *environment) *txs.Tx { + buildTx: func(t *testing.T, env *environment) *txs.Tx { + require := require.New(t) + var primaryValidator *state.Staker it, err := env.state.GetCurrentStakerIterator() - require.NoError(t, err) + require.NoError(err) for it.Next() { staker := it.Value() if staker.Priority != txs.PrimaryNetworkValidatorCurrentPriority { @@ -1163,22 +1141,17 @@ func TestDurangoDisabledTransactions(t *testing.T) { } it.Release() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewAddDelegatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddDelegatorTx( &txs.Validator{ NodeID: primaryValidator.NodeID, Start: 0, End: uint64(primaryValidator.EndTime.Unix()), Wght: defaultMinValidatorStake, }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + rewardsOwner, ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) return tx }, @@ -1197,7 +1170,7 @@ func TestDurangoDisabledTransactions(t *testing.T) { onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) require.NoError(err) - tx := tt.buildTx(env) + tx := tt.buildTx(t, env) feeCalculator := state.PickFeeCalculator(env.config, onAcceptState) err = tx.Unsigned.Visit(&StandardTxExecutor{ @@ -1215,16 +1188,23 @@ func TestDurangoDisabledTransactions(t *testing.T) { func TestDurangoMemoField(t *testing.T) { type test struct { name string - setupTest func(env *environment, memoField []byte) (*txs.Tx, state.Diff) + setupTest func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) + } + + owners := &secp256k1fx.OutputOwners{ + Threshold: 1, + Addrs: []ids.ShortID{ids.GenerateTestShortID()}, } tests := []test{ { name: "AddSubnetValidatorTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + var primaryValidator *state.Staker it, err := env.state.GetCurrentStakerIterator() - require.NoError(t, err) + require.NoError(err) for it.Next() { staker := it.Value() if staker.Priority != txs.PrimaryNetworkValidatorCurrentPriority { @@ -1235,8 +1215,11 @@ func TestDurangoMemoField(t *testing.T) { } it.Release() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewAddSubnetValidatorTx( + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + tx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: primaryValidator.NodeID, @@ -1244,67 +1227,63 @@ func TestDurangoMemoField(t *testing.T) { End: uint64(primaryValidator.EndTime.Unix()), Wght: defaultMinValidatorStake, }, - Subnet: testSubnet1.TxID, + Subnet: subnetID, }, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) + require.NoError(err) return tx, onAcceptState }, }, { name: "CreateChainTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewCreateChainTx( - testSubnet1.TxID, + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueCreateChainTx( + subnetID, []byte{}, ids.GenerateTestID(), []ids.ID{}, "aaa", common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "CreateSubnetTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewCreateSubnetTx( - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueCreateSubnetTx( + owners, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "ImportTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - // Skip shared memory checks - env.backend.Bootstrapped.Set(false) + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) var ( sourceChain = env.ctx.XChainID @@ -1324,61 +1303,54 @@ func TestDurangoMemoField(t *testing.T) { ) env.msm.SharedMemory = sharedMemory - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewImportTx( + wallet := newWallet(t, env, walletConfig{ + chainIDs: []ids.ID{sourceChain}, + }) + + tx, err := wallet.IssueImportTx( sourceChain, - &secp256k1fx.OutputOwners{ - Locktime: 0, - Threshold: 1, - Addrs: []ids.ShortID{sourceKey.Address()}, - }, + owners, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "ExportTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewExportTx( + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueExportTx( env.ctx.XChainID, []*avax.TransferableOutput{{ Asset: avax.Asset{ID: env.ctx.AVAXAssetID}, Out: &secp256k1fx.TransferOutput{ - Amt: units.Avax, - OutputOwners: secp256k1fx.OutputOwners{ - Locktime: 0, - Threshold: 1, - Addrs: []ids.ShortID{ids.GenerateTestShortID()}, - }, + Amt: units.Avax, + OutputOwners: *owners, }, }}, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "RemoveSubnetValidatorTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + var primaryValidator *state.Staker it, err := env.state.GetCurrentStakerIterator() - require.NoError(t, err) + require.NoError(err) for it.Next() { staker := it.Value() if staker.Priority != txs.PrimaryNetworkValidatorCurrentPriority { @@ -1390,8 +1362,12 @@ func TestDurangoMemoField(t *testing.T) { it.Release() endTime := primaryValidator.EndTime - builder, signer := env.factory.NewWallet(testSubnet1ControlKeys[0], testSubnet1ControlKeys[1]) - utx, err := builder.NewAddSubnetValidatorTx( + + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + subnetValTx, err := wallet.IssueAddSubnetValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: primaryValidator.NodeID, @@ -1399,43 +1375,43 @@ func TestDurangoMemoField(t *testing.T) { End: uint64(endTime.Unix()), Wght: genesistest.DefaultValidatorWeight, }, - Subnet: testSubnet1.ID(), + Subnet: subnetID, }, ) - require.NoError(t, err) - subnetValTx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) + require.NoError(err) feeCalculator := state.PickFeeCalculator(env.config, onAcceptState) - require.NoError(t, subnetValTx.Unsigned.Visit(&StandardTxExecutor{ + require.NoError(subnetValTx.Unsigned.Visit(&StandardTxExecutor{ Backend: &env.backend, State: onAcceptState, FeeCalculator: feeCalculator, Tx: subnetValTx, })) - builder, signer = env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx2, err := builder.NewRemoveSubnetValidatorTx( + tx, err := wallet.IssueRemoveSubnetValidatorTx( primaryValidator.NodeID, - testSubnet1.ID(), + subnetID, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx2) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "TransformSubnetTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewTransformSubnetTx( - testSubnet1.TxID, // subnetID + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueTransformSubnetTx( + subnetID, // subnetID ids.GenerateTestID(), // assetID 10, // initial supply 10, // max supply @@ -1451,29 +1427,27 @@ func TestDurangoMemoField(t *testing.T) { 80, // uptime requirement common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "AddPermissionlessValidatorTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) var ( nodeID = ids.GenerateTestNodeID() chainTime = env.state.GetTimestamp() endTime = chainTime.Add(defaultMaxStakingDuration) ) sk, err := bls.NewSecretKey() - require.NoError(t, err) + require.NoError(err) - builder, txSigner := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewAddPermissionlessValidatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddPermissionlessValidatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: nodeID, @@ -1485,33 +1459,26 @@ func TestDurangoMemoField(t *testing.T) { }, signer.NewProofOfPossession(sk), env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + owners, + owners, reward.PercentDenominator, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), txSigner, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "AddPermissionlessDelegatorTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + var primaryValidator *state.Staker it, err := env.state.GetCurrentStakerIterator() - require.NoError(t, err) + require.NoError(err) for it.Next() { staker := it.Value() if staker.Priority != txs.PrimaryNetworkValidatorCurrentPriority { @@ -1522,8 +1489,8 @@ func TestDurangoMemoField(t *testing.T) { } it.Release() - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewAddPermissionlessDelegatorTx( + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueAddPermissionlessDelegatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ NodeID: primaryValidator.NodeID, @@ -1534,49 +1501,45 @@ func TestDurangoMemoField(t *testing.T) { Subnet: constants.PrimaryNetworkID, }, env.ctx.AVAXAssetID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + owners, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "TransferSubnetOwnershipTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewTransferSubnetOwnershipTx( - testSubnet1.TxID, - &secp256k1fx.OutputOwners{ - Threshold: 1, - Addrs: []ids.ShortID{ids.ShortEmpty}, - }, + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + + subnetID := testSubnet1.ID() + wallet := newWallet(t, env, walletConfig{ + subnetIDs: []ids.ID{subnetID}, + }) + + tx, err := wallet.IssueTransferSubnetOwnershipTx( + subnetID, + owners, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, { name: "BaseTx", - setupTest: func(env *environment, memoField []byte) (*txs.Tx, state.Diff) { - builder, signer := env.factory.NewWallet(genesistest.DefaultFundedKeys...) - utx, err := builder.NewBaseTx( + setupTest: func(t *testing.T, env *environment, memoField []byte) (*txs.Tx, state.Diff) { + require := require.New(t) + + wallet := newWallet(t, env, walletConfig{}) + tx, err := wallet.IssueBaseTx( []*avax.TransferableOutput{ { Asset: avax.Asset{ID: env.ctx.AVAXAssetID}, @@ -1591,13 +1554,10 @@ func TestDurangoMemoField(t *testing.T) { }, common.WithMemo(memoField), ) - require.NoError(t, err) - tx, err := walletsigner.SignUnsigned(context.Background(), signer, utx) - require.NoError(t, err) + require.NoError(err) onAcceptState, err := state.NewDiff(env.state.GetLastAccepted(), env) - require.NoError(t, err) - + require.NoError(err) return tx, onAcceptState }, }, @@ -1614,7 +1574,7 @@ func TestDurangoMemoField(t *testing.T) { feeCalculator := state.PickFeeCalculator(env.config, env.state) // Populated memo field should error - tx, onAcceptState := tt.setupTest(env, []byte{'m', 'e', 'm', 'o'}) + tx, onAcceptState := tt.setupTest(t, env, []byte{'m', 'e', 'm', 'o'}) err := tx.Unsigned.Visit(&StandardTxExecutor{ Backend: &env.backend, State: onAcceptState, @@ -1624,7 +1584,7 @@ func TestDurangoMemoField(t *testing.T) { require.ErrorIs(err, avax.ErrMemoTooLarge) // Empty memo field should not error - tx, onAcceptState = tt.setupTest(env, []byte{}) + tx, onAcceptState = tt.setupTest(t, env, []byte{}) require.NoError(tx.Unsigned.Visit(&StandardTxExecutor{ Backend: &env.backend, State: onAcceptState, diff --git a/vms/platformvm/txs/txstest/backend.go b/vms/platformvm/txs/txstest/backend.go deleted file mode 100644 index 3ef798c0b69d..000000000000 --- a/vms/platformvm/txs/txstest/backend.go +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. - -package txstest - -import ( - "context" - "math" - - "github.com/ava-labs/avalanchego/chains/atomic" - "github.com/ava-labs/avalanchego/ids" - "github.com/ava-labs/avalanchego/utils/constants" - "github.com/ava-labs/avalanchego/utils/set" - "github.com/ava-labs/avalanchego/vms/components/avax" - "github.com/ava-labs/avalanchego/vms/platformvm/fx" - "github.com/ava-labs/avalanchego/vms/platformvm/state" - "github.com/ava-labs/avalanchego/vms/platformvm/txs" - "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - "github.com/ava-labs/avalanchego/wallet/chain/p/signer" -) - -var ( - _ builder.Backend = (*Backend)(nil) - _ signer.Backend = (*Backend)(nil) -) - -func newBackend( - addrs set.Set[ids.ShortID], - state state.State, - sharedMemory atomic.SharedMemory, -) *Backend { - return &Backend{ - addrs: addrs, - state: state, - sharedMemory: sharedMemory, - } -} - -type Backend struct { - addrs set.Set[ids.ShortID] - state state.State - sharedMemory atomic.SharedMemory -} - -func (b *Backend) UTXOs(_ context.Context, sourceChainID ids.ID) ([]*avax.UTXO, error) { - if sourceChainID == constants.PlatformChainID { - return avax.GetAllUTXOs(b.state, b.addrs) - } - - utxos, _, _, err := avax.GetAtomicUTXOs( - b.sharedMemory, - txs.Codec, - sourceChainID, - b.addrs, - ids.ShortEmpty, - ids.Empty, - math.MaxInt, - ) - return utxos, err -} - -func (b *Backend) GetUTXO(_ context.Context, chainID, utxoID ids.ID) (*avax.UTXO, error) { - if chainID == constants.PlatformChainID { - return b.state.GetUTXO(utxoID) - } - - utxoBytes, err := b.sharedMemory.Get(chainID, [][]byte{utxoID[:]}) - if err != nil { - return nil, err - } - - utxo := avax.UTXO{} - if _, err := txs.Codec.Unmarshal(utxoBytes[0], &utxo); err != nil { - return nil, err - } - return &utxo, nil -} - -func (b *Backend) GetSubnetOwner(_ context.Context, subnetID ids.ID) (fx.Owner, error) { - return b.state.GetSubnetOwner(subnetID) -} diff --git a/vms/platformvm/txs/txstest/builder.go b/vms/platformvm/txs/txstest/builder.go deleted file mode 100644 index 532720be981f..000000000000 --- a/vms/platformvm/txs/txstest/builder.go +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. - -package txstest - -import ( - "github.com/ava-labs/avalanchego/snow" - "github.com/ava-labs/avalanchego/utils/crypto/secp256k1" - "github.com/ava-labs/avalanchego/vms/platformvm/config" - "github.com/ava-labs/avalanchego/vms/platformvm/state" - "github.com/ava-labs/avalanchego/vms/secp256k1fx" - "github.com/ava-labs/avalanchego/wallet/chain/p/builder" - "github.com/ava-labs/avalanchego/wallet/chain/p/signer" -) - -func NewWalletFactory( - ctx *snow.Context, - cfg *config.Config, - state state.State, -) *WalletFactory { - return &WalletFactory{ - ctx: ctx, - cfg: cfg, - state: state, - } -} - -type WalletFactory struct { - ctx *snow.Context - cfg *config.Config - state state.State -} - -func (w *WalletFactory) NewWallet(keys ...*secp256k1.PrivateKey) (builder.Builder, signer.Signer) { - var ( - kc = secp256k1fx.NewKeychain(keys...) - addrs = kc.Addresses() - backend = newBackend(addrs, w.state, w.ctx.SharedMemory) - context = newContext(w.ctx, w.cfg, w.state.GetTimestamp()) - ) - - return builder.New(addrs, context, backend), signer.New(kc, backend) -} From f9fb26154d5d3d48db3ef7644a0110d0d7e53465 Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Mon, 26 Aug 2024 13:25:16 -0400 Subject: [PATCH 110/114] nit --- vms/platformvm/block/builder/helpers_test.go | 2 -- vms/platformvm/block/executor/helpers_test.go | 11 ----------- 2 files changed, 13 deletions(-) diff --git a/vms/platformvm/block/builder/helpers_test.go b/vms/platformvm/block/builder/helpers_test.go index a8e311ebdf3c..02f7102a562c 100644 --- a/vms/platformvm/block/builder/helpers_test.go +++ b/vms/platformvm/block/builder/helpers_test.go @@ -84,7 +84,6 @@ type environment struct { state state.State uptimes uptime.Manager utxosVerifier utxo.Verifier - factory *txstest.WalletFactory backend txexecutor.Backend } @@ -124,7 +123,6 @@ func newEnvironment(t *testing.T, f upgradetest.Fork) *environment { //nolint:un res.uptimes = uptime.NewManager(res.state, res.clk) res.utxosVerifier = utxo.NewVerifier(res.ctx, res.clk, res.fx) - res.factory = txstest.NewWalletFactory(res.ctx, res.config, res.state) genesisID := res.state.GetLastAccepted() res.backend = txexecutor.Backend{ diff --git a/vms/platformvm/block/executor/helpers_test.go b/vms/platformvm/block/executor/helpers_test.go index b6c54d2d642b..f066b1fc13c7 100644 --- a/vms/platformvm/block/executor/helpers_test.go +++ b/vms/platformvm/block/executor/helpers_test.go @@ -96,7 +96,6 @@ type environment struct { mockedState *state.MockState uptimes uptime.Manager utxosVerifier utxo.Verifier - factory *txstest.WalletFactory backend *executor.Backend } @@ -130,20 +129,10 @@ func newEnvironment(t *testing.T, ctrl *gomock.Controller, f upgradetest.Fork) * res.uptimes = uptime.NewManager(res.state, res.clk) res.utxosVerifier = utxo.NewVerifier(res.ctx, res.clk, res.fx) - res.factory = txstest.NewWalletFactory( - res.ctx, - res.config, - res.state, - ) } else { res.mockedState = state.NewMockState(ctrl) res.uptimes = uptime.NewManager(res.mockedState, res.clk) res.utxosVerifier = utxo.NewVerifier(res.ctx, res.clk, res.fx) - res.factory = txstest.NewWalletFactory( - res.ctx, - res.config, - res.mockedState, - ) // setup expectations strictly needed for environment creation res.mockedState.EXPECT().GetLastAccepted().Return(ids.GenerateTestID()).Times(1) From 93d0397ac9baa08ebfbda1881333e40ab11abe4e Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Tue, 27 Aug 2024 18:53:28 -0400 Subject: [PATCH 111/114] reduce diff --- vms/platformvm/block/builder/builder.go | 28 ++++++------------------- 1 file changed, 6 insertions(+), 22 deletions(-) diff --git a/vms/platformvm/block/builder/builder.go b/vms/platformvm/block/builder/builder.go index fc0ac3396e01..35ad20adc16c 100644 --- a/vms/platformvm/block/builder/builder.go +++ b/vms/platformvm/block/builder/builder.go @@ -262,22 +262,13 @@ func (b *builder) PackAllBlockTxs() ([]*txs.Tx, error) { math.MaxInt, ) } - - stateDiff, err := state.NewDiffOn(preferredState) - if err != nil { - return nil, err - } - - if _, err := txexecutor.AdvanceTimeTo(b.txExecutorBackend, stateDiff, timestamp); err != nil { - return nil, err - } - - return packEtnaBlockTxsOn( + return packEtnaBlockTxs( preferredID, - stateDiff, + preferredState, b.Mempool, b.txExecutorBackend, b.blkManager, + timestamp, math.MaxUint64, ) } @@ -303,6 +294,7 @@ func buildBlock( builder.txExecutorBackend, builder.blkManager, timestamp, + 0, // minCapacity is 0 as we want to honor the capacity in state. ) } else { blockTxs, err = packDurangoBlockTxs( @@ -420,6 +412,7 @@ func packEtnaBlockTxs( backend *txexecutor.Backend, manager blockexecutor.Manager, timestamp time.Time, + minCapacity gas.Gas, ) ([]*txs.Tx, error) { stateDiff, err := state.NewDiffOn(parentState) if err != nil { @@ -431,17 +424,8 @@ func packEtnaBlockTxs( } feeState := stateDiff.GetFeeState() - return packEtnaBlockTxsOn(parentID, stateDiff, mempool, backend, manager, feeState.Capacity) -} + capacity := max(feeState.Capacity, minCapacity) -func packEtnaBlockTxsOn( - parentID ids.ID, - stateDiff state.Diff, - mempool mempool.Mempool, - backend *txexecutor.Backend, - manager blockexecutor.Manager, - capacity gas.Gas, -) ([]*txs.Tx, error) { var ( blockTxs []*txs.Tx inputs set.Set[ids.ID] From 7e880a4290430360def79a16edb10e6dcd1ef86f Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 28 Aug 2024 12:55:58 -0400 Subject: [PATCH 112/114] reduce diff --- vms/platformvm/block/executor/verifier.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index 29d361efbd4d..2256e3e1da1a 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -455,12 +455,7 @@ func (v *verifier) standardBlock( return nil } -func (v *verifier) processStandardTxs( - txs []*txs.Tx, - feeCalculator fee.Calculator, - state state.Diff, - parentID ids.ID, -) ( +func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculator, state state.Diff, parentID ids.ID) ( set.Set[ids.ID], map[ids.ID]*atomic.Requests, func(), From e7d651e215ab9cb13080542551709b208115ad6c Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 28 Aug 2024 12:56:57 -0400 Subject: [PATCH 113/114] Remove bad comment --- vms/platformvm/block/executor/verifier.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index 2256e3e1da1a..532dc4d4b6f6 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -468,7 +468,7 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato txComplexity, err := fee.TxComplexity(tx.Unsigned) if err != nil { txID := tx.ID() - v.MarkDropped(txID, err) // cache tx as dropped + v.MarkDropped(txID, err) return nil, nil, nil, err } From 9a4bd4c4f8adcc3be3fb43fc6f394f403b7ea95d Mon Sep 17 00:00:00 2001 From: Stephen Buttolph Date: Wed, 28 Aug 2024 16:24:09 -0400 Subject: [PATCH 114/114] Use global configs rather than custom configs --- .../state/chain_time_helpers_test.go | 24 ++++--------------- 1 file changed, 4 insertions(+), 20 deletions(-) diff --git a/vms/platformvm/state/chain_time_helpers_test.go b/vms/platformvm/state/chain_time_helpers_test.go index 1101b27f4639..3a6304aaeea5 100644 --- a/vms/platformvm/state/chain_time_helpers_test.go +++ b/vms/platformvm/state/chain_time_helpers_test.go @@ -9,33 +9,17 @@ import ( "github.com/stretchr/testify/require" "github.com/ava-labs/avalanchego/database/memdb" + "github.com/ava-labs/avalanchego/genesis" "github.com/ava-labs/avalanchego/upgrade/upgradetest" - "github.com/ava-labs/avalanchego/vms/components/gas" "github.com/ava-labs/avalanchego/vms/platformvm/config" "github.com/ava-labs/avalanchego/vms/platformvm/txs/fee" ) func TestPickFeeCalculator(t *testing.T) { var ( - createAssetTxFee uint64 = 9 - staticFeeConfig = fee.StaticConfig{ - TxFee: 1, - CreateSubnetTxFee: 2, - TransformSubnetTxFee: 3, - CreateBlockchainTxFee: 4, - AddPrimaryNetworkValidatorFee: 5, - AddPrimaryNetworkDelegatorFee: 6, - AddSubnetValidatorFee: 7, - AddSubnetDelegatorFee: 8, - } - dynamicFeeConfig = gas.Config{ - Weights: gas.Dimensions{1}, - MaxCapacity: 2, - MaxPerSecond: 3, - TargetPerSecond: 4, - MinPrice: 5, - ExcessConversionConstant: 6, - } + createAssetTxFee = genesis.LocalParams.CreateAssetTxFee + staticFeeConfig = genesis.LocalParams.StaticFeeConfig + dynamicFeeConfig = genesis.LocalParams.DynamicFeeConfig ) apricotPhase2StaticFeeConfig := staticFeeConfig