diff --git a/cmd/blockchaincmd/add_validator.go b/cmd/blockchaincmd/add_validator.go index 1c3bc322b..fdf59f4c3 100644 --- a/cmd/blockchaincmd/add_validator.go +++ b/cmd/blockchaincmd/add_validator.go @@ -25,7 +25,6 @@ import ( "github.com/ava-labs/avalanche-cli/pkg/utils" "github.com/ava-labs/avalanche-cli/pkg/ux" "github.com/ava-labs/avalanche-cli/pkg/validatormanager" - blockchainSDK "github.com/ava-labs/avalanche-tooling-sdk-go/blockchain" "github.com/ava-labs/avalanche-tooling-sdk-go/evm" sdkutils "github.com/ava-labs/avalanche-tooling-sdk-go/utils" validatormanagersdk "github.com/ava-labs/avalanche-tooling-sdk-go/validatormanager" @@ -632,9 +631,26 @@ func CallAddValidator( } } } - pChainHeight, err := blockchainSDK.GetPChainHeight(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + + epochDuration := 30 * time.Second + + // Get P-Chain's current epoch for RegisterL1ValidatorMessage (signed by L1, verified by P-Chain) + pChainEpoch, err := utils.GetCurrentEpoch(network.Endpoint, "P") + if err != nil { + return fmt.Errorf("failure getting p-chain current epoch: %w", err) + } + epochTime := time.Unix(pChainEpoch.StartTime, 0) + elapsed := time.Since(epochTime) + if elapsed < epochDuration { + time.Sleep(epochDuration - elapsed) + } + _, _, err = deployer.PChainTransfer(kc.Addresses().List()[0], 1) + if err != nil { + return fmt.Errorf("could not sent dummy transfer on p-chain: %w", err) + } + pChainEpoch, err = utils.GetCurrentEpoch(network.Endpoint, "P") if err != nil { - return fmt.Errorf("failure getting p-chain height: %w", err) + return fmt.Errorf("failure getting p-chain current epoch: %w", err) } ctx, cancel := sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) @@ -666,7 +682,7 @@ func CallAddValidator( sc.UseACP99, initiateTxHash, signatureAggregatorEndpoint, - pChainHeight, + pChainEpoch.PChainHeight, ) if err != nil { return err @@ -695,6 +711,18 @@ func CallAddValidator( } } + client, err := evm.GetClient(validatorManagerRPCEndpoint) + if err != nil { + return fmt.Errorf("failure connecting to validator manager L1: %w", err) + } + if err := client.SetupProposerVM(signer); err != nil { + return fmt.Errorf("failure setting proposer VM on L1: %w", err) + } + l1Epoch, err := utils.GetCurrentL1Epoch(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + if err != nil { + return fmt.Errorf("failure getting l1 current epoch: %w", err) + } + ctx, cancel = sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) defer cancel() rawTx, err = validatormanager.FinishValidatorRegistration( @@ -711,7 +739,7 @@ func CallAddValidator( validatorManagerBlockchainID, validatorManagerAddress, signatureAggregatorEndpoint, - pChainHeight, + l1Epoch.PChainHeight, ) if err != nil { return err diff --git a/cmd/blockchaincmd/change_weight.go b/cmd/blockchaincmd/change_weight.go index 64e538764..796d8ee8a 100644 --- a/cmd/blockchaincmd/change_weight.go +++ b/cmd/blockchaincmd/change_weight.go @@ -6,8 +6,6 @@ import ( "fmt" "strings" - blockchainSDK "github.com/ava-labs/avalanche-tooling-sdk-go/blockchain" - "github.com/ava-labs/avalanche-cli/cmd/flags" "github.com/ava-labs/avalanche-cli/pkg/blockchain" "github.com/ava-labs/avalanche-cli/pkg/cobrautils" @@ -420,9 +418,10 @@ func changeWeightACP99( } } } - pChainHeight, err := blockchainSDK.GetPChainHeight(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + // Get P-Chain's current epoch for SetL1ValidatorWeightMessage (signed by L1, verified by P-Chain) + pChainEpoch, err := utils.GetCurrentEpoch(network.Endpoint, "P") if err != nil { - return fmt.Errorf("failure getting p-chain height: %w", err) + return fmt.Errorf("failure getting p-chain current epoch: %w", err) } ctx, cancel := sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) defer cancel() @@ -441,7 +440,7 @@ func changeWeightACP99( weight, initiateTxHash, signatureAggregatorEndpoint, - pChainHeight, + pChainEpoch.PChainHeight, ) if err != nil { return err @@ -482,6 +481,12 @@ func changeWeightACP99( } } } + // Get L1's current epoch for L1ValidatorWeightMessage (signed by P-Chain, verified by L1) + l1Epoch, err := utils.GetCurrentL1Epoch(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + if err != nil { + return fmt.Errorf("failure getting l1 current epoch: %w", err) + } + ctx, cancel = sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) defer cancel() rawTx, err = validatormanager.FinishValidatorWeightChange( @@ -499,7 +504,7 @@ func changeWeightACP99( signedMessage, newWeight, signatureAggregatorEndpoint, - pChainHeight, + l1Epoch.PChainHeight, ) if err != nil { return err diff --git a/cmd/blockchaincmd/create.go b/cmd/blockchaincmd/create.go index 5320518bb..0f85170a9 100644 --- a/cmd/blockchaincmd/create.go +++ b/cmd/blockchaincmd/create.go @@ -70,7 +70,6 @@ var createNetworkOptions = []networkoptions.NetworkOption{ networkoptions.Local, networkoptions.Fuji, networkoptions.Mainnet, - networkoptions.Granite, } var ( @@ -305,7 +304,6 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error { if err != nil { return err } - fmt.Printf("using network %s \n", network.Name()) if vmType == models.SubnetEvm { if sovereign { diff --git a/cmd/blockchaincmd/deploy.go b/cmd/blockchaincmd/deploy.go index cf2b02b16..09623766e 100644 --- a/cmd/blockchaincmd/deploy.go +++ b/cmd/blockchaincmd/deploy.go @@ -284,7 +284,6 @@ func getChainsInSubnet(blockchainName string) ([]string, error) { func checkSubnetEVMDefaultAddressNotInAlloc(network models.Network, chain string) error { if network.Kind != models.Local && network.Kind != models.Devnet && - network.Kind != models.Granite && !simulatedPublicNetwork() { genesis, err := app.LoadEvmGenesis(chain) if err != nil { @@ -1177,13 +1176,11 @@ func deployBlockchain(cmd *cobra.Command, args []string) error { deployRelayerFlags.CChainFundingKey = "ewoq" deployRelayerFlags.CChainAmount = constants.DefaultRelayerAmount } - if network.Kind != models.Granite { - if err := relayercmd.CallDeploy(nil, deployRelayerFlags, network); err != nil { - relayerErr = err - ux.Logger.RedXToUser("Relayer is not deployed due to: %v", relayerErr) - } else { - ux.Logger.GreenCheckmarkToUser("Relayer is successfully deployed") - } + if err := relayercmd.CallDeploy(nil, deployRelayerFlags, network); err != nil { + relayerErr = err + ux.Logger.RedXToUser("Relayer is not deployed due to: %v", relayerErr) + } else { + ux.Logger.GreenCheckmarkToUser("Relayer is successfully deployed") } } } diff --git a/cmd/blockchaincmd/describe.go b/cmd/blockchaincmd/describe.go index 670bef910..9ca692f1e 100644 --- a/cmd/blockchaincmd/describe.go +++ b/cmd/blockchaincmd/describe.go @@ -399,42 +399,46 @@ func printPrecompiles(genesis core.Genesis) { warpSet := false allowListSet := false - // Warp - extra := params.GetExtra(genesis.Config) - if extra.GenesisPrecompiles[warp.ConfigKey] != nil { - t.AppendRow(table.Row{"Warp", "n/a", "n/a", "n/a"}) - warpSet = true - } - // Native Minting - if extra.GenesisPrecompiles[nativeminter.ConfigKey] != nil { - cfg := extra.GenesisPrecompiles[nativeminter.ConfigKey].(*nativeminter.Config) - addPrecompileAllowListToTable(t, "Native Minter", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) - allowListSet = true - } - // Contract allow list - if extra.GenesisPrecompiles[deployerallowlist.ConfigKey] != nil { - cfg := extra.GenesisPrecompiles[deployerallowlist.ConfigKey].(*deployerallowlist.Config) - addPrecompileAllowListToTable(t, "Contract Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) - allowListSet = true - } - // TX allow list - if extra.GenesisPrecompiles[txallowlist.ConfigKey] != nil { - cfg := extra.GenesisPrecompiles[txallowlist.Module.ConfigKey].(*txallowlist.Config) - addPrecompileAllowListToTable(t, "Tx Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) - allowListSet = true - } - // Fee config allow list - if extra.GenesisPrecompiles[feemanager.ConfigKey] != nil { - cfg := extra.GenesisPrecompiles[feemanager.ConfigKey].(*feemanager.Config) - addPrecompileAllowListToTable(t, "Fee Config Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) - allowListSet = true - } - // Reward config allow list - if extra.GenesisPrecompiles[rewardmanager.ConfigKey] != nil { - cfg := extra.GenesisPrecompiles[rewardmanager.ConfigKey].(*rewardmanager.Config) - addPrecompileAllowListToTable(t, "Reward Manager Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) - allowListSet = true - } + + params.WithTempRegisteredExtras(func() { + extra := params.GetExtra(genesis.Config) + // Warp + if extra.GenesisPrecompiles[warp.ConfigKey] != nil { + t.AppendRow(table.Row{"Warp", "n/a", "n/a", "n/a"}) + warpSet = true + } + // Native Minting + if extra.GenesisPrecompiles[nativeminter.ConfigKey] != nil { + cfg := extra.GenesisPrecompiles[nativeminter.ConfigKey].(*nativeminter.Config) + addPrecompileAllowListToTable(t, "Native Minter", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) + allowListSet = true + } + // Contract allow list + if extra.GenesisPrecompiles[deployerallowlist.ConfigKey] != nil { + cfg := extra.GenesisPrecompiles[deployerallowlist.ConfigKey].(*deployerallowlist.Config) + addPrecompileAllowListToTable(t, "Contract Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) + allowListSet = true + } + // TX allow list + if extra.GenesisPrecompiles[txallowlist.ConfigKey] != nil { + cfg := extra.GenesisPrecompiles[txallowlist.Module.ConfigKey].(*txallowlist.Config) + addPrecompileAllowListToTable(t, "Tx Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) + allowListSet = true + } + // Fee config allow list + if extra.GenesisPrecompiles[feemanager.ConfigKey] != nil { + cfg := extra.GenesisPrecompiles[feemanager.ConfigKey].(*feemanager.Config) + addPrecompileAllowListToTable(t, "Fee Config Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) + allowListSet = true + } + // Reward config allow list + if extra.GenesisPrecompiles[rewardmanager.ConfigKey] != nil { + cfg := extra.GenesisPrecompiles[rewardmanager.ConfigKey].(*rewardmanager.Config) + addPrecompileAllowListToTable(t, "Reward Manager Allow List", cfg.AdminAddresses, cfg.ManagerAddresses, cfg.EnabledAddresses) + allowListSet = true + } + }) + if warpSet || allowListSet { ux.Logger.PrintToUser("%s", t.Render()) if allowListSet { diff --git a/cmd/blockchaincmd/export_test.go b/cmd/blockchaincmd/export_test.go deleted file mode 100644 index f243a061b..000000000 --- a/cmd/blockchaincmd/export_test.go +++ /dev/null @@ -1,100 +0,0 @@ -// Copyright (C) 2025, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. -package blockchaincmd - -import ( - "encoding/json" - "io" - "os" - "path/filepath" - "testing" - - "github.com/ava-labs/avalanche-cli/internal/mocks" - "github.com/ava-labs/avalanche-cli/pkg/application" - "github.com/ava-labs/avalanche-cli/pkg/constants" - "github.com/ava-labs/avalanche-cli/pkg/prompts" - "github.com/ava-labs/avalanche-cli/pkg/ux" - "github.com/ava-labs/avalanche-cli/pkg/vm" - "github.com/ava-labs/avalanchego/utils/logging" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestExportImportSubnet(t *testing.T) { - testDir := t.TempDir() - require := require.New(t) - testSubnet := "testSubnet" - vmVersion := "v0.9.99" - testSubnetEVMCompat := []byte("{\"rpcChainVMProtocolVersion\": {\"v0.9.99\": 18}}") - - app = application.New() - - mockAppDownloader := mocks.Downloader{} - mockAppDownloader.On("Download", mock.Anything).Return(testSubnetEVMCompat, nil) - - app.Setup(testDir, logging.NoLog{}, nil, "", prompts.NewPrompter(), &mockAppDownloader, nil) - ux.NewUserLog(logging.NoLog{}, io.Discard) - - subnetEvmGenesisPath := "tests/e2e/assets/test_subnet_evm_genesis.json" - genBytes, err := os.ReadFile("../../" + subnetEvmGenesisPath) - require.NoError(err) - sc, err := vm.CreateEvmSidecar( - nil, - app, - testSubnet, - vmVersion, - "Test", - false, - true, - true, - ) - require.NoError(err) - err = app.WriteGenesisFile(testSubnet, genBytes) - require.NoError(err) - err = app.CreateSidecar(sc) - require.NoError(err) - - exportOutputDir := filepath.Join(testDir, "output") - err = os.MkdirAll(exportOutputDir, constants.DefaultPerms755) - require.NoError(err) - exportOutput = filepath.Join(exportOutputDir, testSubnet) - defer func() { - exportOutput = "" - app = nil - }() - globalNetworkFlags.UseLocal = true - err = exportSubnet(nil, []string{"this-does-not-exist-should-fail"}) - require.Error(err) - - err = exportSubnet(nil, []string{testSubnet}) - require.NoError(err) - require.FileExists(exportOutput) - sidecarFile := filepath.Join(app.GetBaseDir(), constants.SubnetDir, testSubnet, constants.SidecarFileName) - orig, err := os.ReadFile(sidecarFile) - require.NoError(err) - - var control map[string]interface{} - err = json.Unmarshal(orig, &control) - require.NoError(err) - require.Equal(control["Name"], testSubnet) - require.Equal(control["VM"], "Subnet-EVM") - require.Equal(control["VMVersion"], vmVersion) - require.Equal(control["Subnet"], testSubnet) - require.Equal(control["TokenName"], "Test Token") - require.Equal(control["TokenSymbol"], "Test") - require.Equal(control["Version"], constants.SidecarVersion) - require.Equal(control["Networks"], nil) - - err = os.Remove(sidecarFile) - require.NoError(err) - - err = importFile(nil, []string{"this-does-also-not-exist-import-should-fail"}) - require.ErrorIs(err, os.ErrNotExist) - err = importFile(nil, []string{exportOutput}) - require.ErrorContains(err, "blockchain already exists") - genFile := filepath.Join(app.GetBaseDir(), constants.SubnetDir, testSubnet, constants.GenesisFileName) - err = os.Remove(genFile) - require.NoError(err) - err = importFile(nil, []string{exportOutput}) - require.NoError(err) -} diff --git a/cmd/blockchaincmd/helpers.go b/cmd/blockchaincmd/helpers.go index 69602fa24..7a868be03 100644 --- a/cmd/blockchaincmd/helpers.go +++ b/cmd/blockchaincmd/helpers.go @@ -190,9 +190,6 @@ func StartLocalMachine( bootstrapValidatorFlags.NumBootstrapValidators = constants.DefaultNumberOfLocalMachineNodes } connectionSettings := localnet.ConnectionSettings{} - if network.Kind == models.Granite { - connectionSettings = node.GetGraniteConnectionSettings() - } // if no cluster provided - we create one with fmt.Sprintf("%s-local-node-%s", blockchainName, networkNameComponent) name if localMachineFlags.UseLocalMachine && clusterNameFlagValue == "" { if localnet.LocalClusterExists(app, clusterName) { diff --git a/cmd/blockchaincmd/join.go b/cmd/blockchaincmd/join.go index adf63e4ec..859bef0d6 100644 --- a/cmd/blockchaincmd/join.go +++ b/cmd/blockchaincmd/join.go @@ -15,10 +15,8 @@ import ( "github.com/ava-labs/avalanche-cli/pkg/plugins" "github.com/ava-labs/avalanche-cli/pkg/utils" "github.com/ava-labs/avalanche-cli/pkg/ux" - sdkutils "github.com/ava-labs/avalanche-tooling-sdk-go/utils" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/utils/logging" - "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/spf13/cobra" ) @@ -323,25 +321,6 @@ func writeAvagoChainConfigFiles( return nil } -func checkIsValidating(subnetID ids.ID, nodeID ids.NodeID, pClient platformvm.Client) (bool, error) { - // first check if the node is already an accepted validator on the subnet - nodeIDs := []ids.NodeID{nodeID} - ctx, cancel := sdkutils.GetAPIContext() - defer cancel() - vals, err := pClient.GetCurrentValidators(ctx, subnetID, nodeIDs) - if err != nil { - return false, err - } - for _, v := range vals { - // strictly this is not needed, as we are providing the nodeID as param - // just a double check - if v.NodeID == nodeID { - return true, nil - } - } - return false, nil -} - func printJoinCmd(subnetID string, network models.Network, vmPath string) { msg := ` To setup your node, you must do two things: diff --git a/cmd/blockchaincmd/join_test.go b/cmd/blockchaincmd/join_test.go deleted file mode 100644 index ab7378e8f..000000000 --- a/cmd/blockchaincmd/join_test.go +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright (C) 2025, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. -package blockchaincmd - -import ( - "testing" - - "github.com/ava-labs/avalanche-cli/internal/mocks" - "github.com/ava-labs/avalanchego/ids" - "github.com/ava-labs/avalanchego/vms/platformvm" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestIsNodeValidatingSubnet(t *testing.T) { - require := require.New(t) - nodeID := ids.GenerateTestNodeID() - nonValidator := ids.GenerateTestNodeID() - subnetID := ids.GenerateTestID() - - pClient := &mocks.PClient{} - pClient.On("GetCurrentValidators", mock.Anything, mock.Anything, mock.Anything).Return( - []platformvm.ClientPermissionlessValidator{ - { - ClientStaker: platformvm.ClientStaker{ - NodeID: nodeID, - }, - }, - }, nil) - - // first pass: should return true for the GetCurrentValidators - isValidating, err := checkIsValidating(subnetID, nodeID, pClient) - require.NoError(err) - require.True(isValidating) - - // second pass: The nonValidator is not in current nor pending validators, hence false - isValidating, err = checkIsValidating(subnetID, nonValidator, pClient) - require.NoError(err) - require.False(isValidating) -} diff --git a/cmd/blockchaincmd/remove_validator.go b/cmd/blockchaincmd/remove_validator.go index 8a584f1e8..6d564a34c 100644 --- a/cmd/blockchaincmd/remove_validator.go +++ b/cmd/blockchaincmd/remove_validator.go @@ -7,8 +7,7 @@ import ( "fmt" "os" "strings" - - blockchainSDK "github.com/ava-labs/avalanche-tooling-sdk-go/blockchain" + "time" "github.com/ava-labs/avalanche-cli/cmd/flags" "github.com/ava-labs/avalanche-cli/pkg/blockchain" @@ -400,9 +399,10 @@ func removeValidatorSOV( } } } - pChainHeight, err := blockchainSDK.GetPChainHeight(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + // Get P-Chain's current epoch for SetL1ValidatorWeightMessage (signed by L1, verified by P-Chain) + pChainEpoch, err := utils.GetCurrentEpoch(network.Endpoint, "P") if err != nil { - return fmt.Errorf("failure getting p-chain height: %w", err) + return fmt.Errorf("failure getting p-chain current epoch: %w", err) } ctx, cancel := sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) defer cancel() @@ -427,7 +427,7 @@ func removeValidatorSOV( sc.UseACP99, initiateTxHash, signatureAggregatorEndpoint, - pChainHeight, + pChainEpoch.PChainHeight, ) if err != nil && errors.Is(err, validatormanagersdk.ErrValidatorIneligibleForRewards) { ux.Logger.PrintToUser("Calculated rewards is zero. Validator %s is not eligible for rewards", nodeID) @@ -460,7 +460,7 @@ func removeValidatorSOV( sc.UseACP99, initiateTxHash, signatureAggregatorEndpoint, - pChainHeight, + pChainEpoch.PChainHeight, ) if err != nil { return err @@ -491,6 +491,31 @@ func removeValidatorSOV( return err } } + + epochDuration := 30 * time.Second + + // Get L1's current epoch for L1ValidatorRegistrationMessage (signed by P-Chain, verified by L1) + l1Epoch, err := utils.GetCurrentL1Epoch(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + if err != nil { + return fmt.Errorf("failure getting l1 current epoch: %w", err) + } + epochTime := time.Unix(l1Epoch.StartTime, 0) + elapsed := time.Since(epochTime) + if elapsed < epochDuration { + time.Sleep(epochDuration - elapsed) + } + client, err := evm.GetClient(validatorManagerRPCEndpoint) + if err != nil { + return fmt.Errorf("failure connecting to validator manager L1: %w", err) + } + if err := client.SetupProposerVM(signer); err != nil { + return fmt.Errorf("failure setting proposer VM on L1: %w", err) + } + l1Epoch, err = utils.GetCurrentL1Epoch(validatorManagerRPCEndpoint, validatorManagerBlockchainID.String()) + if err != nil { + return fmt.Errorf("failure getting l1 current epoch: %w", err) + } + ctx, cancel = sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) defer cancel() rawTx, err = validatormanager.FinishValidatorRemoval( @@ -508,7 +533,7 @@ func removeValidatorSOV( validatorManagerAddress, sc.UseACP99, signatureAggregatorEndpoint, - pChainHeight, + l1Epoch.PChainHeight, ) if err != nil { return err diff --git a/cmd/blockchaincmd/upgradecmd/generate.go b/cmd/blockchaincmd/upgradecmd/generate.go index 50ee1c5ff..b14f8fc60 100644 --- a/cmd/blockchaincmd/upgradecmd/generate.go +++ b/cmd/blockchaincmd/upgradecmd/generate.go @@ -390,7 +390,9 @@ func promptFeeManagerParams( if err != nil { return false, err } - feeConfig = ¶ms.GetExtra(&chainConfig).FeeConfig + params.WithTempRegisteredExtras(func() { + feeConfig = ¶ms.GetExtra(&chainConfig).FeeConfig + }) } config := feemanager.NewConfig( subnetevmutils.NewUint64(uint64(date.Unix())), @@ -426,102 +428,106 @@ func GetFeeConfig(config params.ChainConfig, useDefault bool) ( setGasStep = "Set block gas cost step" ) - extra := params.GetExtra(&config) + var err error + params.WithTempRegisteredExtras(func() { + extra := params.GetExtra(&config) - extra.FeeConfig = avalancheSDK.StarterFeeConfig + extra.FeeConfig = avalancheSDK.StarterFeeConfig - if useDefault { - extra.FeeConfig.GasLimit = vm.LowGasLimit - extra.FeeConfig.TargetGas = extra.FeeConfig.TargetGas.Mul(extra.FeeConfig.GasLimit, vm.NoDynamicFeesGasLimitToTargetGasFactor) - return config, nil - } - - feeConfigOptions := []string{lowOption, mediumOption, highOption, customFee} + if useDefault { + extra.FeeConfig.GasLimit = vm.LowGasLimit + extra.FeeConfig.TargetGas = extra.FeeConfig.TargetGas.Mul(extra.FeeConfig.GasLimit, vm.NoDynamicFeesGasLimitToTargetGasFactor) + return + } - feeDefault, err := app.Prompt.CaptureList( - "How would you like to set fees", - feeConfigOptions, - ) - if err != nil { - return config, err - } + feeConfigOptions := []string{lowOption, mediumOption, highOption, customFee} - useDynamicFees := false - if feeDefault != customFee { - useDynamicFees, err = app.Prompt.CaptureYesNo("Do you want to enable dynamic fees?") + var feeDefault string + feeDefault, err = app.Prompt.CaptureList( + "How would you like to set fees", + feeConfigOptions, + ) if err != nil { - return config, err + return } - } - switch feeDefault { - case lowOption: - vm.SetStandardGas(&extra.FeeConfig, vm.LowGasLimit, vm.LowTargetGas, useDynamicFees) - return config, nil - case mediumOption: - vm.SetStandardGas(&extra.FeeConfig, vm.MediumGasLimit, vm.MediumTargetGas, useDynamicFees) - return config, err - case highOption: - vm.SetStandardGas(&extra.FeeConfig, vm.HighGasLimit, vm.HighTargetGas, useDynamicFees) - return config, err - default: - ux.Logger.PrintToUser("Customizing fee config") - } + useDynamicFees := false + if feeDefault != customFee { + useDynamicFees, err = app.Prompt.CaptureYesNo("Do you want to enable dynamic fees?") + if err != nil { + return + } + } - gasLimit, err := app.Prompt.CapturePositiveBigInt(setGasLimit) - if err != nil { - return config, err - } + switch feeDefault { + case lowOption: + vm.SetStandardGas(&extra.FeeConfig, vm.LowGasLimit, vm.LowTargetGas, useDynamicFees) + return + case mediumOption: + vm.SetStandardGas(&extra.FeeConfig, vm.MediumGasLimit, vm.MediumTargetGas, useDynamicFees) + return + case highOption: + vm.SetStandardGas(&extra.FeeConfig, vm.HighGasLimit, vm.HighTargetGas, useDynamicFees) + return + default: + ux.Logger.PrintToUser("Customizing fee config") + } - blockRate, err := app.Prompt.CapturePositiveBigInt(setBlockRate) - if err != nil { - return config, err - } + gasLimit, err := app.Prompt.CapturePositiveBigInt(setGasLimit) + if err != nil { + return + } - minBaseFee, err := app.Prompt.CapturePositiveBigInt(setMinBaseFee) - if err != nil { - return config, err - } + blockRate, err := app.Prompt.CapturePositiveBigInt(setBlockRate) + if err != nil { + return + } - targetGas, err := app.Prompt.CapturePositiveBigInt(setTargetGas) - if err != nil { - return config, err - } + minBaseFee, err := app.Prompt.CapturePositiveBigInt(setMinBaseFee) + if err != nil { + return + } - baseDenominator, err := app.Prompt.CapturePositiveBigInt(setBaseFeeChangeDenominator) - if err != nil { - return config, err - } + targetGas, err := app.Prompt.CapturePositiveBigInt(setTargetGas) + if err != nil { + return + } - minBlockGas, err := app.Prompt.CapturePositiveBigInt(setMinBlockGas) - if err != nil { - return config, err - } + baseDenominator, err := app.Prompt.CapturePositiveBigInt(setBaseFeeChangeDenominator) + if err != nil { + return + } - maxBlockGas, err := app.Prompt.CapturePositiveBigInt(setMaxBlockGas) - if err != nil { - return config, err - } + minBlockGas, err := app.Prompt.CapturePositiveBigInt(setMinBlockGas) + if err != nil { + return + } - gasStep, err := app.Prompt.CapturePositiveBigInt(setGasStep) - if err != nil { - return config, err - } + maxBlockGas, err := app.Prompt.CapturePositiveBigInt(setMaxBlockGas) + if err != nil { + return + } - feeConf := commontype.FeeConfig{ - GasLimit: gasLimit, - TargetBlockRate: blockRate.Uint64(), - MinBaseFee: minBaseFee, - TargetGas: targetGas, - BaseFeeChangeDenominator: baseDenominator, - MinBlockGasCost: minBlockGas, - MaxBlockGasCost: maxBlockGas, - BlockGasCostStep: gasStep, - } + gasStep, err := app.Prompt.CapturePositiveBigInt(setGasStep) + if err != nil { + return + } - extra.FeeConfig = feeConf + feeConf := commontype.FeeConfig{ + GasLimit: gasLimit, + TargetBlockRate: blockRate.Uint64(), + MinBaseFee: minBaseFee, + TargetGas: targetGas, + BaseFeeChangeDenominator: baseDenominator, + MinBlockGasCost: minBlockGas, + MaxBlockGasCost: maxBlockGas, + BlockGasCostStep: gasStep, + } - return config, nil + extra.FeeConfig = feeConf + }) + + return config, err } func promptContractAllowListParams( diff --git a/cmd/interchaincmd/relayercmd/deploy.go b/cmd/interchaincmd/relayercmd/deploy.go index 8ecc99437..aeae7ca11 100644 --- a/cmd/interchaincmd/relayercmd/deploy.go +++ b/cmd/interchaincmd/relayercmd/deploy.go @@ -518,6 +518,7 @@ func CallDeploy(_ []string, flags DeployFlags, network models.Network) error { if len(configSpec.sources) > 0 && len(configSpec.destinations) > 0 { // relayer fails for empty configs binPath, err := relayer.DeployRelayer( + app, flags.Version, flags.BinPath, app.GetICMRelayerBinDir(), @@ -525,6 +526,7 @@ func CallDeploy(_ []string, flags DeployFlags, network models.Network) error { logPath, runFilePath, storageDir, + network, ) if err != nil { if bs, err := os.ReadFile(logPath); err == nil { diff --git a/cmd/interchaincmd/relayercmd/start.go b/cmd/interchaincmd/relayercmd/start.go index ff932c3c9..baed5fbbf 100644 --- a/cmd/interchaincmd/relayercmd/start.go +++ b/cmd/interchaincmd/relayercmd/start.go @@ -113,6 +113,7 @@ func CallStart(_ []string, flags StartFlags, network models.Network) error { if !utils.FileExists(relayerConfigPath) { return fmt.Errorf("there is no relayer configuration available") } else if binPath, err := relayer.DeployRelayer( + app, flags.Version, flags.BinPath, app.GetICMRelayerBinDir(), @@ -120,6 +121,7 @@ func CallStart(_ []string, flags StartFlags, network models.Network) error { app.GetLocalRelayerLogPath(network.Kind), app.GetLocalRelayerRunPath(network.Kind), app.GetLocalRelayerStorageDir(network.Kind), + network, ); err != nil { return err } else if network.Kind == models.Local { diff --git a/cmd/interchaincmd/signatureaggregatorcmd/list.go b/cmd/interchaincmd/signatureaggregatorcmd/list.go index 97a5713df..f839b6a17 100644 --- a/cmd/interchaincmd/signatureaggregatorcmd/list.go +++ b/cmd/interchaincmd/signatureaggregatorcmd/list.go @@ -18,7 +18,6 @@ var listNetworkOptions = []networkoptions.NetworkOption{ networkoptions.Local, networkoptions.Fuji, networkoptions.Mainnet, - networkoptions.Granite, } type ListFlags struct { diff --git a/cmd/interchaincmd/signatureaggregatorcmd/start.go b/cmd/interchaincmd/signatureaggregatorcmd/start.go index 005dcd3fc..bb6b5411b 100644 --- a/cmd/interchaincmd/signatureaggregatorcmd/start.go +++ b/cmd/interchaincmd/signatureaggregatorcmd/start.go @@ -21,7 +21,6 @@ var startNetworkOptions = []networkoptions.NetworkOption{ networkoptions.Local, networkoptions.Fuji, networkoptions.Mainnet, - networkoptions.Granite, } type StartFlags struct { diff --git a/cmd/interchaincmd/signatureaggregatorcmd/stop.go b/cmd/interchaincmd/signatureaggregatorcmd/stop.go index d9d817d83..467b0f016 100644 --- a/cmd/interchaincmd/signatureaggregatorcmd/stop.go +++ b/cmd/interchaincmd/signatureaggregatorcmd/stop.go @@ -16,7 +16,6 @@ var stopNetworkOptions = []networkoptions.NetworkOption{ networkoptions.Local, networkoptions.Fuji, networkoptions.Mainnet, - networkoptions.Granite, } type StopFlags struct { diff --git a/cmd/networkcmd/start.go b/cmd/networkcmd/start.go index 0d2c92930..c66eb1e93 100644 --- a/cmd/networkcmd/start.go +++ b/cmd/networkcmd/start.go @@ -147,6 +147,7 @@ func Start(flags StartFlags, printEndpoints bool) error { relayerBinPath = extraLocalNetworkData.RelayerPath } if relayerBinPath, err := relayer.DeployRelayer( + app, flags.RelayerVersion, relayerBinPath, app.GetICMRelayerBinDir(), @@ -154,6 +155,7 @@ func Start(flags StartFlags, printEndpoints bool) error { app.GetLocalRelayerLogPath(models.Local), app.GetLocalRelayerRunPath(models.Local), app.GetLocalRelayerStorageDir(models.Local), + models.NewLocalNetwork(), ); err != nil { return err } else if err := localnet.WriteExtraLocalNetworkData(app, "", relayerBinPath, "", ""); err != nil { diff --git a/cmd/nodecmd/local.go b/cmd/nodecmd/local.go index efb0159f7..b12d40508 100644 --- a/cmd/nodecmd/local.go +++ b/cmd/nodecmd/local.go @@ -8,8 +8,6 @@ import ( "strings" "time" - blockchainSDK "github.com/ava-labs/avalanche-tooling-sdk-go/blockchain" - "github.com/ava-labs/avalanche-cli/cmd/flags" "github.com/ava-labs/avalanche-cli/pkg/blockchain" "github.com/ava-labs/avalanche-cli/pkg/cobrautils" @@ -277,10 +275,6 @@ func localStartNode(_ *cobra.Command, args []string) error { if partialSync { nodeConfig[config.PartialSyncPrimaryNetworkKey] = true } - - if network.Kind == models.Granite { - connectionSettings = node.GetGraniteConnectionSettings() - } return node.StartLocalNode( app, clusterName, @@ -668,9 +662,16 @@ func addAsValidator( if err != nil { return err } - pChainHeight, err := blockchainSDK.GetPChainHeight(localValidateFlags.RPC, ids.Empty.String()) + // Get P-Chain's current epoch for RegisterL1ValidatorMessage (signed by L1, verified by P-Chain) + pChainEpoch, err := utils.GetCurrentEpoch(network.Endpoint, "P") if err != nil { - return fmt.Errorf("failure getting p-chain height: %w", err) + return fmt.Errorf("failure getting p-chain current epoch: %w", err) + } + + // Get L1 blockchain ID from chainSpec + l1BlockchainID, err := ids.FromString(chainSpec.BlockchainID) + if err != nil { + return fmt.Errorf("failure parsing blockchain ID: %w", err) } signedMessage, validationID, _, err := validatormanager.InitValidatorRegistration( ctx, @@ -692,12 +693,12 @@ func addAsValidator( delegationFee, time.Duration(minimumStakeDuration)*time.Second, common.HexToAddress(rewardsRecipientAddr), - ids.Empty, + l1BlockchainID, validatorManagerAddress, useACP99, "", signatureAggregatorEndpoint, - pChainHeight, + pChainEpoch.PChainHeight, ) if err != nil { return err @@ -720,6 +721,12 @@ func addAsValidator( } } + // Get L1's current epoch for L1ValidatorRegistrationMessage (signed by P-Chain, verified by L1) + l1Epoch, err := utils.GetCurrentL1Epoch(localValidateFlags.RPC, chainSpec.BlockchainID) + if err != nil { + return fmt.Errorf("failure getting l1 current epoch: %w", err) + } + ctx, cancel = sdkutils.GetTimedContext(constants.EVMEventLookupTimeout) defer cancel() if _, err := validatormanager.FinishValidatorRegistration( @@ -733,10 +740,10 @@ func addAsValidator( signer, validationID, aggregatorLogger, - ids.Empty, + l1BlockchainID, validatorManagerAddress, signatureAggregatorEndpoint, - pChainHeight, + l1Epoch.PChainHeight, ); err != nil { return err } diff --git a/go.mod b/go.mod index a6e1f42fb..889a353e7 100644 --- a/go.mod +++ b/go.mod @@ -3,8 +3,9 @@ module github.com/ava-labs/avalanche-cli go 1.24.9 require ( + connectrpc.com/connect v1.19.1 github.com/ava-labs/avalanche-network-runner v1.8.4-0.20251014185609-6911ff015e4c - github.com/ava-labs/avalanche-tooling-sdk-go v0.3.1-0.20251030005802-b7dea87f7633 + github.com/ava-labs/avalanche-tooling-sdk-go v0.3.1-0.20251030193212-dafe167abe0c github.com/ava-labs/avalanchego v1.14.0-fuji-rc.1 github.com/ava-labs/coreth v0.15.4-rc.4 github.com/ava-labs/icm-services v1.4.1-0.20251021221544-ae1d7d5a81f3 @@ -52,7 +53,6 @@ require ( cloud.google.com/go/auth v0.16.4 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.8.0 // indirect - connectrpc.com/connect v1.19.1 // indirect connectrpc.com/grpcreflect v1.3.0 // indirect dario.cat/mergo v1.0.0 // indirect github.com/DataDog/zstd v1.5.2 // indirect diff --git a/go.sum b/go.sum index a0eb01dba..52b4542b5 100644 --- a/go.sum +++ b/go.sum @@ -47,8 +47,8 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/ava-labs/avalanche-network-runner v1.8.4-0.20251014185609-6911ff015e4c h1:uIriOOpMqG+oF7JbYKGJwYem/sXoRxLAjUoe7x3EpWU= github.com/ava-labs/avalanche-network-runner v1.8.4-0.20251014185609-6911ff015e4c/go.mod h1:NS2385T7YN9VVdIRbM+5NpskLTF2I6ArTdts4qUFwoI= -github.com/ava-labs/avalanche-tooling-sdk-go v0.3.1-0.20251030005802-b7dea87f7633 h1:nWDoAmnixWSSGIbA9NUpA+vo+FPB+a9tT7cEE+kLnxY= -github.com/ava-labs/avalanche-tooling-sdk-go v0.3.1-0.20251030005802-b7dea87f7633/go.mod h1:ucgSCw7GyfkO4IHKuavyH/HjnMcSQ0d3ktBy93GxX8I= +github.com/ava-labs/avalanche-tooling-sdk-go v0.3.1-0.20251030193212-dafe167abe0c h1:liwltrU8UOIxMQ9DAhvACdpbN13ySo5lsn6oxNxw7Sc= +github.com/ava-labs/avalanche-tooling-sdk-go v0.3.1-0.20251030193212-dafe167abe0c/go.mod h1:1uFrL+aPqYTOftku27YNpcs1WRs4hU3kCNDzKe0tGHQ= github.com/ava-labs/avalanchego v1.14.0-fuji-rc.1 h1:/eQUKFGzK+CY2rHOypox87Cqpc9DEIOIjYgEtuRar9g= github.com/ava-labs/avalanchego v1.14.0-fuji-rc.1/go.mod h1:wEiDa5Lc3oKm9l2AxJOXmLz00Wg7b3hUttgkfzgRoDA= github.com/ava-labs/coreth v0.15.4-rc.4 h1:ze7/IwDptWG1u2d32uUZz9Ix9ycVUtlB8JufuSKSSS4= diff --git a/pkg/application/downloader.go b/pkg/application/downloader.go index e10b8cc33..8fbecc0e6 100644 --- a/pkg/application/downloader.go +++ b/pkg/application/downloader.go @@ -76,32 +76,26 @@ func (d downloader) DownloadWithTee(url string, path string) ([]byte, error) { } func (d downloader) DownloadWithCache(url string, path string, duration time.Duration) ([]byte, error) { - var data []byte - var useCache bool - - // Check if cache file exists and is recent - if fileInfo, err := os.Stat(path); err == nil { + data, err := d.Download(url) + if err != nil { + // if we can't download url due to too many requests err, check our cache + // Check if cache file exists and is recent + fileInfo, err := os.Stat(path) + if err != nil { + return nil, fmt.Errorf("unable to download or read from cache for %s", url) + } if time.Since(fileInfo.ModTime()) < duration { // Cache is valid, read from it data, err = os.ReadFile(path) - if err == nil { - useCache = true + if err != nil { + return nil, fmt.Errorf("unable to read from cache for path %s", path) } + return data, nil } } - - // If cache is not valid or doesn't exist, download - if !useCache { - var err error - data, err = d.Download(url) - if err != nil { - return nil, err - } - - // Save to cache - if err := os.MkdirAll(filepath.Dir(path), constants.DefaultPerms755); err == nil { - _ = os.WriteFile(path, data, constants.WriteReadReadPerms) - } + // Save to cache + if err := os.MkdirAll(filepath.Dir(path), constants.DefaultPerms755); err == nil { + _ = os.WriteFile(path, data, constants.WriteReadReadPerms) } return data, nil @@ -213,7 +207,7 @@ func (downloader) doAPIRequest(url, token string) (io.ReadCloser, error) { if resp.StatusCode != http.StatusOK { // http.StatusForbidden is also obtained when hitting github API rate limits if resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode == http.StatusForbidden { - if retries <= 5 { + if retries <= 10 { retries++ toSleep := time.Duration(retries) * 10 * time.Second time.Sleep(toSleep) diff --git a/pkg/blockchain/helper.go b/pkg/blockchain/helper.go index ebbda127a..3cd60e244 100644 --- a/pkg/blockchain/helper.go +++ b/pkg/blockchain/helper.go @@ -51,6 +51,21 @@ func UpdatePChainHeight( return nil } +func WaitForNewEpoch( + title string, +) error { + _, err := ux.TimedProgressBar( + 30*time.Second, + title, + 0, + ) + if err != nil { + return err + } + fmt.Println() + return nil +} + func GetBlockchainTimestamp(network models.Network) (time.Time, error) { ctx, cancel := sdkutils.GetAPIContext() defer cancel() diff --git a/pkg/constants/constants.go b/pkg/constants/constants.go index 3c7215862..0b42c1376 100644 --- a/pkg/constants/constants.go +++ b/pkg/constants/constants.go @@ -69,9 +69,7 @@ const ( LocalBootstrapTimeout = 2 * time.Minute FujiBootstrapTimeout = 15 * time.Minute MainnetBootstrapTimeout = 24 * time.Hour - GraniteBootstrapTimeout = 15 * time.Minute - - EVMEventLookupTimeout = 2 * time.Minute + EVMEventLookupTimeout = 2 * time.Minute DownloadCacheExpiration = 3 * time.Hour @@ -93,7 +91,7 @@ const ( LatestPreReleaseVersionTag = "latest-prerelease" LatestReleaseVersionTag = "latest" DefaultAvalancheGoVersion = LatestReleaseVersionTag - DefaultRelayerVersion = LatestPreReleaseVersionTag + DefaultRelayerVersion = LatestReleaseVersionTag DefaultSignatureAggregatorVersion = LatestReleaseVersionTag FujiAPIEndpoint = "https://api.avax-test.network" @@ -106,9 +104,6 @@ const ( LocalNetworkAvalancheGoMaxLogSize = 1 LocalNetworkAvalancheGoMaxLogFiles = 2 - GraniteNetworkEndpoint = "https://granite.avax-dev.network" - GraniteNetworkID = 76 - DevnetAPIEndpoint = "" DevnetNetworkID = 1338 @@ -238,6 +233,7 @@ const ( ICMKeyName = "cli-teleporter-deployer" ICMRelayerKeyName = "cli-awm-relayer" + RelayerRepoName = "relayer" DefaultRelayerAmount = float64(10) // to not interfere with other node services diff --git a/pkg/constants/etna.go b/pkg/constants/etna.go deleted file mode 100644 index b3723c13e..000000000 --- a/pkg/constants/etna.go +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (C) 2025, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. -package constants - -import ( - "time" - - "github.com/ava-labs/avalanchego/upgrade" - avagoconstants "github.com/ava-labs/avalanchego/utils/constants" -) - -var EtnaActivationTime = map[uint32]time.Time{ - avagoconstants.FujiID: time.Date(2024, time.November, 25, 16, 0, 0, 0, time.UTC), - avagoconstants.MainnetID: time.Date(2024, time.December, 16, 17, 0, 0, 0, time.UTC), - LocalNetworkID: upgrade.Default.EtnaTime, -} diff --git a/pkg/constants/etnaDevnet/genesis.json b/pkg/constants/etnaDevnet/genesis.json deleted file mode 100644 index 38cd96de0..000000000 --- a/pkg/constants/etnaDevnet/genesis.json +++ /dev/null @@ -1,87 +0,0 @@ -{ - "networkID": 76, - "allocations": [ - { - "ethAddr": "0xC71A61a815e49d16C425482A342a367CD42E38a6", - "avaxAddr": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "initialAmount": 500000000000000000, - "unlockSchedule": [ - { - "amount": 100000000000000000, - "locktime": 1633824000 - }, - { - "amount": 100000000000000000, - "locktime": 1633825000 - }, - { - "amount": 100000000000000000, - "locktime": 1633826000 - }, - { - "amount": 100000000000000000, - "locktime": 1633827000 - }, - { - "amount": 100000000000000000, - "locktime": 1633828000 - } - ] - } - ], - "startTime": 1725300000, - "initialStakeDuration": 31530000, - "initialStakeDurationOffset": 5400, - "initialStakedFunds": [ - "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9" - ], - "initialStakers": [ - { - "nodeID": "NodeID-gpXWBExQSZXqJPQt6L6MnveUfgr7HJ4q", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xa14d67f097d7e6514696fd83080794b6b5ca664001f2ede4fd6f01da4933db875ff028fec42b29fc5524941e0f20830f", - "proofOfPossession": "0x82352ae1e01038173e92e088bd34c2bee9cc4b34df5c5e8bd2773cef9238eef870c2f93fa89607332ccbb84aa66608c706b7c2f127b8b80c461c04bbc6082afbffe220aac79f66533ea7c63f0451d7d32456369dd335c9710938ee4111d08d79" - } - }, - { - "nodeID": "NodeID-78ibWpjtZz5ZGT6EyTEdu8VKmboUHTuGT", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0x8327dbe1ba411c270637b080a8471fb41eeb8a9b3917af0727501ef8bdaa901d063780bd702f30f458a61f3d4297dc98", - "proofOfPossession": "0xa9c039b5765ab068bd632bbcdc9bc2a53f29e2c56b33e30d732a23d8c430d53ef47ebccfaa5cfcedd8f041c2c1348f0b0eac413192b7544d284f82d1fa0f74f98d5805905363b8186efdef6e77182fb1e7147f8511e900d195db06da6a22f0a0" - } - }, - { - "nodeID": "NodeID-L4CY8B5uVSDe4cnN1BpeDsHacMp4q4q8q", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xa98c646a8c862ec15326e4cfe2a0f66a8fb7cf555765f83ff320a1a76268228f3c8b262d1de4008e0ba49a89cfabfb95", - "proofOfPossession": "0x95c816a4d292a47c4d9934e358621d0785fd2920a1a304cebc9b7e47417e3fff780cfcddf7ca1177b45bbfac2f9978581761d9ddd55ec6142d92998eeadbafe8cd7651056fbb79afea643f0cd20ff4f6389ddd91ee2db4579438a6908609b4c1" - } - }, - { - "nodeID": "NodeID-P5QGH4EXddrcyNAzkqyZKHXgEpVX6HExL", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xb0d35ccf70a6d84e2bca1dc166a4c3324d7edd86e879add2ba6511c8ef6bfd89a15534e67467ccd9c9211534b33295a1", - "proofOfPossession": "0xa4b480a9a07b4a97630dd9d6e2bf4834a3e670448b5575e3ba72a03e06ec509ec859840a1104b18f0cd54696e6f98adb0e9f5260161332fe32a50cb1a9806b1b5025037731ea77c641d607fd0584ce29d7954f5e8f523c13a2e5732511227f50" - } - }, - { - "nodeID": "NodeID-7eRvnfs2a2PvrPHUuCRRpPVAoVjbWxaFG", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xa5fde6042c6e0ee482f46346df046000cd57dd878d36637a5a62adec07a5114cdeea094a85f4f72b46645f94e9076692", - "proofOfPossession": "0x91444230c5ceb8e51642139e1842b56f8563865376b6f4205beca4dc0bb0bc4b314bce1e19e3b542a3941ece51ae205e03a094824fee28f9f702ed310756f0637bf166371656e1c3eb9001df89f4cdccc73410242a6d875eb6363d12bce40316" - } - } - ], - "cChainGenesis": "{\"config\":{\"chainId\":43117,\"homesteadBlock\":0,\"daoForkBlock\":0,\"daoForkSupport\":true,\"eip150Block\":0,\"eip150Hash\":\"0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0\",\"eip155Block\":0,\"eip158Block\":0,\"byzantiumBlock\":0,\"constantinopleBlock\":0,\"petersburgBlock\":0,\"istanbulBlock\":0,\"muirGlacierBlock\":0},\"nonce\":\"0x0\",\"timestamp\":\"0x0\",\"extraData\":\"0x00\",\"gasLimit\":\"0x5f5e100\",\"difficulty\":\"0x0\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"coinbase\":\"0x0000000000000000000000000000000000000000\",\"alloc\":{\"0100000000000000000000000000000000000000\":{\"code\":\"0x7300000000000000000000000000000000000000003014608060405260043610603d5760003560e01c80631e010439146042578063b6510bb314606e575b600080fd5b605c60048036036020811015605657600080fd5b503560b1565b60408051918252519081900360200190f35b818015607957600080fd5b5060af60048036036080811015608e57600080fd5b506001600160a01b03813516906020810135906040810135906060013560b6565b005b30cd90565b836001600160a01b031681836108fc8690811502906040516000604051808303818888878c8acf9550505050505015801560f4573d6000803e3d6000fd5b505050505056fea26469706673582212201eebce970fe3f5cb96bf8ac6ba5f5c133fc2908ae3dcd51082cfee8f583429d064736f6c634300060a0033\",\"balance\":\"0x0\"},\"0x643F2454430E218750b5e6533d9C0e0Dd50B8d68\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xf9BFA4C45a8d830a591B3374320fd8CCF3FD75D4\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xD9d4f16a71E23eDf8e2F2a1Ebecd46B03177a22c\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0x2a17831425bc6D20084D1526b1001C451ED4C4A7\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0x7c5A8639F1e86F134f1E4239429f756A1441e322\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xfDDEf5cb0D09E483dBAB587BA958657B79A42E58\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xB4cA6C121D6287af7ac7cb62Ae33d2b054b9FC44\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xC71A61a815e49d16C425482A342a367CD42E38a6\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"}},\"number\":\"0x0\",\"gasUsed\":\"0x0\",\"parentHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\"}", - "message": "Etna here we come" -} diff --git a/pkg/constants/granite.go b/pkg/constants/granite.go deleted file mode 100644 index a9d47b765..000000000 --- a/pkg/constants/granite.go +++ /dev/null @@ -1,30 +0,0 @@ -// Copyright (C) 2022, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. -package constants - -import ( - _ "embed" -) - -//go:embed graniteDevnet/genesis.json -var GraniteDevnetGenesisData []byte - -//go:embed graniteDevnet/upgrade.json -var GraniteDevnetUpgradeData []byte - -var ( - GraniteDevnetBootstrapNodeIDs = []string{ - "NodeID-DG4zG5SNeMof4Fh6u5Dmn7qhpQD5pqbw1", - "NodeID-HDkaXpmjrENuBmqkggonVQh6tmuFuJFP", - "NodeID-PnfqkMjddeFVShZq8dwxb9KxsHgkES7RC", - "NodeID-5T26eUHiPv276fQuM4y8dDsJrVJkHFm3L", - "NodeID-M7StQdVYYzqWGHVZJsZoWjLWiWugB79DX", - } - GraniteDevnetBootstrapIPs = []string{ - "107.21.11.213:9651", - "34.233.248.130:9651", - "52.201.126.172:9651", - "35.170.144.5:9651", - "98.82.41.186:9651", - } -) diff --git a/pkg/constants/graniteDevnet/genesis.json b/pkg/constants/graniteDevnet/genesis.json deleted file mode 100644 index b654f5f8e..000000000 --- a/pkg/constants/graniteDevnet/genesis.json +++ /dev/null @@ -1,87 +0,0 @@ -{ - "networkID": 76, - "allocations": [ - { - "ethAddr": "0xC71A61a815e49d16C425482A342a367CD42E38a6", - "avaxAddr": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "initialAmount": 500000000000000000, - "unlockSchedule": [ - { - "amount": 100000000000000000, - "locktime": 1633824000 - }, - { - "amount": 100000000000000000, - "locktime": 1633825000 - }, - { - "amount": 100000000000000000, - "locktime": 1633826000 - }, - { - "amount": 100000000000000000, - "locktime": 1633827000 - }, - { - "amount": 100000000000000000, - "locktime": 1633828000 - } - ] - } - ], - "startTime": 1759245839, - "initialStakeDuration": 31530000, - "initialStakeDurationOffset": 5400, - "initialStakedFunds": [ - "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9" - ], - "initialStakers": [ - { - "nodeID": "NodeID-DG4zG5SNeMof4Fh6u5Dmn7qhpQD5pqbw1", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0x9567aae08a553277a443e895b1a440f47fa0cd9cef4d245a42deb220c356628a4eed1f0eddced6153798c8f8276c81e9", - "proofOfPossession": "0x9647d1530073ecb1125915fa59b987573d8d366f05247730635ebd64a41fc4a8e3f155d3446b2244ea2b62bb17411c1d164b3c542f40275f26543caac14e9faacac5192c64ce7a3b67797ef81b402d659eac22c7fa5ce75a8b3e7c2ec3c7b9e1" - } - }, - { - "nodeID": "NodeID-HDkaXpmjrENuBmqkggonVQh6tmuFuJFP", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xb0f5dccb0b6b1aa27eea60de867f4f8e35ed7dbbc83ccb141d0de64bd9018eb24ee97d3753c33e0cd0d289024441e165", - "proofOfPossession": "0xb9111cc01cab6e1d4b8c49202c789d51d386fe22aa3ffbda4da08ecc66e727f36bf79ab432292429c1132ed5b5736a2d0530180691636ff886e4b8bf76d393bca0990b06bd86e06bfa53841935b809bb059255d92355928563acf656bb6a306c" - } - }, - { - "nodeID": "NodeID-PnfqkMjddeFVShZq8dwxb9KxsHgkES7RC", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xb1746c6f9bdcc0ef8a33609c65be3aa46b2f842472af7c2f5b3abe2dd4943481f845c5c621dc7f14489fca180a4b9049", - "proofOfPossession": "0xa767c5293768ad924b4a57cb865952c3f80418642406cf354ac81e6c9ca11ca2b6d84d2f9adf57a3e5d0b69d7de134960487df1108e08598f30e0c62058bbefb89a6f205178016f59bef5ccc12be427f113f9670b8a050e7d37f2bd04fc13d23" - } - }, - { - "nodeID": "NodeID-5T26eUHiPv276fQuM4y8dDsJrVJkHFm3L", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0x941fc5e507a45170d1229dfb08da7b5f58fe2bd1fbf63d3d8e5b1b7c71e71638ea523e22a6ac90e835f1ef99b7fb8da6", - "proofOfPossession": "0xade5caaba1513956b1411fb9dfd59a53cb84dc03e4e070f438897f52851e64620a75d81535c8fb72997e3a894b22b9f609f7cec7d3eb66c392563f3bc496688df1060b896b4a5dd8e3b8d826aa2002407cfee6dd30f4409aa56e5c51309afcf9" - } - }, - { - "nodeID": "NodeID-M7StQdVYYzqWGHVZJsZoWjLWiWugB79DX", - "rewardAddress": "X-custom1v6vuwxjgr043sg0nuuhq70k6vgnule692fvnr9", - "delegationFee": 62500, - "signer": { - "publicKey": "0xa3bcce07df5a66aa5d15c3d4bb87eda4f585f057ddc26d7dfe14e6f4009ac5642bc041abf1bc332f55f8eb5bc2ccad57", - "proofOfPossession": "0x968ec3cce5c0c0f2356ad2485ffe585475b5afff5710bebd752f9c70c0b7b7c9ff5ddcbf7049bc7a1d54d1559178f5811850d6bad1d62b0dfea5d88a3ed285a3e0d3a66ec9148b86968ddbf0e98a7d1d510f38507a930f1c79e5d2618f9db3f2" - } - } - ], - "cChainGenesis": "{\"config\":{\"chainId\":43117,\"homesteadBlock\":0,\"daoForkBlock\":0,\"daoForkSupport\":true,\"eip150Block\":0,\"eip150Hash\":\"0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0\",\"eip155Block\":0,\"eip158Block\":0,\"byzantiumBlock\":0,\"constantinopleBlock\":0,\"petersburgBlock\":0,\"istanbulBlock\":0,\"muirGlacierBlock\":0},\"nonce\":\"0x0\",\"timestamp\":\"0x0\",\"extraData\":\"0x00\",\"gasLimit\":\"0x5f5e100\",\"difficulty\":\"0x0\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"coinbase\":\"0x0000000000000000000000000000000000000000\",\"alloc\":{\"0100000000000000000000000000000000000000\":{\"code\":\"0x7300000000000000000000000000000000000000003014608060405260043610603d5760003560e01c80631e010439146042578063b6510bb314606e575b600080fd5b605c60048036036020811015605657600080fd5b503560b1565b60408051918252519081900360200190f35b818015607957600080fd5b5060af60048036036080811015608e57600080fd5b506001600160a01b03813516906020810135906040810135906060013560b6565b005b30cd90565b836001600160a01b031681836108fc8690811502906040516000604051808303818888878c8acf9550505050505015801560f4573d6000803e3d6000fd5b505050505056fea26469706673582212201eebce970fe3f5cb96bf8ac6ba5f5c133fc2908ae3dcd51082cfee8f583429d064736f6c634300060a0033\",\"balance\":\"0x0\"},\"0x643F2454430E218750b5e6533d9C0e0Dd50B8d68\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xf9BFA4C45a8d830a591B3374320fd8CCF3FD75D4\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xD9d4f16a71E23eDf8e2F2a1Ebecd46B03177a22c\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0x2a17831425bc6D20084D1526b1001C451ED4C4A7\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0x7c5A8639F1e86F134f1E4239429f756A1441e322\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xfDDEf5cb0D09E483dBAB587BA958657B79A42E58\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xB4cA6C121D6287af7ac7cb62Ae33d2b054b9FC44\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xfDDEf5cb0D09E483dBAB587BA958657B79A42E58\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"},\"0xC71A61a815e49d16C425482A342a367CD42E38a6\":{\"balance\":\"0x1431E0FAE6D7217CAA0000000\"}},\"number\":\"0x0\",\"gasUsed\":\"0x0\",\"parentHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\"}", - "message": "Granite here we come" -} diff --git a/pkg/constants/graniteDevnet/upgrade.json b/pkg/constants/graniteDevnet/upgrade.json deleted file mode 100644 index 4360cfed1..000000000 --- a/pkg/constants/graniteDevnet/upgrade.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "apricotPhase1Time": "2020-12-05T05:00:00Z", - "apricotPhase2Time": "2020-12-05T05:00:00Z", - "apricotPhase3Time": "2020-12-05T05:00:00Z", - "apricotPhase4Time": "2020-12-05T05:00:00Z", - "apricotPhase4MinPChainHeight": 0, - "apricotPhase5Time": "2020-12-05T05:00:00Z", - "apricotPhasePre6Time": "2020-12-05T05:00:00Z", - "apricotPhase6Time": "2020-12-05T05:00:00Z", - "apricotPhasePost6Time": "2020-12-05T05:00:00Z", - "banffTime": "2020-12-05T05:00:00Z", - "cortinaTime": "2020-12-05T05:00:00Z", - "cortinaXChainStopVertexID": "11111111111111111111111111111111LpoYY", - "durangoTime": "2020-12-05T05:00:00Z", - "etnaTime": "2020-12-05T05:00:00Z", - "fortunaTime": "2020-12-05T05:00:00Z", - "graniteTime": "2025-10-13T19:00:00Z", - "graniteEpochDuration": 300000000000 -} diff --git a/pkg/contract/allocations.go b/pkg/contract/allocations.go index 19ec1a9c7..8320afc55 100644 --- a/pkg/contract/allocations.go +++ b/pkg/contract/allocations.go @@ -203,29 +203,45 @@ func getGenesisNativeMinterAdmin( if err != nil { return false, false, "", "", "", err } - if genesis.Config != nil && params.GetExtra(genesis.Config).GenesisPrecompiles[nativeminter.ConfigKey] != nil { - allowListCfg, ok := params.GetExtra(genesis.Config).GenesisPrecompiles[nativeminter.ConfigKey].(*nativeminter.Config) + if genesis.Config == nil { + return false, false, "", "", "", nil + } + + var hasNativeMinter bool + var foundKey bool + var keyName, addressStr, privKey string + params.WithTempRegisteredExtras(func() { + extra := params.GetExtra(genesis.Config) + if extra.GenesisPrecompiles[nativeminter.ConfigKey] == nil { + return + } + hasNativeMinter = true + allowListCfg, ok := extra.GenesisPrecompiles[nativeminter.ConfigKey].(*nativeminter.Config) if !ok { - return false, false, "", "", "", fmt.Errorf( + err = fmt.Errorf( "expected config of type nativeminter.AllowListConfig, but got %T", allowListCfg, ) + return } if len(allowListCfg.AllowListConfig.AdminAddresses) == 0 { - return false, false, "", "", "", nil + return } for _, admin := range allowListCfg.AllowListConfig.AdminAddresses { - found, keyName, addressStr, privKey, err := SearchForManagedKey(app, network, admin, true) + foundKey, keyName, addressStr, privKey, err = SearchForManagedKey(app, network, admin, true) if err != nil { - return false, false, "", "", "", err + return } - if found { - return true, true, keyName, addressStr, privKey, nil + if foundKey { + return } } - return true, false, "", allowListCfg.AllowListConfig.AdminAddresses[0].Hex(), "", nil + addressStr = allowListCfg.AllowListConfig.AdminAddresses[0].Hex() + }) + if err != nil { + return false, false, "", "", "", err } - return false, false, "", "", "", nil + return hasNativeMinter, foundKey, keyName, addressStr, privKey, nil } func getGenesisNativeMinterManager( @@ -237,29 +253,45 @@ func getGenesisNativeMinterManager( if err != nil { return false, false, "", "", "", err } - if genesis.Config != nil && params.GetExtra(genesis.Config).GenesisPrecompiles[nativeminter.ConfigKey] != nil { - allowListCfg, ok := params.GetExtra(genesis.Config).GenesisPrecompiles[nativeminter.ConfigKey].(*nativeminter.Config) + if genesis.Config == nil { + return false, false, "", "", "", nil + } + + var hasNativeMinter bool + var foundKey bool + var keyName, addressStr, privKey string + params.WithTempRegisteredExtras(func() { + extra := params.GetExtra(genesis.Config) + if extra.GenesisPrecompiles[nativeminter.ConfigKey] == nil { + return + } + hasNativeMinter = true + allowListCfg, ok := extra.GenesisPrecompiles[nativeminter.ConfigKey].(*nativeminter.Config) if !ok { - return false, false, "", "", "", fmt.Errorf( + err = fmt.Errorf( "expected config of type nativeminter.AllowListConfig, but got %T", allowListCfg, ) + return } if len(allowListCfg.AllowListConfig.ManagerAddresses) == 0 { - return false, false, "", "", "", nil + return } for _, admin := range allowListCfg.AllowListConfig.ManagerAddresses { - found, keyName, addressStr, privKey, err := SearchForManagedKey(app, network, admin, true) + foundKey, keyName, addressStr, privKey, err = SearchForManagedKey(app, network, admin, true) if err != nil { - return false, false, "", "", "", err + return } - if found { - return true, true, keyName, addressStr, privKey, nil + if foundKey { + return } } - return true, false, "", allowListCfg.AllowListConfig.ManagerAddresses[0].Hex(), "", nil + addressStr = allowListCfg.AllowListConfig.ManagerAddresses[0].Hex() + }) + if err != nil { + return false, false, "", "", "", err } - return false, false, "", "", "", nil + return hasNativeMinter, foundKey, keyName, addressStr, privKey, nil } func GetEVMSubnetGenesisNativeMinterAdmin( diff --git a/pkg/dependencies/dependencies.go b/pkg/dependencies/dependencies.go index adcadac91..b2fc1a705 100644 --- a/pkg/dependencies/dependencies.go +++ b/pkg/dependencies/dependencies.go @@ -60,6 +60,8 @@ func GetLatestCLISupportedDependencyVersion(app *application.Avalanche, dependen return parsedDependency.SubnetEVM[networkName].LatestVersion, nil case constants.SignatureAggregatorRepoName: return parsedDependency.SignatureAggregator[networkName].LatestVersion, nil + case constants.RelayerRepoName: + return parsedDependency.Relayer[networkName].LatestVersion, nil default: return "", fmt.Errorf("unsupported dependency: %s", dependencyName) } diff --git a/pkg/dependencies/dependencies_test.go b/pkg/dependencies/dependencies_test.go index b721835a4..c2341fef7 100644 --- a/pkg/dependencies/dependencies_test.go +++ b/pkg/dependencies/dependencies_test.go @@ -22,8 +22,8 @@ var ( testAvagoCompat5 = []byte("{\"39\": [\"v1.12.2\", \"v1.13.0\"],\"38\": [\"v1.11.13\", \"v1.12.0\", \"v1.12.1\"]}") testAvagoCompat6 = []byte("{\"39\": [\"v1.12.2\", \"v1.13.0\", \"v1.13.1\"],\"38\": [\"v1.11.13\", \"v1.12.0\", \"v1.12.1\"]}") testAvagoCompat7 = []byte("{\"40\": [\"v1.13.2\"],\"39\": [\"v1.12.2\", \"v1.13.0\", \"v1.13.1\"]}") - testCLICompat = []byte(`{"subnet-evm":"v0.7.3","rpc":39,"avalanchego":{"Local Network":{"latest-version":"v1.13.0"},"DevNet":{"latest-version":"v1.13.0"},"Fuji":{"latest-version":"v1.13.0"},"Mainnet":{"latest-version":"v1.13.0"}}, "signature-aggregator": "signature-aggregator-v0.4.4"}`) - testCLICompat2 = []byte(`{"subnet-evm":"v0.7.3","rpc":39,"avalanchego":{"Local Network":{"latest-version":"v1.13.0"},"DevNet":{"latest-version":"v1.13.0"},"Fuji":{"latest-version":"v1.13.0-fuji"},"Mainnet":{"latest-version":"v1.13.0"}}, "signature-aggregator": "signature-aggregator-v0.4.4"}`) + testCLICompat = []byte(`{"rpc":39,"subnet-evm":{"Local Network":{"latest-version":"v0.7.3"},"DevNet":{"latest-version":"v0.7.3"},"Fuji":{"latest-version":"v0.7.3"},"Mainnet":{"latest-version":"v0.7.3"}},"avalanchego":{"Local Network":{"latest-version":"v1.13.0"},"DevNet":{"latest-version":"v1.13.0"},"Fuji":{"latest-version":"v1.13.0"},"Mainnet":{"latest-version":"v1.13.0"}}, "signature-aggregator": {"Local Network":{"latest-version":"signature-aggregator-v0.4.4"},"DevNet":{"latest-version":"signature-aggregator-v0.4.4"},"Fuji":{"latest-version":"signature-aggregator-v0.4.4"},"Mainnet":{"latest-version":"signature-aggregator-v0.4.4"}}}`) + testCLICompat2 = []byte(`{"rpc":39,"subnet-evm":{"Local Network":{"latest-version":"v0.7.3"},"DevNet":{"latest-version":"v0.7.3"},"Fuji":{"latest-version":"v0.7.3"},"Mainnet":{"latest-version":"v0.7.3"}},"avalanchego":{"Local Network":{"latest-version":"v1.13.0"},"DevNet":{"latest-version":"v1.13.0"},"Fuji":{"latest-version":"v1.13.0-fuji"},"Mainnet":{"latest-version":"v1.13.0"}}, "signature-aggregator": {"Local Network":{"latest-version":"signature-aggregator-v0.4.4"},"DevNet":{"latest-version":"signature-aggregator-v0.4.4"},"Fuji":{"latest-version":"signature-aggregator-v0.4.4"},"Mainnet":{"latest-version":"signature-aggregator-v0.4.4"}}}`) ) func TestGetLatestAvalancheGoByProtocolVersion(t *testing.T) { diff --git a/pkg/dependencies/min_version_test.go b/pkg/dependencies/min_version_test.go index 187e078b3..da58d605b 100644 --- a/pkg/dependencies/min_version_test.go +++ b/pkg/dependencies/min_version_test.go @@ -14,7 +14,7 @@ import ( "github.com/stretchr/testify/require" ) -var testCLIMinVersion = []byte(`{"subnet-evm":"v0.7.3","rpc":39,"avalanchego":{"Local Network":{"latest-version":"v1.13.0", "minimum-version":""},"DevNet":{"latest-version":"v1.13.0", "minimum-version":""},"Fuji":{"latest-version":"v1.13.0", "minimum-version":"v1.13.0-fuji"},"Mainnet":{"latest-version":"v1.13.0", "minimum-version":"v1.13.0"}}}`) +var testCLIMinVersion = []byte(`{"rpc":39,"subnet-evm":{"Local Network":{"latest-version":"v0.7.3"},"DevNet":{"latest-version":"v0.7.3"},"Fuji":{"latest-version":"v0.7.3"},"Mainnet":{"latest-version":"v0.7.3"}},"avalanchego":{"Local Network":{"latest-version":"v1.13.0", "minimum-version":""},"DevNet":{"latest-version":"v1.13.0", "minimum-version":""},"Fuji":{"latest-version":"v1.13.0", "minimum-version":"v1.13.0-fuji"},"Mainnet":{"latest-version":"v1.13.0", "minimum-version":"v1.13.0"}}}`) func TestCheckMinDependencyVersion(t *testing.T) { tests := []struct { diff --git a/pkg/interchain/relayer/relayer.go b/pkg/interchain/relayer/relayer.go index 0a9f48530..4ed728781 100644 --- a/pkg/interchain/relayer/relayer.go +++ b/pkg/interchain/relayer/relayer.go @@ -15,6 +15,8 @@ import ( "syscall" "time" + "github.com/ava-labs/avalanche-cli/pkg/dependencies" + "github.com/ava-labs/avalanche-cli/pkg/application" "github.com/ava-labs/avalanche-cli/pkg/binutils" "github.com/ava-labs/avalanche-cli/pkg/constants" @@ -97,6 +99,7 @@ type relayerRunFile struct { } func DeployRelayer( + app *application.Avalanche, version string, binPath string, binDir string, @@ -104,13 +107,14 @@ func DeployRelayer( logFilePath string, runFilePath string, storageDir string, + network models.Network, ) (string, error) { if err := RelayerCleanup(runFilePath, logFilePath, storageDir); err != nil { return "", err } if binPath == "" { var err error - binPath, err = InstallRelayer(binDir, version) + binPath, err = InstallRelayer(app, binDir, version, network) if err != nil { return "", err } @@ -230,17 +234,16 @@ func GetLatestRelayerPreReleaseVersion() (string, error) { ) } -func InstallRelayer(binDir, version string) (string, error) { +func InstallRelayer(app *application.Avalanche, binDir, version string, network models.Network) (string, error) { + var err error if version == "" || version == constants.LatestPreReleaseVersionTag { - var err error version, err = GetLatestRelayerPreReleaseVersion() if err != nil { return "", err } } if version == constants.LatestReleaseVersionTag { - var err error - version, err = GetLatestRelayerReleaseVersion() + version, err = dependencies.GetLatestCLISupportedDependencyVersion(app, constants.RelayerRepoName, network, nil) if err != nil { return "", err } diff --git a/pkg/keychain/keychain.go b/pkg/keychain/keychain.go index 1dd51d3d5..1babffae7 100644 --- a/pkg/keychain/keychain.go +++ b/pkg/keychain/keychain.go @@ -142,15 +142,6 @@ func GetKeychainFromCmdLineFlags( return nil, err } } - case network.Kind == models.Granite: - // prompt the user if no key source was provided - if !useEwoq && !useLedger && keyName == "" { - var err error - useLedger, keyName, err = prompts.GetKeyOrLedger(app.Prompt, keychainGoal, app.GetKeyDir(), false) - if err != nil { - return nil, err - } - } case network.Kind == models.Fuji: if useEwoq || keyName == "ewoq" { return nil, ErrEwoqKeyOnFujiOrMainnet diff --git a/pkg/localnet/default.json b/pkg/localnet/default.json index 1642a4e25..fb0c913a2 100644 --- a/pkg/localnet/default.json +++ b/pkg/localnet/default.json @@ -51,5 +51,5 @@ "log-rotater-max-size": 1, "proposervm-use-current-height": true }, - "upgrade": "{\n \"apricotPhase1Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase2Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase3Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase4Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase4MinPChainHeight\": 0,\n \"apricotPhase5Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhasePre6Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase6Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhasePost6Time\": \"2020-12-05T05:00:00Z\",\n \"banffTime\": \"2020-12-05T05:00:00Z\",\n \"cortinaTime\": \"2020-12-05T05:00:00Z\",\n \"cortinaXChainStopVertexID\": \"11111111111111111111111111111111LpoYY\",\n \"durangoTime\": \"2020-12-05T05:00:00Z\",\n \"etnaTime\": \"2024-10-09T20:00:00Z\"\n}\n" + "upgrade": "{\n \"apricotPhase1Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase2Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase3Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase4Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase4MinPChainHeight\": 0,\n \"apricotPhase5Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhasePre6Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhase6Time\": \"2020-12-05T05:00:00Z\",\n \"apricotPhasePost6Time\": \"2020-12-05T05:00:00Z\",\n \"banffTime\": \"2020-12-05T05:00:00Z\",\n \"cortinaTime\": \"2020-12-05T05:00:00Z\",\n \"cortinaXChainStopVertexID\": \"11111111111111111111111111111111LpoYY\",\n \"durangoTime\": \"2020-12-05T05:00:00Z\",\n \"etnaTime\": \"2020-12-05T05:00:00Z\",\n \"fortunaTime\": \"2020-12-05T05:00:00Z\",\n \"graniteTime\": \"2020-12-05T05:00:00Z\",\n \"graniteEpochDuration\": 30000000000\n}\n" } diff --git a/pkg/localnet/migration.go b/pkg/localnet/migration.go index 088ba114a..20c57b08e 100644 --- a/pkg/localnet/migration.go +++ b/pkg/localnet/migration.go @@ -157,6 +157,7 @@ func MigrateANRToTmpNet( if utils.FileExists(relayerConfigPath) { printFunc("Restarting relayer") if _, err := relayer.DeployRelayer( + app, constants.DefaultRelayerVersion, relayerBinPath, app.GetICMRelayerBinDir(), @@ -164,6 +165,7 @@ func MigrateANRToTmpNet( app.GetLocalRelayerLogPath(clusterToReloadNetwork.Kind), app.GetLocalRelayerRunPath(clusterToReloadNetwork.Kind), app.GetLocalRelayerStorageDir(clusterToReloadNetwork.Kind), + clusterToReloadNetwork, ); err != nil { return err } diff --git a/pkg/models/compatibility.go b/pkg/models/compatibility.go index 06e09ad5a..35fc27756 100644 --- a/pkg/models/compatibility.go +++ b/pkg/models/compatibility.go @@ -19,4 +19,5 @@ type CLIDependencyMap struct { SubnetEVM map[string]NetworkVersion `json:"subnet-evm"` AvalancheGo map[string]NetworkVersion `json:"avalanchego"` SignatureAggregator map[string]NetworkVersion `json:"signature-aggregator"` + Relayer map[string]NetworkVersion `json:"relayer"` } diff --git a/pkg/models/network.go b/pkg/models/network.go index 5d66f1a09..cac79e7c5 100644 --- a/pkg/models/network.go +++ b/pkg/models/network.go @@ -24,7 +24,6 @@ const ( Fuji Local Devnet - Granite ) const wssScheme = "wss" @@ -39,8 +38,6 @@ func (nk NetworkKind) String() string { return "Local Network" case Devnet: return "Devnet" - case Granite: - return "Granite" } return "invalid network" } @@ -71,10 +68,6 @@ func NewLocalNetwork() Network { return NewNetwork(Local, constants.LocalNetworkID, constants.LocalAPIEndpoint, "") } -func NewGraniteNetwork() Network { - return NewNetwork(Granite, constants.GraniteNetworkID, constants.GraniteNetworkEndpoint, "") -} - func NewDevnetNetwork(endpoint string, id uint32) Network { if endpoint == "" { endpoint = constants.DevnetAPIEndpoint @@ -97,8 +90,6 @@ func ConvertClusterToNetwork(clusterNetwork Network) Network { return NewFujiNetwork() case clusterNetwork.ID == avagoconstants.MainnetID: return NewMainnetNetwork() - case clusterNetwork.ID == constants.GraniteNetworkID: - return NewGraniteNetwork() default: networkID := uint32(0) if clusterNetwork.Endpoint != "" { @@ -136,8 +127,6 @@ func NetworkFromNetworkID(networkID uint32) Network { return NewFujiNetwork() case constants.LocalNetworkID: return NewLocalNetwork() - case constants.GraniteNetworkID: - return NewGraniteNetwork() } return NewDevnetNetwork("", networkID) } @@ -175,8 +164,6 @@ func (n Network) BlockchainWSEndpoint(blockchainID string) string { trimmedURI = strings.TrimPrefix(trimmedURI, "https://") scheme := "ws" switch n.Kind { - case Granite: - scheme = wssScheme case Fuji: scheme = wssScheme case Mainnet: @@ -191,8 +178,6 @@ func (n Network) NetworkIDFlagValue() string { return fmt.Sprintf("network-%d", n.ID) case Devnet: return fmt.Sprintf("network-%d", n.ID) - case Granite: - return "granite" case Fuji: return "fuji" case Mainnet: @@ -207,8 +192,6 @@ func (n Network) GenesisParams() *genesis.Params { return &genesis.LocalParams case Devnet: return &genesis.LocalParams - case Granite: - return &genesis.LocalParams case Fuji: return &genesis.FujiParams case Mainnet: @@ -239,8 +222,6 @@ func (n *Network) BootstrappingContext() (context.Context, context.CancelFunc) { timeout = constants.FujiBootstrapTimeout case Mainnet: timeout = constants.MainnetBootstrapTimeout - case Granite: - timeout = constants.GraniteBootstrapTimeout } return utils.GetTimedContext(timeout) } @@ -255,8 +236,6 @@ func (n Network) SDKNetwork() sdkNetwork.Network { return sdkNetwork.NewNetwork(sdkNetwork.Devnet, n.ID, n.Endpoint) case Devnet: return sdkNetwork.NewNetwork(sdkNetwork.Devnet, n.ID, n.Endpoint) - case Granite: - return sdkNetwork.GraniteNetwork() } return sdkNetwork.UndefinedNetwork } diff --git a/pkg/networkoptions/network_options.go b/pkg/networkoptions/network_options.go index 59158dedb..951bbc1cb 100644 --- a/pkg/networkoptions/network_options.go +++ b/pkg/networkoptions/network_options.go @@ -33,7 +33,6 @@ const ( Local Devnet Cluster - Granite ) var ( @@ -42,7 +41,6 @@ var ( Devnet, Fuji, Mainnet, - Granite, } NonLocalSupportedNetworkOptions = []NetworkOption{ Devnet, @@ -72,8 +70,6 @@ func (n NetworkOption) String() string { return "Devnet" case Cluster: return "Cluster" - case Granite: - return "Granite" } return "invalid network" } @@ -86,8 +82,6 @@ func NetworkOptionFromString(s string) NetworkOption { return Fuji case s == "Fuji Testnet": return Fuji - case s == "Granite": - return Granite case s == "Local Network": return Local case s == "Devnet" || strings.Contains(s, "Devnet"): @@ -104,7 +98,6 @@ type NetworkFlags struct { UseDevnet bool UseFuji bool UseMainnet bool - UseGranite bool Endpoint string ClusterName string } @@ -122,8 +115,6 @@ func AddNetworkFlagsToCmd(cmd *cobra.Command, networkFlags *NetworkFlags, addEnd case Fuji: cmd.Flags().BoolVarP(&networkFlags.UseFuji, "testnet", "t", false, "operate on testnet (alias to `fuji`)") cmd.Flags().BoolVarP(&networkFlags.UseFuji, "fuji", "f", false, "operate on fuji (alias to `testnet`") - case Granite: - cmd.Flags().BoolVar(&networkFlags.UseGranite, "granite", false, "operate on a granite devnet") case Mainnet: cmd.Flags().BoolVarP(&networkFlags.UseMainnet, "mainnet", "m", false, "operate on mainnet") case Cluster: @@ -145,8 +136,6 @@ func GetNetworkFlagsGroup(cmd *cobra.Command, networkFlags *NetworkFlags, addEnd switch networkOption { case Local: set.BoolVarP(&networkFlags.UseLocal, "local", "l", false, "operate on a local network") - case Granite: - set.BoolVar(&networkFlags.UseGranite, "granite", false, "operate on granite devnet") case Devnet: set.BoolVar(&networkFlags.UseDevnet, "devnet", false, "operate on a devnet network") addEndpoint = true @@ -287,7 +276,6 @@ func GetNetworkFromCmdLineFlags( Fuji: "--fuji/--testnet", Mainnet: "--mainnet", Cluster: "--cluster", - Granite: "--granite", } supportedNetworksFlags := strings.Join(sdkutils.Map(supportedNetworkOptions, func(n NetworkOption) string { return networkFlagsMap[n] }), ", ") // received option @@ -297,8 +285,6 @@ func GetNetworkFromCmdLineFlags( networkOption = Local case networkFlags.UseDevnet: networkOption = Devnet - case networkFlags.UseGranite: - networkOption = Granite case networkFlags.UseFuji: networkOption = Fuji case networkFlags.UseMainnet: @@ -313,8 +299,6 @@ func GetNetworkFromCmdLineFlags( networkOption = Fuji case constants.LocalAPIEndpoint: networkOption = Local - case constants.GraniteNetworkEndpoint: - networkOption = Granite default: networkOption = Devnet } @@ -338,7 +322,7 @@ func GetNetworkFromCmdLineFlags( return models.UndefinedNetwork, errMsg } // mutual exclusion - if !flags.EnsureMutuallyExclusive([]bool{networkFlags.UseLocal, networkFlags.UseDevnet, networkFlags.UseFuji, networkFlags.UseGranite, networkFlags.UseMainnet, networkFlags.ClusterName != ""}) { + if !flags.EnsureMutuallyExclusive([]bool{networkFlags.UseLocal, networkFlags.UseDevnet, networkFlags.UseFuji, networkFlags.UseMainnet, networkFlags.ClusterName != ""}) { return models.UndefinedNetwork, fmt.Errorf("network flags %s are mutually exclusive", supportedNetworksFlags) } @@ -426,8 +410,6 @@ func GetNetworkFromCmdLineFlags( switch networkOption { case Local: network = models.NewLocalNetwork() - case Granite: - network = models.NewGraniteNetwork() case Devnet: networkID := uint32(0) if networkFlags.Endpoint != "" { @@ -479,8 +461,6 @@ func NetworkToNetworkFlags(network models.Network) NetworkFlags { flags.UseFuji = true case models.Mainnet: flags.UseMainnet = true - case models.Granite: - flags.UseGranite = true } return flags diff --git a/pkg/networkoptions/network_options_test.go b/pkg/networkoptions/network_options_test.go index da1aa465a..88b770178 100644 --- a/pkg/networkoptions/network_options_test.go +++ b/pkg/networkoptions/network_options_test.go @@ -6,7 +6,7 @@ import ( "testing" "github.com/ava-labs/avalanche-cli/pkg/models" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNetworkToNetworkFlags(t *testing.T) { @@ -28,8 +28,7 @@ func TestNetworkToNetworkFlags(t *testing.T) { UseDevnet: false, UseFuji: false, UseMainnet: false, - UseGranite: false, - Endpoint: "http://127.0.0.1:9650", + Endpoint: "", ClusterName: "", }, }, @@ -46,8 +45,7 @@ func TestNetworkToNetworkFlags(t *testing.T) { UseDevnet: false, UseFuji: true, UseMainnet: false, - UseGranite: false, - Endpoint: "https://api.avax-test.network", + Endpoint: "", ClusterName: "", }, }, @@ -64,8 +62,7 @@ func TestNetworkToNetworkFlags(t *testing.T) { UseDevnet: false, UseFuji: false, UseMainnet: true, - UseGranite: false, - Endpoint: "https://api.avax.network", + Endpoint: "", ClusterName: "", }, }, @@ -82,26 +79,7 @@ func TestNetworkToNetworkFlags(t *testing.T) { UseDevnet: true, UseFuji: false, UseMainnet: false, - UseGranite: false, - Endpoint: "https://custom-devnet.example.com", - ClusterName: "", - }, - }, - { - name: "Granite Network", - network: models.Network{ - Kind: models.Granite, - ID: 76, - Endpoint: "https://granite.avax-dev.network", - ClusterName: "", - }, - expected: NetworkFlags{ - UseLocal: false, - UseDevnet: false, - UseFuji: false, - UseMainnet: false, - UseGranite: true, - Endpoint: "https://granite.avax-dev.network", + Endpoint: "", ClusterName: "", }, }, @@ -118,9 +96,8 @@ func TestNetworkToNetworkFlags(t *testing.T) { UseDevnet: true, UseFuji: false, UseMainnet: false, - UseGranite: false, - Endpoint: "https://cluster.example.com", - ClusterName: "my-cluster", + Endpoint: "", + ClusterName: "", }, }, { @@ -136,7 +113,6 @@ func TestNetworkToNetworkFlags(t *testing.T) { UseDevnet: false, UseFuji: false, UseMainnet: false, - UseGranite: false, Endpoint: "", ClusterName: "", }, @@ -146,7 +122,7 @@ func TestNetworkToNetworkFlags(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := NetworkToNetworkFlags(tt.network) - assert.Equal(t, tt.expected, result) + require.Equal(t, tt.expected, result) }) } } diff --git a/pkg/node/local.go b/pkg/node/local.go index bf34427ad..7b6ddc4ca 100644 --- a/pkg/node/local.go +++ b/pkg/node/local.go @@ -49,22 +49,6 @@ func setupAvalancheGo( return avalancheGoBinaryPath, err } -func GetGraniteConnectionSettings() localnet.ConnectionSettings { - networkID := constants.GraniteNetworkID - bootstrapIDs := constants.GraniteDevnetBootstrapNodeIDs - bootstrapIPs := constants.GraniteDevnetBootstrapIPs - genesis := constants.GraniteDevnetGenesisData - upgrade := constants.GraniteDevnetUpgradeData - - return localnet.ConnectionSettings{ - NetworkID: uint32(networkID), - Genesis: genesis, - Upgrade: upgrade, - BootstrapIDs: bootstrapIDs, - BootstrapIPs: bootstrapIPs, - } -} - func StartLocalNode( app *application.Avalanche, clusterName string, @@ -145,8 +129,8 @@ func StartLocalNode( nodeSettings, []ids.ID{}, network, - true, // Download DB - true, // Bootstrap + true, // Download DB + true, // Bootstrap setPublicIP, // Set Public IP ) if err != nil { diff --git a/pkg/signatureaggregator/signature-aggregator.go b/pkg/signatureaggregator/signature-aggregator.go index ccb612796..795954d30 100644 --- a/pkg/signatureaggregator/signature-aggregator.go +++ b/pkg/signatureaggregator/signature-aggregator.go @@ -352,6 +352,7 @@ func CreateSignatureAggregatorConfig(networkEndpoint string, apiPort, metricsPor ManuallyTrackedPeers: make([]*basecfg.PeerConfig, 0), APIPort: apiPort, MetricsPort: metricsPort, + MaxPChainLookback: signatureAggregatorConfig.DefaultMaxPChainLookback, } return config } @@ -398,6 +399,9 @@ func WriteSignatureAggregatorConfig(app *application.Avalanche, config *signatur config.LogLevel = existingConfig.LogLevel config.SignatureCacheSize = existingConfig.SignatureCacheSize config.AllowPrivateIPs = existingConfig.AllowPrivateIPs + if existingConfig.MaxPChainLookback > 0 { + config.MaxPChainLookback = existingConfig.MaxPChainLookback + } } // Marshal and write the config diff --git a/pkg/utils/common.go b/pkg/utils/common.go index a2fc7b930..806077e84 100644 --- a/pkg/utils/common.go +++ b/pkg/utils/common.go @@ -21,14 +21,20 @@ import ( "syscall" "time" + "connectrpc.com/connect" "github.com/ava-labs/avalanche-cli/pkg/constants" sdkutils "github.com/ava-labs/avalanche-tooling-sdk-go/utils" + "github.com/ava-labs/avalanchego/api/connectclient" "github.com/ava-labs/avalanchego/api/info" + pbproposervm "github.com/ava-labs/avalanchego/connectproto/pb/proposervm" + "github.com/ava-labs/avalanchego/connectproto/pb/proposervm/proposervmconnect" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/vms/platformvm" "github.com/ava-labs/avalanchego/vms/platformvm/txs" + "github.com/ava-labs/avalanchego/vms/proposervm" + "github.com/ava-labs/avalanchego/vms/proposervm/block" "github.com/ava-labs/subnet-evm/core" "github.com/aws/aws-sdk-go-v2/service/ec2/types" @@ -358,6 +364,51 @@ func GetChainID(endpoint string, chainName string) (ids.ID, error) { return client.GetBlockchainID(ctx, chainName) } +func GetProposedHeight(endpoint string, chainAlias string) (uint64, error) { + client := proposervm.NewJSONRPCClient(endpoint, chainAlias) + ctx, cancel := sdkutils.GetAPIContext() + defer cancel() + return client.GetProposedHeight(ctx) +} + +func GetCurrentEpoch(endpoint string, chainAlias string) (block.Epoch, error) { + client := proposervm.NewJSONRPCClient(endpoint, chainAlias) + ctx, cancel := sdkutils.GetAPIContext() + defer cancel() + return client.GetCurrentEpoch(ctx) +} + +func GetCurrentL1Epoch(rpcURL, chainAlias string) (block.Epoch, error) { + endpoint, err := url.Parse(rpcURL) + if err != nil { + return block.Epoch{}, fmt.Errorf("failed to parse rpc endpoint %w", err) + } + baseURL := fmt.Sprintf("%s://%s", endpoint.Scheme, endpoint.Host) + proposerClient := proposervmconnect.NewProposerVMClient( + connectclient.New(), + baseURL, + connect.WithInterceptors( + connectclient.SetRouteHeaderInterceptor{ + Route: []string{ + chainAlias, + proposervm.HTTPHeaderRoute, + }, + }, + ), + ) + ctx, cancel := sdkutils.GetAPIContext() + defer cancel() + response, err := proposerClient.GetCurrentEpoch(ctx, &connect.Request[pbproposervm.GetCurrentEpochRequest]{}) + if err != nil { + return block.Epoch{}, fmt.Errorf("failed to get current epoch ProposerVM %w", err) + } + return block.Epoch{ + StartTime: response.Msg.StartTime, + Number: response.Msg.Number, + PChainHeight: response.Msg.PChainHeight, + }, nil +} + func GetChainIDs(endpoint string, chainName string) (string, string, error) { pClient := platformvm.NewClient(endpoint) ctx, cancel := sdkutils.GetAPIContext() diff --git a/pkg/vm/additional_evm_prompts_test.go b/pkg/vm/additional_evm_prompts_test.go index bde4085f7..02421279e 100644 --- a/pkg/vm/additional_evm_prompts_test.go +++ b/pkg/vm/additional_evm_prompts_test.go @@ -18,8 +18,8 @@ import ( ) const ( - testSubnetEVMVersion074 = `{"subnet-evm": "v0.7.4"}` - testSubnetEVMVersion073 = `{"subnet-evm": "v0.7.3"}` + testSubnetEVMVersion074 = `{"rpc": 39, "subnet-evm": {"invalid network": {"latest-version": "v0.7.4", "minimum-version": "v0.6.0"}, "Local Network": {"latest-version": "v0.7.4", "minimum-version": "v0.6.0"}}, "avalanchego": {"invalid network": {"latest-version": "v1.13.0", "minimum-version": "v1.12.0"}, "Local Network": {"latest-version": "v1.13.0", "minimum-version": "v1.12.0"}}, "signature-aggregator": {"invalid network": {"latest-version": "v0.4.4", "minimum-version": "v0.4.0"}, "Local Network": {"latest-version": "v0.4.4", "minimum-version": "v0.4.0"}}}` + testSubnetEVMVersion073 = `{"rpc": 39, "subnet-evm": {"invalid network": {"latest-version": "v0.7.3", "minimum-version": "v0.6.0"}, "Local Network": {"latest-version": "v0.7.3", "minimum-version": "v0.6.0"}}, "avalanchego": {"invalid network": {"latest-version": "v1.13.0", "minimum-version": "v1.12.0"}, "Local Network": {"latest-version": "v1.13.0", "minimum-version": "v1.12.0"}}, "signature-aggregator": {"invalid network": {"latest-version": "v0.4.4", "minimum-version": "v0.4.0"}, "Local Network": {"latest-version": "v0.4.4", "minimum-version": "v0.4.0"}}}` ) func TestPromptPermissioning(t *testing.T) { @@ -637,7 +637,7 @@ func TestPromptUserForSubnetEVMVersion(t *testing.T) { }, mockDownloader: func(m *mocks.Downloader) { // Mock the dependency calls that happen before the prompt - depResponseJSON := `{"subnet-evm": "v0.7.4"}` + depResponseJSON := testSubnetEVMVersion074 m.On("DownloadWithCache", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Return([]byte(depResponseJSON), nil) m.On("GetLatestPreReleaseVersion", "ava-labs", "subnet-evm", "").Return("v0.7.5-rc1", nil) // Different from release to trigger 3 options }, @@ -863,7 +863,7 @@ func TestPromptSubnetEVMVersion(t *testing.T) { }, mockDownloader: func(m *mocks.Downloader) { // Mock GetLatestCLISupportedDependencyVersion - depResponseJSON := `{"subnet-evm": "v0.7.5"}` + depResponseJSON := `{"rpc": 39, "subnet-evm": {"invalid network": {"latest-version": "v0.7.5", "minimum-version": "v0.6.0"}, "Local Network": {"latest-version": "v0.7.5", "minimum-version": "v0.6.0"}}, "avalanchego": {"invalid network": {"latest-version": "v1.13.0", "minimum-version": "v1.12.0"}, "Local Network": {"latest-version": "v1.13.0", "minimum-version": "v1.12.0"}}, "signature-aggregator": {"invalid network": {"latest-version": "v0.4.4", "minimum-version": "v0.4.0"}, "Local Network": {"latest-version": "v0.4.4", "minimum-version": "v0.4.0"}}}` m.On("DownloadWithCache", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Return([]byte(depResponseJSON), nil) }, expectedError: "", diff --git a/tests/e2e/assets/linux/avalanchego b/tests/e2e/assets/linux/avalanchego index 5a91c3b04..bbf82cf03 100755 Binary files a/tests/e2e/assets/linux/avalanchego and b/tests/e2e/assets/linux/avalanchego differ diff --git a/tests/e2e/assets/mac/avalanchego b/tests/e2e/assets/mac/avalanchego index 942acd90e..e4dea7bc5 100755 Binary files a/tests/e2e/assets/mac/avalanchego and b/tests/e2e/assets/mac/avalanchego differ diff --git a/tests/e2e/commands/etna.go b/tests/e2e/commands/etna.go index 624be2375..fb8470f19 100644 --- a/tests/e2e/commands/etna.go +++ b/tests/e2e/commands/etna.go @@ -25,6 +25,9 @@ const ( const ( PoSString = "proof-of-stake" PoAString = "proof-of-authority" + // TODO: when mapping is compatible, remove these constants + GraniteFujiAvagoVersion = "v1.14.0-fuji" + GraniteFujiSubnetEVMVersion = "v0.8.0-fuji" ) func CreateEtnaSubnetEvmConfig( @@ -60,6 +63,7 @@ func CreateEtnaSubnetEvmConfig( "--evm-token=TOK", "--icm=false", "--"+constants.SkipUpdateFlag, + "--local", ) if rewardBasisPoints != "" { cmd.Args = append(cmd.Args, rewardBasisPoints) @@ -82,7 +86,8 @@ func CreateEtnaSubnetEvmConfig( mapper := utils.NewVersionMapper() mapping, err := utils.GetVersionMapping(mapper) gomega.Expect(err).Should(gomega.BeNil()) - return mapping[utils.LatestEVM2AvagoKey], mapping[utils.LatestAvago2EVMKey] + // TODO: when compatible, return mapping[utils.LatestEVM2AvagoKey], mapping[utils.LatestAvago2EVMKey] + return mapping[utils.LatestEVM2AvagoKey], GraniteFujiAvagoVersion } func CreateLocalEtnaNode( diff --git a/tests/e2e/commands/subnet.go b/tests/e2e/commands/subnet.go index 351538d1a..7b59c1d13 100644 --- a/tests/e2e/commands/subnet.go +++ b/tests/e2e/commands/subnet.go @@ -12,7 +12,6 @@ import ( "github.com/ava-labs/avalanche-cli/cmd" "github.com/ava-labs/avalanche-cli/pkg/constants" - "github.com/ava-labs/avalanche-cli/pkg/models" "github.com/ava-labs/avalanche-cli/tests/e2e/utils" "github.com/onsi/gomega" ) @@ -32,8 +31,9 @@ func CreateSubnetEvmConfigNonSOV(subnetName string, genesisPath string, icmEnabl mapping, err := utils.GetVersionMapping(mapper) gomega.Expect(err).Should(gomega.BeNil()) // let's use a SubnetEVM version which has a guaranteed compatible avago - CreateSubnetEvmConfigWithVersionNonSOV(subnetName, genesisPath, mapping[utils.LatestEVM2AvagoKey], icmEnabled) - return mapping[utils.LatestEVM2AvagoKey], mapping[utils.LatestAvago2EVMKey] + // TODO: when mapping is compatible, use mapping[utils.LatestEVM2AvagoKey] and return mapping[utils.LatestAvago2EVMKey] + CreateSubnetEvmConfigWithVersionNonSOV(subnetName, genesisPath, GraniteFujiSubnetEVMVersion, icmEnabled) + return mapping[utils.LatestEVM2AvagoKey], GraniteFujiAvagoVersion } func CreateSubnetEvmConfigSOV(subnetName string, genesisPath string) (string, string) { @@ -41,8 +41,9 @@ func CreateSubnetEvmConfigSOV(subnetName string, genesisPath string) (string, st mapping, err := utils.GetVersionMapping(mapper) gomega.Expect(err).Should(gomega.BeNil()) // let's use a SubnetEVM version which has a guaranteed compatible avago - CreateSubnetEvmConfigWithVersionSOV(subnetName, genesisPath, mapping[utils.LatestEVM2AvagoKey]) - return mapping[utils.LatestEVM2AvagoKey], mapping[utils.LatestAvago2EVMKey] + // TODO: when mapping is compatible, use mapping[utils.LatestEVM2AvagoKey] and return mapping[utils.LatestAvago2EVMKey] + CreateSubnetEvmConfigWithVersionSOV(subnetName, genesisPath, GraniteFujiSubnetEVMVersion) + return mapping[utils.LatestEVM2AvagoKey], GraniteFujiAvagoVersion } /* #nosec G204 */ @@ -67,6 +68,7 @@ func CreateSubnetEvmConfigWithVersionNonSOV(subnetName string, genesisPath strin icmFlag, "--evm-token", "TOK", + "--local", } if version == "" { cmdArgs = append(cmdArgs, "--latest") @@ -111,6 +113,7 @@ func CreateSubnetEvmConfigWithVersionSOV(subnetName string, genesisPath string, "--icm=false", "--evm-token", "TOK", + "--local", } if version == "" { cmdArgs = append(cmdArgs, "--latest") @@ -179,6 +182,7 @@ func CreateCustomVMConfigNonSOV(subnetName string, genesisPath string, vmPath st "--icm=false", "--evm-token", "TOK", + "--local", ) output, err := cmd.CombinedOutput() if err != nil { @@ -234,6 +238,7 @@ func CreateCustomVMConfigSOV(subnetName string, genesisPath string, vmPath strin "--icm=false", "--evm-token", "TOK", + "--local", ) output, err := cmd.CombinedOutput() if err != nil { @@ -1128,43 +1133,6 @@ func DescribeSubnet(subnetName string) (string, error) { return string(output), err } -/* #nosec G204 */ -func SimulateGetSubnetStatsFuji(subnetName, subnetID string) string { - // Check config does already exist: - // We want to run stats on an existing subnet - exists, err := utils.SubnetConfigExists(subnetName) - gomega.Expect(err).Should(gomega.BeNil()) - gomega.Expect(exists).Should(gomega.BeTrue()) - - // add the subnet ID to the `fuji` section so that the `stats` command - // can find it (as this is a simulation with a `local` network, - // it got written in to the `local` network section) - err = utils.AddSubnetIDToSidecar(subnetName, models.NewFujiNetwork(), subnetID) - gomega.Expect(err).Should(gomega.BeNil()) - // run stats - cmd := exec.Command( - CLIBinary, - SubnetCmd, - "stats", - subnetName, - "--fuji", - "--"+constants.SkipUpdateFlag, - ) - output, err := cmd.CombinedOutput() - var exitErr *exec.ExitError - if err != nil { - stderr := "" - if errors.As(err, &exitErr) { - stderr = string(exitErr.Stderr) - } - fmt.Println(string(output)) - fmt.Println(err) - fmt.Println(stderr) - } - gomega.Expect(exitErr).Should(gomega.BeNil()) - return string(output) -} - /* #nosec G204 */ func ListValidators(subnetName string, network string) (string, error) { // Create config diff --git a/tests/e2e/testcases/blockchain/convert/suite.go b/tests/e2e/testcases/blockchain/convert/suite.go index 962c93ab5..0946720b9 100644 --- a/tests/e2e/testcases/blockchain/convert/suite.go +++ b/tests/e2e/testcases/blockchain/convert/suite.go @@ -49,6 +49,7 @@ var _ = ginkgo.Describe("[Blockchain Convert]", ginkgo.Ordered, func() { "icm": false, "skip-update-check": true, "genesis": utils.SubnetEvmGenesisPoaPath, + "local": true, } _, err := utils.TestCommand(cmd.BlockchainCmd, "create", blockchainCmdArgs, nil, testFlags) gomega.Expect(err).Should(gomega.BeNil()) diff --git a/tests/e2e/testcases/packageman/suite.go b/tests/e2e/testcases/packageman/suite.go index 053cd54ba..56f55c50d 100644 --- a/tests/e2e/testcases/packageman/suite.go +++ b/tests/e2e/testcases/packageman/suite.go @@ -72,8 +72,9 @@ var _ = ginkgo.Describe("[Package Management]", ginkgo.Ordered, func() { }) ginkgo.It("can deploy a subnet with subnet-evm version SOV", func() { - evmVersion := binaryToVersion[utils.SoloSubnetEVMKey1] - avagoVersion := binaryToVersion[utils.SoloAvagoKey] + // TODO: when mapping is compatible, use binaryToVersion[utils.SoloSubnetEVMKey1] + evmVersion := commands.GraniteFujiSubnetEVMVersion + avagoVersion := commands.GraniteFujiAvagoVersion // remove subnet-evm if installed version detected if utils.CheckSubnetEVMExists(evmVersion) || utils.CheckAvalancheGoExists(avagoVersion) { @@ -149,51 +150,6 @@ var _ = ginkgo.Describe("[Package Management]", ginkgo.Ordered, func() { commands.DeleteSubnetConfig(secondSubnetName) }) - ginkgo.It("can deploy multiple subnet-evm versions SOV", func() { - if utils.CheckSubnetEVMExists(binaryToVersion[utils.SoloSubnetEVMKey1]) || - utils.CheckSubnetEVMExists(binaryToVersion[utils.SoloSubnetEVMKey2]) { - _ = utils.DeleteBins() - } - - commands.CreateSubnetEvmConfigWithVersionSOV(subnetName, utils.SubnetEvmGenesisPoaPath, binaryToVersion[utils.SoloSubnetEVMKey1]) - commands.CreateSubnetEvmConfigWithVersionSOV(secondSubnetName, utils.SubnetEvmGenesisPoaPath, binaryToVersion[utils.SoloSubnetEVMKey2]) - - deployOutput := commands.DeploySubnetLocallySOV(subnetName) - rpcs1, err := utils.ParseRPCsFromOutput(deployOutput) - if err != nil { - fmt.Println(deployOutput) - } - gomega.Expect(err).Should(gomega.BeNil()) - gomega.Expect(rpcs1).Should(gomega.HaveLen(1)) - - deployOutput = commands.DeploySubnetLocallySOV(secondSubnetName) - rpcs2, err := utils.ParseRPCsFromOutput(deployOutput) - if err != nil { - fmt.Println(deployOutput) - } - gomega.Expect(err).Should(gomega.BeNil()) - gomega.Expect(rpcs2).Should(gomega.HaveLen(1)) - - err = utils.SetHardhatRPC(rpcs1[0]) - gomega.Expect(err).Should(gomega.BeNil()) - - err = utils.RunHardhatTests(utils.BaseTest) - gomega.Expect(err).Should(gomega.BeNil()) - - err = utils.SetHardhatRPC(rpcs2[0]) - gomega.Expect(err).Should(gomega.BeNil()) - - err = utils.RunHardhatTests(utils.BaseTest) - gomega.Expect(err).Should(gomega.BeNil()) - - // check subnet-evm install - gomega.Expect(utils.CheckSubnetEVMExists(binaryToVersion[utils.SoloSubnetEVMKey1])).Should(gomega.BeTrue()) - gomega.Expect(utils.CheckSubnetEVMExists(binaryToVersion[utils.SoloSubnetEVMKey2])).Should(gomega.BeTrue()) - - commands.DeleteSubnetConfig(subnetName) - commands.DeleteSubnetConfig(secondSubnetName) - }) - ginkgo.It("can deploy with multiple avalanchego versions non SOV", func() { if binaryToVersion[utils.MultiAvago1Key] == binaryToVersion[utils.MultiAvago2Key] { ginkgo.Skip("this needs two different rpc-compatible avalanchego to be available") diff --git a/tests/e2e/testcases/relayer/deploy/suite.go b/tests/e2e/testcases/relayer/deploy/suite.go index 37d13f92f..5731df427 100644 --- a/tests/e2e/testcases/relayer/deploy/suite.go +++ b/tests/e2e/testcases/relayer/deploy/suite.go @@ -452,67 +452,6 @@ var _ = ginkgo.Describe("[Relayer] deploy", func() { gomega.Expect(err).Should(gomega.BeNil()) }) - ginkgo.It("should deploy the relayer between subnet (sov) and subnet (non-sov) in both directions", func() { - commands.CreateSubnetEvmConfigNonSOV(subnetName, utils.SubnetEvmGenesisPath, false) - commands.DeploySubnetLocallyNonSOV(subnetName) - - // Deploy ICM contracts - _, err := commands.DeployICMContracts([]string{}, utils.TestFlags{ - "key": ewoqKeyName, - "blockchain": subnetName, - }) - gomega.Expect(err).Should(gomega.BeNil()) - - _, err = commands.DeployICMContracts([]string{}, utils.TestFlags{ - "key": ewoqKeyName, - "blockchain": subnet2Name, - }) - gomega.Expect(err).Should(gomega.BeNil()) - - // Deploy relayer - deployFlags := utils.TestFlags{ - "key": keyName, - "blockchains": fmt.Sprintf("%s,%s", subnetName, subnet2Name), - "amount": 10000, - "log-level": "info", - } - - deployArgs := []string{ - "deploy", - } - - output, err := utils.TestCommand(cmd.InterchainCmd, "relayer", deployArgs, utils.GlobalFlags{ - "local": true, - "skip-update-check": true, - }, deployFlags) - gomega.Expect(err).Should(gomega.BeNil()) - gomega.Expect(output).Should(gomega.ContainSubstring("Executing Relayer")) - - // Send message from subnet to subnet2 - _, err = commands.SendICMMessage( - []string{ - subnetName, - subnet2Name, - "hello world", - }, - utils.TestFlags{ - "key": ewoqKeyName, - }) - gomega.Expect(err).Should(gomega.BeNil()) - - // Send message from subnet2 to subnet - _, err = commands.SendICMMessage( - []string{ - subnet2Name, - subnetName, - "hello world", - }, - utils.TestFlags{ - "key": ewoqKeyName, - }) - gomega.Expect(err).Should(gomega.BeNil()) - }) - ginkgo.It("should deploy the relayer between subnet (sov), subnet (sov) and c-chain in all directions", func() { commands.CreateSubnetEvmConfigSOV(subnetName, utils.SubnetEvmGenesisPoaPath) commands.DeploySubnetLocallyNonSOV(subnetName) diff --git a/tests/e2e/testcases/subnet/non-sov/public/suite.go b/tests/e2e/testcases/subnet/non-sov/public/suite.go index 92252ac21..361ed0de9 100644 --- a/tests/e2e/testcases/subnet/non-sov/public/suite.go +++ b/tests/e2e/testcases/subnet/non-sov/public/suite.go @@ -160,15 +160,6 @@ var _ = ginkgo.Describe("[Public Subnet non SOV]", func() { // wait for subnet walidators to be up err = utils.WaitSubnetValidators(subnetID, nodeInfos) gomega.Expect(err).Should(gomega.BeNil()) - - // this is a simulation, so app is probably saving the info in the - // `local network` section of the sidecar instead of the `fuji` section... - // ...need to manipulate the `fuji` section of the sidecar to contain the subnetID info - // so that the `stats` command for `fuji` can find it - output := commands.SimulateGetSubnetStatsFuji(subnetName, subnetID) - gomega.Expect(output).Should(gomega.Not(gomega.BeNil())) - gomega.Expect(output).Should(gomega.ContainSubstring("Current validators")) - gomega.Expect(output).Should(gomega.ContainSubstring("NodeID-")) }) ginkgo.It("deploy subnet with new chain id", func() { diff --git a/tests/e2e/testcases/subnet/sov/etna/suite.go b/tests/e2e/testcases/subnet/sov/etna/suite.go index e8b97d680..b658c1bba 100644 --- a/tests/e2e/testcases/subnet/sov/etna/suite.go +++ b/tests/e2e/testcases/subnet/sov/etna/suite.go @@ -42,6 +42,7 @@ func createEtnaSubnetEvmConfig(poa, pos bool) string { "--evm-token=TOK", "--icm=false", "--" + constants.SkipUpdateFlag, + "--local", } if poa { cmdArgs = append(cmdArgs, "--proof-of-authority") @@ -62,12 +63,7 @@ func createEtnaSubnetEvmConfig(poa, pos bool) string { exists, err = utils.SubnetConfigExists(utils.BlockchainName) gomega.Expect(err).Should(gomega.BeNil()) gomega.Expect(exists).Should(gomega.BeTrue()) - - // return binary versions for this conf - mapper := utils.NewVersionMapper() - mapping, err := utils.GetVersionMapping(mapper) - gomega.Expect(err).Should(gomega.BeNil()) - return mapping[utils.LatestAvago2EVMKey] + return "v1.14.0-fuji" } func createEtnaSubnetEvmConfigWithoutProxyOwner(poa, pos bool) { @@ -88,6 +84,7 @@ func createEtnaSubnetEvmConfigWithoutProxyOwner(poa, pos bool) { "--evm-token=TOK", "--icm=false", "--" + constants.SkipUpdateFlag, + "--local", } if poa { cmdArgs = append(cmdArgs, "--proof-of-authority") @@ -130,6 +127,7 @@ func createEtnaSubnetEvmConfigValidatorManagerFlagKeyname(poa, pos bool) { "--evm-token=TOK", "--icm=false", "--" + constants.SkipUpdateFlag, + "--local", } if poa { cmdArgs = append(cmdArgs, "--proof-of-authority") @@ -172,6 +170,7 @@ func createEtnaSubnetEvmConfigValidatorManagerFlagPChain(poa, pos bool) { "--evm-token=TOK", "--icm=false", "--" + constants.SkipUpdateFlag, + "--local", } if poa { cmdArgs = append(cmdArgs, "--proof-of-authority")