Fix wiz (#2946)

* fix sig agg

* update sig agg version

* sig agg changes

* sig agg changes

* sig agg changes

* fix CI issues

* bump go.mod deps

* start fixing e2e

* more lint fixes

* nit

* fix tmpnet runtime config initialization

Simplify avalanche-go binary path configuration by setting it on the
default runtime config instead of iterating through all nodes.
Also handle case where Process config might be nil.

* improve file operations and add db caching

- Add db cache directory creation and management
- Implement caching for avalanchego database downloads with 7-day TTL
- Refactor file copy operations to use streaming for memory efficiency
- Extract and expose archive extraction utilities for reuse
- Add proper error handling and logging for cache operations

* fix cached db file path extension

Add .tar.gz extension to cached database file path to ensure proper file type identification and handling.

* bump avalanchego dependency and simplify network ID retrieval

- Update avalanchego to v1.13.3-0.20250911181736-31dcd1ea2540
- Remove local avalanchego replace directive
- Simplify GetTmpNetNetworkID to use network.GetNetworkID() directly
- Remove unused GetTmpNetNodeNetworkID function

* add network ID migration for config files

Implements migration logic to set NetworkID in network config files when missing, using old tmpnet network ID retrieval logic for backward compatibility.

* refactor: reorganize ERC20 functionality and update test suite

Moved ERC20 implementation from pkg/ictt/erc20.go to new pkg/erc20/ package structure
and updated all references across commands and tests. Removed obsolete SOV public
subnet test suite and updated E2E test configurations accordingly.

* migrate blockchain configs from file-based to content-based storage

- Add migrateNodeBlockchainConfigs function to migration.go for converting file-based chain configs to ChainConfigContentKey
- Update tmpnet.go to use ChainConfigContentKey instead of ChainConfigDirKey for blockchain configurations
- Remove file-based blockchain config directory setup and operations
- Add cleanup of binary files in package manager test suite

* remove unused chain config copying in AddNodeToLocalCluster

Removes the manual copying of chain config files when adding a new node
to the local cluster, along with unused imports for filepath and dircopy.
The chain configuration is now handled through content-based storage.

Signed-off-by: Felipe Madero <felipe.madero@gmail.com>

* improve port management and fix import ordering

- Add dynamic port allocation for ICM relayer metrics to avoid conflicts
- Implement FindAvailablePort utility function for port discovery
- Fix import ordering in whitelist.go to follow Go conventions

Signed-off-by: Felipe Madero <felipe.madero@gmail.com>

* fix acp-support string formatting in test assertions

Update ContainSubstring calls to use proper string formatting for acp-support values in log file assertions.

* use main branchs of SDK + ANR

* fix wiz command for sovereign subnets and improve error handling

- Skip subnet validation for sovereign subnets in wiz command
- Add skipICMDeploy parameter to blockchain deploy
- Improve relayer host null checking in start/stop commands
- Update C-chain genesis generation for devnet
- Fix dependencies version lookup for devnet networks
- Remove unused validator weight validation
- Enhance docker build error messages

* fix nil pointer check in vmcAtL1 flag lookup

Handle case where flag lookup returns nil by checking for nil before accessing flag.Changed property.

* update Go version to 1.23.9 and simplify Docker base image

- Bump BuildEnvGolangVersion from 1.22.1 to 1.23.9 in constants
- Remove bullseye suffix from Docker golang base image in buildCustomVM script

---------

Signed-off-by: Felipe Madero <felipe.madero@gmail.com>
Co-authored-by: Raymond Sukanto <rsukanto@umich.edu>

Author: felipemadero

cmd/blockchaincmd/add_validator.go

@@ -61,7 +61,6 @@ var (
 	errNoSubnetID                       = errors.New("failed to find the subnet ID for this subnet, has it been deployed/created on this network?")
 	errMutuallyExclusiveDurationOptions = errors.New("--use-default-duration/--use-default-validator-params and --staking-period are mutually exclusive")
 	errMutuallyExclusiveStartOptions    = errors.New("--use-default-start-time/--use-default-validator-params and --start-time are mutually exclusive")
-	errMutuallyExclusiveWeightOptions   = errors.New("--use-default-validator-params and --weight are mutually exclusive")
 	ErrNotPermissionedSubnet            = errors.New("subnet is not permissioned")
 	clusterNameFlagValue                string
 	createLocalValidator                bool
@@ -757,9 +756,6 @@ func CallAddValidatorNonSOV(
 	if useDefaultStartTime && startTimeStr != "" {
 		return errMutuallyExclusiveStartOptions
 	}
-	if useDefaultWeight && weight != 0 {
-		return errMutuallyExclusiveWeightOptions
-	}
 
 	if outputTxPath != "" {
 		if utils.FileExists(outputTxPath) {

cmd/blockchaincmd/deploy.go

@@ -235,13 +235,15 @@ func CallDeploy(
 	useLedgerParam bool,
 	useEwoqParam bool,
 	sameControlKeyParam bool,
+	skipICMDeploy bool,
 ) error {
 	subnetOnly = subnetOnlyParam
 	globalNetworkFlags = networkFlags
 	sameControlKey = sameControlKeyParam
 	keyName = keyNameParam
 	useLedger = useLedgerParam
 	useEwoq = useEwoqParam
+	icmSpec.SkipICMDeploy = skipICMDeploy
 	return deployBlockchain(cmd, []string{blockchainName})
 }
 
@@ -869,7 +871,7 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 	if sidecar.Sovereign {
 		externalVmcDeploy := !vmcAtL1 || vmcChainFlags.Defined()
 
-		if flag := cmd.Flags().Lookup(vmcAtL1FlagName); flag != nil && !flag.Changed && !vmcChainFlags.Defined() {
+		if flag := cmd.Flags().Lookup(vmcAtL1FlagName); (flag == nil || !flag.Changed) && !vmcChainFlags.Defined() {
 			if network.Kind == models.Local {
 				externalVmcDeploy = false
 			} else {

cmd/interchaincmd/relayercmd/start.go

@@ -79,10 +79,14 @@ func CallStart(_ []string, flags StartFlags, network models.Network) error {
 		if err != nil {
 			return err
 		}
-		if err := ssh.RunSSHStartICMRelayerService(host); err != nil {
-			return err
+		if host != nil {
+			if err := ssh.RunSSHStartICMRelayerService(host); err != nil {
+				return err
+			}
+			ux.Logger.GreenCheckmarkToUser("Remote AWM Relayer on %s successfully started", host.GetCloudID())
+		} else {
+			ux.Logger.PrintToUser("No ICM relayer host found on cluster %s", network.ClusterName)
 		}
-		ux.Logger.GreenCheckmarkToUser("Remote AWM Relayer on %s successfully started", host.GetCloudID())
 	default:
 		if relayerIsUp, _, _, err := relayer.RelayerIsUp(
 			app.GetLocalRelayerRunPath(network.Kind),

cmd/interchaincmd/relayercmd/stop.go

@@ -67,10 +67,14 @@ func CallStop(_ []string, flags StopFlags, network models.Network) error {
 		if err != nil {
 			return err
 		}
-		if err := ssh.RunSSHStopICMRelayerService(host); err != nil {
-			return err
+		if host != nil {
+			if err := ssh.RunSSHStopICMRelayerService(host); err != nil {
+				return err
+			}
+			ux.Logger.GreenCheckmarkToUser("Remote AWM Relayer on %s successfully stopped", host.GetCloudID())
+		} else {
+			ux.Logger.PrintToUser("No ICM relayer host found on cluster %s", network.ClusterName)
 		}
-		ux.Logger.GreenCheckmarkToUser("Remote AWM Relayer on %s successfully stopped", host.GetCloudID())
 	default:
 		b, _, _, err := relayer.RelayerIsUp(
 			app.GetLocalRelayerRunPath(network.Kind),

cmd/nodecmd/create_devnet.go

@@ -25,14 +25,13 @@ import (
 	sdkutils "github.com/ava-labs/avalanche-tooling-sdk-go/utils"
 	"github.com/ava-labs/avalanchego/config"
 	avago_upgrade "github.com/ava-labs/avalanchego/upgrade"
-	avago_constants "github.com/ava-labs/avalanchego/utils/constants"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls/signer/localsigner"
 	"github.com/ava-labs/avalanchego/utils/formatting"
 	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/avalanchego/vms/platformvm/signer"
+	"github.com/ava-labs/libevm/common"
+	"github.com/ava-labs/libevm/core"
 	"github.com/ava-labs/subnet-evm/params"
-	"github.com/ava-labs/subnet-evm/params/extras"
-	subnetevmutils "github.com/ava-labs/subnet-evm/utils"
 
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
@@ -45,52 +44,28 @@ const (
 	defaultLocalCChainFundedAddress = "8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC"
 	defaultLocalCChainFundedBalance = "0x295BE96E64066972000000"
 	allocationCommonEthAddress      = "0xb3d82b1367d362de99ab59a658165aff520cbd4d"
+	defaultGasLimit                 = uint64(100_000_000) // Gas limit is arbitrary
 )
 
 //go:embed upgrade.json
 var upgradeBytes []byte
 
+var defaultFundedKeyCChainAmount = new(big.Int).Exp(big.NewInt(10), big.NewInt(30), nil)
+
 func generateCustomCchainGenesis() ([]byte, error) {
-	chainConfig := &params.ChainConfig{
-		ChainID:             big.NewInt(43112),
-		HomesteadBlock:      big.NewInt(0),
-		DAOForkBlock:        big.NewInt(0),
-		DAOForkSupport:      true,
-		EIP150Block:         big.NewInt(0),
-		EIP155Block:         big.NewInt(0),
-		EIP158Block:         big.NewInt(0),
-		ByzantiumBlock:      big.NewInt(0),
-		ConstantinopleBlock: big.NewInt(0),
-		PetersburgBlock:     big.NewInt(0),
-		IstanbulBlock:       big.NewInt(0),
-		MuirGlacierBlock:    big.NewInt(0),
-	}
-	agoUpgrade := avago_upgrade.GetConfig(avago_constants.LocalID)
-	params.GetExtra(chainConfig).NetworkUpgrades = extras.NetworkUpgrades{
-		SubnetEVMTimestamp: subnetevmutils.NewUint64(0),
-		DurangoTimestamp:   subnetevmutils.TimeToNewUint64(agoUpgrade.DurangoTime),
-		EtnaTimestamp:      subnetevmutils.TimeToNewUint64(agoUpgrade.EtnaTime),
-		FortunaTimestamp:   nil, // Fortuna is optional and has no effect on Subnet-EVM
-		GraniteTimestamp:   nil, // Granite is optional and has no effect on Subnet-EVM
+	cChainBalances := make(core.GenesisAlloc, 1)
+	cChainBalances[common.HexToAddress(defaultLocalCChainFundedAddress)] = core.GenesisAccount{
+		Balance: defaultFundedKeyCChainAmount,
 	}
-	cChainGenesisMap := map[string]interface{}{}
-	cChainGenesisMap["config"] = chainConfig
-	cChainGenesisMap["nonce"] = hexa0Str
-	cChainGenesisMap["timestamp"] = hexa0Str
-	cChainGenesisMap["extraData"] = "0x00"
-	cChainGenesisMap["gasLimit"] = "0x5f5e100"
-	cChainGenesisMap["difficulty"] = hexa0Str
-	cChainGenesisMap["mixHash"] = "0x0000000000000000000000000000000000000000000000000000000000000000"
-	cChainGenesisMap["coinbase"] = "0x0000000000000000000000000000000000000000"
-	cChainGenesisMap["alloc"] = map[string]interface{}{
-		defaultLocalCChainFundedAddress: map[string]interface{}{
-			"balance": defaultLocalCChainFundedBalance,
-		},
+	chainID := big.NewInt(43112)
+	cChainGenesis := &core.Genesis{
+		Config:     &params.ChainConfig{ChainID: chainID},            // The rest of the config is set in coreth on VM initialization
+		Difficulty: big.NewInt(0),                                    // Difficulty is a mandatory field
+		Timestamp:  uint64(avago_upgrade.InitiallyActiveTime.Unix()), // This time enables Avalanche upgrades by default
+		GasLimit:   defaultGasLimit,
+		Alloc:      cChainBalances,
 	}
-	cChainGenesisMap["number"] = hexa0Str
-	cChainGenesisMap["gasUsed"] = hexa0Str
-	cChainGenesisMap["parentHash"] = "0x0000000000000000000000000000000000000000000000000000000000000000"
-	return json.Marshal(cChainGenesisMap)
+	return json.Marshal(cChainGenesis)
 }
 
 func generateCustomGenesis(

cmd/nodecmd/deploy.go

@@ -79,6 +79,7 @@ func deploySubnet(cmd *cobra.Command, args []string) error {
 	useLedgerParam := false
 	useEwoqParam := true
 	sameControlKey := true
+	skipICMDeploy := true
 
 	if err := blockchaincmd.CallDeploy(
 		cmd,
@@ -89,6 +90,7 @@ func deploySubnet(cmd *cobra.Command, args []string) error {
 		useLedgerParam,
 		useEwoqParam,
 		sameControlKey,
+		skipICMDeploy,
 	); err != nil {
 		return err
 	}

cmd/nodecmd/wiz.go

@@ -103,7 +103,7 @@ The node wiz command creates a devnet and deploys, sync and validate a subnet in
 	cmd.Flags().StringVar(&cmdLineGCPProjectName, "gcp-project", "", "use given GCP project")
 	cmd.Flags().StringVar(&cmdLineAlternativeKeyPairName, "alternative-key-pair-name", "", "key pair name to use if default one generates conflicts")
 	cmd.Flags().StringVar(&awsProfile, "aws-profile", constants.AWSDefaultCredential, "aws profile to use")
-	cmd.Flags().BoolVar(&defaultValidatorParams, "default-validator-params", false, "use default weight/start/duration params for subnet validator")
+	cmd.Flags().BoolVar(&defaultValidatorParams, "default-validator-params", true, "use default weight/start/duration params for subnet validator")
 	cmd.Flags().BoolVar(&forceSubnetCreate, "force-subnet-create", false, "overwrite the existing subnet configuration if one exists")
 	cmd.Flags().StringVar(&subnetGenesisFile, "subnet-genesis", "", "file path of the subnet genesis")
 	cmd.Flags().BoolVar(&icmReady, "teleporter", false, "generate an icm-ready vm")
@@ -290,20 +290,23 @@ func wiz(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	ux.Logger.PrintToUser("")
-	ux.Logger.PrintToUser("%s", logging.Green.Wrap("Adding nodes as subnet validators"))
-	ux.Logger.PrintToUser("")
-	avoidSubnetValidationChecks = true
-	useEwoq = true
-	if err := validateSubnet(cmd, []string{clusterName, subnetName}); err != nil {
+	sc, err := app.LoadSidecar(subnetName)
+	if err != nil {
 		return err
 	}
 
-	network, err := app.GetClusterNetwork(clusterName)
-	if err != nil {
-		return err
+	if !sc.Sovereign {
+		ux.Logger.PrintToUser("")
+		ux.Logger.PrintToUser("%s", logging.Green.Wrap("Adding nodes as subnet validators"))
+		ux.Logger.PrintToUser("")
+		avoidSubnetValidationChecks = true
+		useEwoq = true
+		if err := validateSubnet(cmd, []string{clusterName, subnetName}); err != nil {
+			return err
+		}
 	}
-	sc, err := app.LoadSidecar(subnetName)
+
+	network, err := app.GetClusterNetwork(clusterName)
 	if err != nil {
 		return err
 	}
@@ -312,11 +315,13 @@ func wiz(cmd *cobra.Command, args []string) error {
 		return constants.ErrNoSubnetID
 	}
 
-	ux.Logger.PrintToUser("")
-	ux.Logger.PrintToUser("%s", logging.Green.Wrap("Waiting for nodes to be validating the subnet"))
-	ux.Logger.PrintToUser("")
-	if err := waitForSubnetValidators(network, clusterName, subnetID, validateCheckTimeout, validateCheckPoolTime); err != nil {
-		return err
+	if !sc.Sovereign {
+		ux.Logger.PrintToUser("")
+		ux.Logger.PrintToUser("%s", logging.Green.Wrap("Waiting for nodes to be validating the subnet"))
+		ux.Logger.PrintToUser("")
+		if err := waitForSubnetValidators(network, clusterName, subnetID, validateCheckTimeout, validateCheckPoolTime); err != nil {
+			return err
+		}
 	}
 
 	isEVMGenesis, _, err := app.HasSubnetEVMGenesis(subnetName)
@@ -341,6 +346,7 @@ func wiz(cmd *cobra.Command, args []string) error {
 			if err != nil {
 				return err
 			}
+			relayerVersion = strings.Replace(relayerVersion, "icm-relayer-", "", 1)
 			if err := setICMRelayerHost(awmRelayerHost, relayerVersion); err != nil {
 				return err
 			}
@@ -356,15 +362,18 @@ func wiz(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	ux.Logger.PrintToUser("")
-	ux.Logger.PrintToUser("%s", logging.Green.Wrap("Setting the nodes as subnet trackers"))
-	ux.Logger.PrintToUser("")
-	if err := syncSubnet(cmd, []string{clusterName, subnetName}); err != nil {
-		return err
-	}
-	if err := node.WaitForHealthyCluster(app, clusterName, healthCheckTimeout, healthCheckPoolTime); err != nil {
-		return err
+	if !sc.Sovereign {
+		ux.Logger.PrintToUser("")
+		ux.Logger.PrintToUser("%s", logging.Green.Wrap("Setting the nodes as subnet trackers"))
+		ux.Logger.PrintToUser("")
+		if err := syncSubnet(cmd, []string{clusterName, subnetName}); err != nil {
+			return err
+		}
+		if err := node.WaitForHealthyCluster(app, clusterName, healthCheckTimeout, healthCheckPoolTime); err != nil {
+			return err
+		}
 	}
+
 	blockchainID := sc.Networks[network.Name()].BlockchainID
 	if blockchainID == ids.Empty {
 		return constants.ErrNoBlockchainID
@@ -376,30 +385,35 @@ func wiz(cmd *cobra.Command, args []string) error {
 			return err
 		}
 	}
-	if err := waitForClusterSubnetStatus(clusterName, subnetName, blockchainID, status.Validating, validateCheckTimeout, validateCheckPoolTime); err != nil {
-		return err
-	}
 
-	if b, err := hasICMDeploys(clusterName); err != nil {
-		return err
-	} else if b {
-		ux.Logger.PrintToUser("")
-		ux.Logger.PrintToUser("%s", logging.Green.Wrap("Updating Proposer VMs"))
-		ux.Logger.PrintToUser("")
-		if err := updateProposerVMs(network); err != nil {
-			// not going to consider fatal, as icm messaging will be working fine after a failed first msg
-			ux.Logger.PrintToUser(logging.Yellow.Wrap("failure setting proposer: %s"), err)
+	if !sc.Sovereign {
+		if err := waitForClusterSubnetStatus(clusterName, subnetName, blockchainID, status.Validating, validateCheckTimeout, validateCheckPoolTime); err != nil {
+			return err
+		}
+
+		if b, err := hasICMDeploys(clusterName); err != nil {
+			return err
+		} else if b {
+			ux.Logger.PrintToUser("")
+			ux.Logger.PrintToUser("%s", logging.Green.Wrap("Updating Proposer VMs"))
+			ux.Logger.PrintToUser("")
+			if err := updateProposerVMs(network); err != nil {
+				// not going to consider fatal, as icm messaging will be working fine after a failed first msg
+				ux.Logger.PrintToUser(logging.Yellow.Wrap("failure setting proposer: %s"), err)
+			}
 		}
 	}
 
 	if sc.TeleporterReady && sc.RunRelayer && isEVMGenesis {
 		ux.Logger.PrintToUser("")
 		ux.Logger.PrintToUser("%s", logging.Green.Wrap("Setting up ICM on subnet"))
 		ux.Logger.PrintToUser("")
+		chainSpec := contract.ChainSpec{
+			BlockchainName: subnetName,
+		}
+		chainSpec.SetEnabled(true, true, false, false, false)
 		flags := messengercmd.DeployFlags{
-			ChainFlags: contract.ChainSpec{
-				BlockchainName: subnetName,
-			},
+			ChainFlags: chainSpec,
 			PrivateKeyFlags: contract.PrivateKeyFlags{
 				KeyName: constants.ICMKeyName,
 			},
@@ -416,7 +430,7 @@ func wiz(cmd *cobra.Command, args []string) error {
 			RegistryBydecodePath:         icmRegistryBydecodePath,
 			IncludeCChain:                true,
 		}
-		if err := messengercmd.CallDeploy([]string{}, flags, models.UndefinedNetwork); err != nil {
+		if err := messengercmd.CallDeploy([]string{}, flags, network); err != nil {
 			return err
 		}
 		ux.Logger.PrintToUser("")

pkg/constants/constants.go

@@ -162,7 +162,7 @@ const (
 	AvalancheGoLokiPort                          = 23101
 	CloudServerStorageSize                       = 1000
 	MonitoringCloudServerStorageSize             = 50
-	BuildEnvGolangVersion                        = "1.22.1"
+	BuildEnvGolangVersion                        = "1.23.9"
 	AnsibleInventoryDir                          = "inventories"
 	AnsibleSSHShellParams                        = "-o IdentitiesOnly=yes -o StrictHostKeyChecking=no"
 	AnsibleSSHUseAgentParams                     = "-o StrictHostKeyChecking=no"

pkg/dependencies/dependencies.go

@@ -8,15 +8,13 @@ import (
 	"fmt"
 	"strconv"
 
+	"github.com/ava-labs/avalanche-cli/pkg/application"
+	"github.com/ava-labs/avalanche-cli/pkg/constants"
+	"github.com/ava-labs/avalanche-cli/pkg/models"
 	"github.com/ava-labs/avalanche-cli/pkg/subnet"
 	"github.com/ava-labs/avalanche-cli/pkg/ux"
 
 	"golang.org/x/mod/semver"
-
-	"github.com/ava-labs/avalanche-cli/pkg/models"
-
-	"github.com/ava-labs/avalanche-cli/pkg/application"
-	"github.com/ava-labs/avalanche-cli/pkg/constants"
 )
 
 var ErrNoAvagoVersion = errors.New("unable to find a compatible avalanchego version")
@@ -50,7 +48,11 @@ func GetLatestCLISupportedDependencyVersion(app *application.Avalanche, dependen
 				*rpcVersion,
 			)
 		}
-		return parsedDependency.AvalancheGo[network.Name()].LatestVersion, nil
+		depNetworkName := network.Name()
+		if network.Kind == models.Devnet {
+			depNetworkName = "DevNet"
+		}
+		return parsedDependency.AvalancheGo[depNetworkName].LatestVersion, nil
 	case constants.SubnetEVMRepoName:
 		return parsedDependency.SubnetEVM, nil
 	case constants.SignatureAggregatorRepoName:

pkg/docker/image.go

@@ -66,7 +66,7 @@ func BuildDockerImage(host *models.Host, image string, path string, dockerfile s
 	cmd := fmt.Sprintf("cd %s && docker build -q --build-arg GO_VERSION=%s -t %s -f %s .", path, goVersion, image, dockerfile)
 	_, err = host.Command(cmd, nil, constants.SSHLongRunningScriptTimeout)
 	if err != nil {
-		return fmt.Errorf("failed to build docker image %s: %w", image, err)
+		return fmt.Errorf("failed to build docker image %s with command '%s': %w", image, cmd, err)
 	}
 	return nil
 }