Universal CLI

api/indexer/indexer.go

@@ -174,6 +174,7 @@ func (i *Indexer) storeTransactions(blk *chain.ExecutedBlock) error {
 			result.Units,
 			result.Fee,
 			result.Outputs,
+			string(result.Error),
 		); err != nil {
 			return err
 		}
@@ -190,6 +191,7 @@ func (*Indexer) storeTransaction(
 	units fees.Dimensions,
 	fee uint64,
 	outputs [][]byte,
+	errorStr string,
 ) error {
 	outputLength := consts.ByteLen // Single byte containing number of outputs
 	for _, output := range outputs {
@@ -206,19 +208,20 @@ func (*Indexer) storeTransaction(
 	for _, output := range outputs {
 		writer.PackBytes(output)
 	}
+	writer.PackString(errorStr)
 	if err := writer.Err(); err != nil {
 		return err
 	}
 	return batch.Put(txID[:], writer.Bytes())
 }
 
-func (i *Indexer) GetTransaction(txID ids.ID) (bool, int64, bool, fees.Dimensions, uint64, [][]byte, error) {
+func (i *Indexer) GetTransaction(txID ids.ID) (bool, int64, bool, fees.Dimensions, uint64, [][]byte, string, error) {
 	v, err := i.txDB.Get(txID[:])
 	if errors.Is(err, database.ErrNotFound) {
-		return false, 0, false, fees.Dimensions{}, 0, nil, nil
+		return false, 0, false, fees.Dimensions{}, 0, nil, "", nil
 	}
 	if err != nil {
-		return false, 0, false, fees.Dimensions{}, 0, nil, err
+		return false, 0, false, fees.Dimensions{}, 0, nil, "", err
 	}
 	reader := codec.NewReader(v, consts.NetworkSizeLimit)
 	timestamp := reader.UnpackUint64(true)
@@ -231,14 +234,15 @@ func (i *Indexer) GetTransaction(txID ids.ID) (bool, int64, bool, fees.Dimension
 	for i := range outputs {
 		outputs[i] = reader.UnpackLimitedBytes(consts.NetworkSizeLimit)
 	}
+	errorStr := reader.UnpackString(false)
 	if err := reader.Err(); err != nil {
-		return false, 0, false, fees.Dimensions{}, 0, nil, err
+		return false, 0, false, fees.Dimensions{}, 0, nil, "", err
 	}
 	dimensions, err := fees.UnpackDimensions(dimensionsBytes)
 	if err != nil {
-		return false, 0, false, fees.Dimensions{}, 0, nil, err
+		return false, 0, false, fees.Dimensions{}, 0, nil, "", err
 	}
-	return true, int64(timestamp), success, dimensions, fee, outputs, nil
+	return true, int64(timestamp), success, dimensions, fee, outputs, errorStr, nil
 }
 
 func (i *Indexer) Close() error {

api/indexer/server.go

@@ -111,6 +111,7 @@ type GetTxResponse struct {
 	Units     fees.Dimensions `json:"units"`
 	Fee       uint64          `json:"fee"`
 	Outputs   []codec.Bytes   `json:"result"`
+	ErrorStr  string          `json:"errorStr"`
 }
 
 type Server struct {
@@ -122,7 +123,7 @@ func (s *Server) GetTx(req *http.Request, args *GetTxRequest, reply *GetTxRespon
 	_, span := s.tracer.Start(req.Context(), "Indexer.GetTx")
 	defer span.End()
 
-	found, t, success, units, fee, outputs, err := s.indexer.GetTransaction(args.TxID)
+	found, t, success, units, fee, outputs, errorStr, err := s.indexer.GetTransaction(args.TxID)
 	if err != nil {
 		return err
 	}
@@ -139,5 +140,6 @@ func (s *Server) GetTx(req *http.Request, args *GetTxRequest, reply *GetTxRespon
 		wrappedOutputs[i] = codec.Bytes(output)
 	}
 	reply.Outputs = wrappedOutputs
+	reply.ErrorStr = errorStr
 	return nil
 }

cmd/hypersdk-cli/README.md

@@ -12,14 +12,20 @@ FIXME: Has to point to the commit with the latest update from main, or just `@ma
 
 ## Configuration
 
-The CLI stores configuration in `~/.hypersdk-cli/config.cfg`. This includes:
+The CLI stores configuration in `~/.hypersdk-cli/config.yaml`. This includes:
 - Private key
 - Endpoint URL
 
+Example setup for a local HyperSDK VM:
+```bash
+hypersdk-cli endpoint set --endpoint=http://localhost:9650/ext/bc/morpheusvm/ 
+hypersdk-cli key set --key=0x323b1d8f4eed5f0da9da93071b034f2dce9d2d22692c172f3cb252a64ddfafd01b057de320297c29ad0c1f589ea216869cf1938d88c9fbd70d6748323dbf2fa7
+```
+
 ## Global Flags
 
 - `--endpoint`: Override the default endpoint for a single command
-- `-o, --output`: Set output format (`human` or `json`)
+- `-o, --output`: Set output format (`text` or `json`)
 
 ## Commands
 

cmd/hypersdk-cli/actions.go

@@ -17,7 +17,7 @@ var actionsCmd = &cobra.Command{
 	Use:   "actions",
 	Short: "Print the list of actions available in the ABI",
 	RunE: func(cmd *cobra.Command, _ []string) error {
-		endpoint, err := getConfigValue(cmd, "endpoint")
+		endpoint, err := getConfigValue(cmd, "endpoint", true)
 		if err != nil {
 			return fmt.Errorf("failed to get endpoint: %w", err)
 		}

cmd/hypersdk-cli/address.go

@@ -15,7 +15,7 @@ var addressCmd = &cobra.Command{
 	Use:   "address",
 	Short: "Print current key address",
 	RunE: func(cmd *cobra.Command, _ []string) error {
-		keyString, err := getConfigValue(cmd, "key")
+		keyString, err := getConfigValue(cmd, "key", true)
 		if err != nil {
 			return fmt.Errorf("failed to get key: %w", err)
 		}

cmd/hypersdk-cli/config.go

@@ -12,12 +12,49 @@ import (
 	"strings"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 
 	"github.com/ava-labs/hypersdk/codec"
 )
 
+func init() {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Error getting home directory:", err)
+		os.Exit(1)
+	}
+
+	configDir := filepath.Join(homeDir, ".hypersdk-cli")
+	if err := os.MkdirAll(configDir, 0o755); err != nil {
+		fmt.Fprintln(os.Stderr, "Error creating config directory:", err)
+		os.Exit(1)
+	}
+
+	configFile := filepath.Join(configDir, "config.yaml")
+	if _, err := os.Stat(configFile); os.IsNotExist(err) {
+		if _, err := os.Create(configFile); err != nil {
+			fmt.Fprintln(os.Stderr, "Error creating config file:", err)
+			os.Exit(1)
+		}
+	}
+
+	// Set config name and paths
+	viper.SetConfigName("config")
+	viper.SetConfigType("yaml")
+	viper.AddConfigPath(configDir)
+
+	// Read config
+	if err := viper.ReadInConfig(); err != nil {
+		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
+			fmt.Fprintln(os.Stderr, "Error reading config:", err)
+			os.Exit(1)
+		}
+		// Config file not found; will be created when needed
+	}
+}
+
 func isJSONOutputRequested(cmd *cobra.Command) (bool, error) {
-	output, err := getConfigValue(cmd, "output")
+	output, err := getConfigValue(cmd, "output", false)
 	if err != nil {
 		return false, fmt.Errorf("failed to get output format: %w", err)
 	}
@@ -43,92 +80,35 @@ func printValue(cmd *cobra.Command, v fmt.Stringer) error {
 	}
 }
 
-func getConfigValue(cmd *cobra.Command, name string) (string, error) {
-	// Check if the value is among flags
-	if value, err := cmd.Flags().GetString(name); err == nil && value != "" {
+func getConfigValue(cmd *cobra.Command, key string, required bool) (string, error) {
+	// Check flags first
+	if value, err := cmd.Flags().GetString(key); err == nil && value != "" {
 		return value, nil
 	}
 
-	// If not in flags, check the config file
-	config, err := readConfig()
-	if err != nil {
-		return "", fmt.Errorf("failed to read config: %w", err)
-	}
-
-	if value, ok := config[name]; ok {
+	// Then check viper
+	if value := viper.GetString(key); value != "" {
 		return value, nil
 	}
 
-	return "", fmt.Errorf("value for %s not found", name)
-}
-
-func updateConfig(name, value string) error {
-	config, err := readConfig()
-	if err != nil {
-		return fmt.Errorf("failed to read config: %w", err)
+	if required {
+		return "", fmt.Errorf("required value for %s not found", key)
 	}
 
-	config[name] = value
-	return writeConfig(config)
+	return "", nil
 }
 
-func readConfig() (map[string]string, error) {
-	homeDir, err := os.UserHomeDir()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get home directory: %w", err)
-	}
-
-	configPath := filepath.Join(homeDir, ".hypersdk-cli", "config.cfg")
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return make(map[string]string), nil
-		}
-		return nil, fmt.Errorf("failed to read config file: %w", err)
-	}
-
-	config := make(map[string]string)
-	lines := strings.Split(string(data), "\n")
-	for _, line := range lines {
-		parts := strings.SplitN(line, "=", 2)
-		if len(parts) == 2 {
-			config[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
-		}
-	}
-
-	return config, nil
-}
-
-func writeConfig(config map[string]string) error {
-	homeDir, err := os.UserHomeDir()
-	if err != nil {
-		return fmt.Errorf("failed to get home directory: %w", err)
-	}
-
-	configDir := filepath.Join(homeDir, ".hypersdk-cli")
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
-		return fmt.Errorf("failed to create config directory: %w", err)
-	}
-
-	configPath := filepath.Join(configDir, "config.cfg")
-	var buf strings.Builder
-	for key, value := range config {
-		buf.WriteString(fmt.Sprintf("%s = %s\n", key, value))
-	}
-
-	if err := os.WriteFile(configPath, []byte(buf.String()), 0o600); err != nil {
-		return fmt.Errorf("failed to write config file: %w", err)
-	}
-
-	return nil
+func setConfigValue(key, value string) error {
+	viper.Set(key, value)
+	return viper.WriteConfig()
 }
 
-func decodeFileOrHex(whatever string) ([]byte, error) {
-	if decoded, err := codec.LoadHex(whatever, -1); err == nil {
+func decodeFileOrHex(fileNameOrHex string) ([]byte, error) {
+	if decoded, err := codec.LoadHex(fileNameOrHex, -1); err == nil {
 		return decoded, nil
 	}
 
-	if fileContents, err := os.ReadFile(whatever); err == nil {
+	if fileContents, err := os.ReadFile(fileNameOrHex); err == nil {
 		return fileContents, nil
 	}
 

cmd/hypersdk-cli/endpoint.go

@@ -13,7 +13,7 @@ var endpointCmd = &cobra.Command{
 	Use:   "endpoint",
 	Short: "Manage endpoint",
 	RunE: func(cmd *cobra.Command, _ []string) error {
-		endpoint, err := getConfigValue(cmd, "endpoint")
+		endpoint, err := getConfigValue(cmd, "endpoint", true)
 		if err != nil {
 			return fmt.Errorf("failed to get endpoint: %w", err)
 		}

cmd/hypersdk-cli/endpoint_set.go

@@ -4,14 +4,11 @@
 package main
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"log"
 
 	"github.com/spf13/cobra"
-
-	"github.com/ava-labs/hypersdk/api/jsonrpc"
 )
 
 var endpointSetCmd = &cobra.Command{
@@ -27,35 +24,22 @@ var endpointSetCmd = &cobra.Command{
 			return errors.New("endpoint is required")
 		}
 
-		if err := updateConfig("endpoint", endpoint); err != nil {
+		if err := setConfigValue("endpoint", endpoint); err != nil {
 			return fmt.Errorf("failed to update config: %w", err)
 		}
 
-		client := jsonrpc.NewJSONRPCClient(endpoint)
-		success, err := client.Ping(context.Background())
-		pingErr := ""
-		if err != nil {
-			pingErr = err.Error()
-		}
-
 		return printValue(cmd, endpointSetCmdResponse{
 			Endpoint: endpoint,
-			pingResponse: pingResponse{
-				PingSucceed: success,
-				PingError:   pingErr,
-			},
 		})
 	},
 }
 
 type endpointSetCmdResponse struct {
-	pingResponse
 	Endpoint string `json:"endpoint"`
 }
 
 func (r endpointSetCmdResponse) String() string {
-	pingStatus := r.pingResponse.String()
-	return fmt.Sprintf("Endpoint set to: %s\n%s", r.Endpoint, pingStatus)
+	return "Endpoint set to: " + r.Endpoint
 }
 
 func init() {

cmd/hypersdk-cli/key_set.go

@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"log"
 
 	"github.com/spf13/cobra"
 
@@ -31,10 +32,9 @@ var keySetCmd = &cobra.Command{
 	Use:   "set",
 	Short: "Set the private ED25519 key",
 	RunE: func(cmd *cobra.Command, _ []string) error {
-		// read directly from the flag instead of calling getConfigValue
 		keyString, err := cmd.Flags().GetString("key")
 		if err != nil {
-			return fmt.Errorf("failed to get key: %w", err)
+			return fmt.Errorf("failed to get key flag: %w", err)
 		}
 		if keyString == "" {
 			return errors.New("--key is required")
@@ -50,8 +50,8 @@ func checkAndSavePrivateKey(keyString string, cmd *cobra.Command) error {
 		return fmt.Errorf("failed to decode key: %w", err)
 	}
 
-	err = updateConfig("key", hex.EncodeToString(key[:]))
-	if err != nil {
+	// Use Viper to save the key
+	if err := setConfigValue("key", hex.EncodeToString(key[:])); err != nil {
 		return fmt.Errorf("failed to update config: %w", err)
 	}
 
@@ -88,4 +88,10 @@ func (r keySetCmdResponse) String() string {
 
 func init() {
 	keyCmd.AddCommand(keySetCmd, keyGenerateCmd)
+	keySetCmd.Flags().String("key", "", "Private key in hex format or path to file containing the key")
+
+	err := keySetCmd.MarkFlagRequired("key")
+	if err != nil {
+		log.Fatalf("failed to mark key flag as required: %s", err)
+	}
 }

cmd/hypersdk-cli/main.go

@@ -25,7 +25,7 @@ func Execute() {
 }
 
 func init() {
-	rootCmd.PersistentFlags().StringP("output", "o", "human", "Output format (human or json)")
+	rootCmd.PersistentFlags().StringP("output", "o", "text", "Output format (text or json)")
 	rootCmd.PersistentFlags().String("endpoint", "", "Override the default endpoint")
 	rootCmd.PersistentFlags().String("key", "", "Private ED25519 key as hex string")
 }