github.com/ava-labs/avalanchego@v1.11.11/vms/platformvm/genesis/genesistest/genesis.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package genesistest
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/ava-labs/avalanchego/ids"
    13  	"github.com/ava-labs/avalanchego/snow/snowtest"
    14  	"github.com/ava-labs/avalanchego/upgrade"
    15  	"github.com/ava-labs/avalanchego/utils/constants"
    16  	"github.com/ava-labs/avalanchego/utils/crypto/secp256k1"
    17  	"github.com/ava-labs/avalanchego/utils/units"
    18  	"github.com/ava-labs/avalanchego/vms/components/avax"
    19  	"github.com/ava-labs/avalanchego/vms/platformvm/reward"
    20  	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
    21  	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
    22  
    23  	platformvmgenesis "github.com/ava-labs/avalanchego/vms/platformvm/genesis"
    24  )
    25  
    26  const (
    27  	DefaultValidatorDuration = 28 * 24 * time.Hour
    28  	DefaultValidatorWeight   = 5 * units.MilliAvax
    29  	DefaultInitialBalance    = 1 * units.Avax
    30  
    31  	ValidatorDelegationShares = reward.PercentDenominator
    32  	XChainName                = "x"
    33  	InitialSupply             = 360 * units.MegaAvax
    34  )
    35  
    36  var (
    37  	AVAXAsset = avax.Asset{ID: snowtest.AVAXAssetID}
    38  
    39  	DefaultValidatorStartTime     = upgrade.InitiallyActiveTime
    40  	DefaultValidatorStartTimeUnix = uint64(DefaultValidatorStartTime.Unix())
    41  	DefaultValidatorEndTime       = DefaultValidatorStartTime.Add(DefaultValidatorDuration)
    42  	DefaultValidatorEndTimeUnix   = uint64(DefaultValidatorEndTime.Unix())
    43  )
    44  
    45  var (
    46  	// Keys that are funded in the genesis
    47  	DefaultFundedKeys = secp256k1.TestKeys()
    48  
    49  	// Node IDs of genesis validators
    50  	DefaultNodeIDs []ids.NodeID
    51  )
    52  
    53  func init() {
    54  	DefaultNodeIDs = make([]ids.NodeID, len(DefaultFundedKeys))
    55  	for i := range DefaultFundedKeys {
    56  		DefaultNodeIDs[i] = ids.GenerateTestNodeID()
    57  	}
    58  }
    59  
    60  type Config struct {
    61  	NodeIDs            []ids.NodeID
    62  	ValidatorWeight    uint64
    63  	ValidatorStartTime time.Time
    64  	ValidatorEndTime   time.Time
    65  
    66  	FundedKeys     []*secp256k1.PrivateKey
    67  	InitialBalance uint64
    68  }
    69  
    70  func New(t testing.TB, c Config) *platformvmgenesis.Genesis {
    71  	if len(c.NodeIDs) == 0 {
    72  		c.NodeIDs = DefaultNodeIDs
    73  	}
    74  	if c.ValidatorWeight == 0 {
    75  		c.ValidatorWeight = DefaultValidatorWeight
    76  	}
    77  	if c.ValidatorStartTime.IsZero() {
    78  		c.ValidatorStartTime = DefaultValidatorStartTime
    79  	}
    80  	if c.ValidatorEndTime.IsZero() {
    81  		c.ValidatorEndTime = DefaultValidatorEndTime
    82  	}
    83  	if len(c.FundedKeys) == 0 {
    84  		c.FundedKeys = DefaultFundedKeys
    85  	}
    86  	if c.InitialBalance == 0 {
    87  		c.InitialBalance = DefaultInitialBalance
    88  	}
    89  
    90  	require := require.New(t)
    91  
    92  	genesis := &platformvmgenesis.Genesis{
    93  		UTXOs:         make([]*platformvmgenesis.UTXO, len(c.FundedKeys)),
    94  		Validators:    make([]*txs.Tx, len(c.NodeIDs)),
    95  		Timestamp:     uint64(c.ValidatorStartTime.Unix()),
    96  		InitialSupply: InitialSupply,
    97  	}
    98  	for i, key := range c.FundedKeys {
    99  		genesis.UTXOs[i] = &platformvmgenesis.UTXO{UTXO: avax.UTXO{
   100  			UTXOID: avax.UTXOID{
   101  				TxID:        snowtest.AVAXAssetID,
   102  				OutputIndex: uint32(i),
   103  			},
   104  			Asset: AVAXAsset,
   105  			Out: &secp256k1fx.TransferOutput{
   106  				Amt: c.InitialBalance,
   107  				OutputOwners: secp256k1fx.OutputOwners{
   108  					Threshold: 1,
   109  					Addrs: []ids.ShortID{
   110  						key.Address(),
   111  					},
   112  				},
   113  			},
   114  		}}
   115  	}
   116  	for i, nodeID := range c.NodeIDs {
   117  		key := c.FundedKeys[i%len(c.FundedKeys)]
   118  		owner := secp256k1fx.OutputOwners{
   119  			Threshold: 1,
   120  			Addrs: []ids.ShortID{
   121  				key.Address(),
   122  			},
   123  		}
   124  		validator := &txs.AddValidatorTx{
   125  			BaseTx: txs.BaseTx{BaseTx: avax.BaseTx{
   126  				NetworkID:    constants.UnitTestID,
   127  				BlockchainID: constants.PlatformChainID,
   128  			}},
   129  			Validator: txs.Validator{
   130  				NodeID: nodeID,
   131  				Start:  uint64(c.ValidatorStartTime.Unix()),
   132  				End:    uint64(c.ValidatorEndTime.Unix()),
   133  				Wght:   c.ValidatorWeight,
   134  			},
   135  			StakeOuts: []*avax.TransferableOutput{
   136  				{
   137  					Asset: AVAXAsset,
   138  					Out: &secp256k1fx.TransferOutput{
   139  						Amt:          c.ValidatorWeight,
   140  						OutputOwners: owner,
   141  					},
   142  				},
   143  			},
   144  			RewardsOwner:     &owner,
   145  			DelegationShares: ValidatorDelegationShares,
   146  		}
   147  		validatorTx := &txs.Tx{Unsigned: validator}
   148  		require.NoError(validatorTx.Initialize(txs.GenesisCodec))
   149  
   150  		genesis.Validators[i] = validatorTx
   151  	}
   152  
   153  	chain := &txs.CreateChainTx{
   154  		BaseTx: txs.BaseTx{BaseTx: avax.BaseTx{
   155  			NetworkID:    constants.UnitTestID,
   156  			BlockchainID: constants.PlatformChainID,
   157  		}},
   158  		SubnetID:   constants.PrimaryNetworkID,
   159  		ChainName:  XChainName,
   160  		VMID:       constants.AVMID,
   161  		SubnetAuth: &secp256k1fx.Input{},
   162  	}
   163  	chainTx := &txs.Tx{Unsigned: chain}
   164  	require.NoError(chainTx.Initialize(txs.GenesisCodec))
   165  
   166  	genesis.Chains = []*txs.Tx{chainTx}
   167  	return genesis
   168  }
   169  
   170  func NewBytes(t testing.TB, c Config) []byte {
   171  	g := New(t, c)
   172  	genesisBytes, err := platformvmgenesis.Codec.Marshal(platformvmgenesis.CodecVersion, g)
   173  	require.NoError(t, err)
   174  	return genesisBytes
   175  }