Khalil/6959 Recover Epoch transaction args script

cmd/bootstrap/cmd/check_machine_account.go

@@ -13,6 +13,7 @@ import (
 	sdk "github.com/onflow/flow-go-sdk"
 	client "github.com/onflow/flow-go-sdk/access/grpc"
 	"github.com/onflow/flow-go/cmd"
+	"github.com/onflow/flow-go/cmd/util/cmd/common"
 	model "github.com/onflow/flow-go/model/bootstrap"
 	"github.com/onflow/flow-go/module/epochs"
 )
@@ -44,7 +45,10 @@ func checkMachineAccountRun(_ *cobra.Command, _ []string) {
 
 	// read the private node information - used to get the role
 	var nodeInfoPriv model.NodeInfoPriv
-	readJSON(filepath.Join(flagOutdir, fmt.Sprintf(model.PathNodeInfoPriv, nodeID)), &nodeInfoPriv)
+	err = common.ReadJSON(filepath.Join(flagOutdir, fmt.Sprintf(model.PathNodeInfoPriv, nodeID)), &nodeInfoPriv)
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to read json")
+	}
 
 	// read the machine account info file
 	machineAccountInfo := readMachineAccountInfo(nodeID)
@@ -97,7 +101,10 @@ func readMachineAccountInfo(nodeID string) model.NodeMachineAccountInfo {
 	var machineAccountInfo model.NodeMachineAccountInfo
 
 	path := filepath.Join(flagOutdir, fmt.Sprintf(model.PathNodeMachineAccountInfoPriv, nodeID))
-	readJSON(path, &machineAccountInfo)
+	err := common.ReadJSON(path, &machineAccountInfo)
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to read json")
+	}
 
 	return machineAccountInfo
 }

cmd/bootstrap/cmd/db_encryption_key.go

@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/onflow/flow-go/cmd/bootstrap/utils"
+	"github.com/onflow/flow-go/cmd/util/cmd/common"
 	model "github.com/onflow/flow-go/model/bootstrap"
 )
 
@@ -35,7 +36,7 @@ func dbEncryptionKeyRun(_ *cobra.Command, _ []string) {
 	log = log.With().Str("path", dbEncryptionKeyPath).Logger()
 
 	// check if the key already exists
-	exists, err := pathExists(path.Join(flagOutdir, dbEncryptionKeyPath))
+	exists, err := common.PathExists(path.Join(flagOutdir, dbEncryptionKeyPath))
 	if err != nil {
 		log.Fatal().Err(err).Msg("could not check if db encryption key already exists")
 	}
@@ -50,5 +51,10 @@ func dbEncryptionKeyRun(_ *cobra.Command, _ []string) {
 	}
 	log.Info().Msg("generated db encryption key")
 
-	writeText(dbEncryptionKeyPath, dbEncryptionKey)
+	err = common.WriteText(dbEncryptionKeyPath, flagOutdir, dbEncryptionKey)
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to write file")
+	}
+
+	log.Info().Msgf("wrote file %v", dbEncryptionKeyPath)
 }

cmd/bootstrap/cmd/dkg.go

@@ -6,6 +6,7 @@ import (
 	"github.com/onflow/crypto"
 
 	bootstrapDKG "github.com/onflow/flow-go/cmd/bootstrap/dkg"
+	"github.com/onflow/flow-go/cmd/util/cmd/common"
 	model "github.com/onflow/flow-go/model/bootstrap"
 	"github.com/onflow/flow-go/model/dkg"
 	"github.com/onflow/flow-go/model/encodable"
@@ -38,17 +39,23 @@ func runBeaconKG(nodes []model.NodeInfo) dkg.DKGData {
 		encKey := encodable.RandomBeaconPrivKey{PrivateKey: privKey}
 		privKeyShares = append(privKeyShares, encKey)
 
-		writeJSON(fmt.Sprintf(model.PathRandomBeaconPriv, nodeID), encKey)
+		err = common.WriteJSON(fmt.Sprintf(model.PathRandomBeaconPriv, nodeID), flagOutdir, encKey)
+		if err != nil {
+			log.Fatal().Err(err).Msg("failed to write json")
+		}
 	}
 
 	// write full DKG info that will be used to construct QC
-	writeJSON(model.PathRootDKGData, inmem.EncodableFullDKG{
+	err = common.WriteJSON(model.PathRootDKGData, flagOutdir, inmem.EncodableFullDKG{
 		GroupKey: encodable.RandomBeaconPubKey{
 			PublicKey: dkgData.PubGroupKey,
 		},
 		PubKeyShares:  pubKeyShares,
 		PrivKeyShares: privKeyShares,
 	})
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to write json")
+	}
 
 	return dkgData
 }

cmd/bootstrap/cmd/final_list.go

@@ -4,6 +4,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/onflow/flow-go/cmd"
+	"github.com/onflow/flow-go/cmd/util/cmd/common"
 	model "github.com/onflow/flow-go/model/bootstrap"
 	"github.com/onflow/flow-go/model/flow"
 )
@@ -65,7 +66,10 @@ func finalList(cmd *cobra.Command, args []string) {
 	validateNodes(localNodes, registeredNodes)
 
 	// write node-config.json with the new list of nodes to be used for the `finalize` command
-	writeJSON(model.PathFinallist, model.ToPublicNodeInfoList(localNodes))
+	err := common.WriteJSON(model.PathFinallist, flagOutdir, model.ToPublicNodeInfoList(localNodes))
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to write json")
+	}
 }
 
 func validateNodes(localNodes []model.NodeInfo, registeredNodes []model.NodeInfo) {
@@ -229,16 +233,16 @@ func checkMismatchingNodes(localNodes []model.NodeInfo, registeredNodes []model.
 }
 
 func assembleInternalNodesWithoutWeight() []model.NodeInfo {
-	privInternals := readInternalNodes()
+	privInternals := common.ReadInternalNodes(log, flagInternalNodePrivInfoDir)
 	log.Info().Msgf("read %v internal private node-info files", len(privInternals))
 
 	var nodes []model.NodeInfo
 	for _, internal := range privInternals {
 		// check if address is valid format
-		validateAddressFormat(internal.Address)
+		common.ValidateAddressFormat(log, internal.Address)
 
 		// validate every single internal node
-		nodeID := validateNodeID(internal.NodeID)
+		nodeID := ValidateNodeID(internal.NodeID)
 		node := model.NewPrivateNodeInfo(
 			nodeID,
 			internal.Role,
@@ -255,26 +259,29 @@ func assembleInternalNodesWithoutWeight() []model.NodeInfo {
 }
 
 func assemblePartnerNodesWithoutWeight() []model.NodeInfo {
-	partners := readPartnerNodes()
+	partners := common.ReadPartnerNodes(log, flagPartnerNodeInfoDir)
 	log.Info().Msgf("read %v partner node configuration files", len(partners))
 	return createPublicNodeInfo(partners)
 }
 
 func readStakingContractDetails() []model.NodeInfo {
 	var stakingNodes []model.NodeInfoPub
-	readJSON(flagStakingNodesPath, &stakingNodes)
+	err := common.ReadJSON(flagStakingNodesPath, &stakingNodes)
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to read json")
+	}
 	return createPublicNodeInfo(stakingNodes)
 }
 
 func createPublicNodeInfo(nodes []model.NodeInfoPub) []model.NodeInfo {
 	var publicInfoNodes []model.NodeInfo
 	for _, n := range nodes {
-		validateAddressFormat(n.Address)
+		common.ValidateAddressFormat(log, n.Address)
 
 		// validate every single partner node
-		nodeID := validateNodeID(n.NodeID)
-		networkPubKey := validateNetworkPubKey(n.NetworkPubKey)
-		stakingPubKey := validateStakingPubKey(n.StakingPubKey)
+		nodeID := ValidateNodeID(n.NodeID)
+		networkPubKey := ValidateNetworkPubKey(n.NetworkPubKey)
+		stakingPubKey := ValidateStakingPubKey(n.StakingPubKey)
 
 		// all nodes should have equal weight
 		node := model.NewPublicNodeInfo(