fix: Format wasp-cli message in json

Author: howjmay

tools/cluster/cluster.go

@@ -83,7 +83,7 @@ func Retry(fn func() error, retries int) error {
 	return err
 }
 
-func New(name string, config *ClusterConfig, dataPath string, t *testing.T, log log.Logger, l1PacakgeID *iotago.PackageID) *Cluster {
+func New(name string, config *ClusterConfig, dataPath string, t *testing.T, log log.Logger, l1PackageID *iotago.PackageID) *Cluster {
 	if log == nil {
 		if t == nil {
 			panic("one of t or log must be set")
@@ -94,7 +94,7 @@ func New(name string, config *ClusterConfig, dataPath string, t *testing.T, log
 
 	config.setValidatorAddressIfNotSet() // privtangle prefix
 	for i := range config.Wasp {
-		config.Wasp[i].PackageID = l1PacakgeID
+		config.Wasp[i].PackageID = l1PackageID
 	}
 	client := config.L1Client()
 	return &Cluster{

tools/cluster/tests/wasp-cli_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/ecdsa"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"math/big"
@@ -23,6 +24,7 @@ import (
 	"github.com/iotaledger/wasp/v2/packages/testutil/testkey"
 	"github.com/iotaledger/wasp/v2/packages/vm/gas"
 	"github.com/iotaledger/wasp/v2/tools/cluster"
+	"github.com/iotaledger/wasp/v2/tools/wasp-cli/format"
 )
 
 func TestWaspAuth(t *testing.T) {
@@ -137,10 +139,10 @@ func TestZeroGasFee(t *testing.T) {
 	t.Run("deposit directly to EVM", func(t *testing.T) {
 		alternativeAddress := getAddressFromJSON(w.MustRun("wallet", "address", "--address-index=1", "--json"))
 		w.MustRun("wallet", "send-funds", alternativeAddress, "base|1000000")
-		outs := w.MustRun("wallet", "balance", "--address-index=1")
+		w.MustRun("wallet", "balance", "--address-index=1")
 		_, eth := newEthereumAccount()
 		w.MustRun("chain", "deposit", eth.String(), "base|1000000", "--node=0")
-		outs = w.MustRun("chain", "balance", eth.String(), "--node=0")
+		outs = w.MustRun("chain", "balance", eth.String(), "--node=0", "--json")
 		checkL2Balance(t, outs, 1000000)
 	})
 }
@@ -199,13 +201,27 @@ func checkL1BalanceJSON(t *testing.T, out []string, expected int) {
 
 func checkL2Balance(t *testing.T, out []string, expected int) {
 	t.Helper()
-	r := regexp.MustCompile(`.*(?i:base)\s*(?i:tokens)?:*\s*(\d+).*`).FindStringSubmatch(strings.Join(out, ""))
-	if r == nil {
-		panic("couldn't check balance")
+
+	rawOutput := strings.Join(out, "\n")
+
+	var balanceOutput format.ChainBalanceOutput
+	err := json.Unmarshal([]byte(rawOutput), &balanceOutput)
+	require.NoError(t, err, "Expected valid JSON output, got: %v", rawOutput)
+
+	// Find the base token in the coins array
+	var baseAmount int64
+	found := false
+	for _, coin := range balanceOutput.Coins {
+		if coin.Token == "base" {
+			baseAmount, err = strconv.ParseInt(coin.Amount, 10, 64)
+			require.NoError(t, err)
+			found = true
+			break
+		}
 	}
-	amount, err := strconv.Atoi(r[1])
-	require.NoError(t, err)
-	require.EqualValues(t, expected, amount)
+
+	require.True(t, found, "base token not found in balance output")
+	require.EqualValues(t, expected, baseAmount, "Expected base token balance to be %d, got %d", expected, baseAmount)
 }
 
 // getAddressFromJSON extracts the address from JSON output
@@ -283,25 +299,25 @@ func TestWaspCLIDeposit(t *testing.T) {
 	t.Run("deposit directly to EVM", func(t *testing.T) {
 		_, eth := newEthereumAccount()
 		w.MustRun("chain", "deposit", "base|1000000", "--node=0")
-		outs := w.MustRun("chain", "deposit", eth.String(), "base|10000", "--node=0", "--print-receipt")
-		outs = w.MustRun("chain", "balance", eth.String(), "--node=0")
+		w.MustRun("chain", "deposit", eth.String(), "base|10000", "--node=0", "--print-receipt")
+		outs = w.MustRun("chain", "balance", eth.String(), "--node=0", "--json")
 		checkL2Balance(t, outs, 10000)
 	})
 
 	t.Run("deposit to own account, then to EVM", func(t *testing.T) {
 		const depositAmount = int64(1_000_000)
 		w.MustRun("wallet", "request-funds", "--address-index=2")
-		outs = w.MustRun("chain", "deposit", "base|1000000", "--address-index=2", "--node=0", "--print-receipt")
+		outs = w.MustRun("chain", "deposit", "base|1000000", "--address-index=2", "--node=0", "--print-receipt", "--json")
 		l2GasFee := getL2GasFee(t, outs)
-		outs = w.MustRun("chain", "balance", "--address-index=2", "--node=0")
+		outs = w.MustRun("chain", "balance", "--address-index=2", "--node=0", "--json")
 		checkL2Balance(t, outs, int(depositAmount-l2GasFee))
-		outs := w.MustRun("wallet", "balance", "--address-index=2", "--json")
+		w.MustRun("wallet", "balance", "--address-index=2", "--json")
 		_, eth := newEthereumAccount()
-		outs = w.MustRun("chain", "deposit", eth.String(), "base|1000000", "--address-index=2", "--node=0", "--print-receipt")
+		outs = w.MustRun("chain", "deposit", eth.String(), "base|1000000", "--address-index=2", "--node=0", "--print-receipt", "--json")
 		l2GasFee = getL2GasFee(t, outs)
-		outs = w.MustRun("chain", "balance", eth.String(), "--node=0")
+		outs = w.MustRun("chain", "balance", eth.String(), "--node=0", "--json")
 		checkL2Balance(t, outs, 1000000) // receiver gets full amount
-		outs = w.MustRun("chain", "balance", "--address-index=2", "--node=0")
+		outs = w.MustRun("chain", "balance", "--address-index=2", "--node=0", "--json")
 		expectedL2Balance := int(depositAmount - l2GasFee - int64(minFee))
 		checkL2Balance(t, outs, expectedL2Balance)
 	})
@@ -383,18 +399,28 @@ func TestWaspCLIDeposit(t *testing.T) {
 }
 
 func getL2GasFee(t *testing.T, outs []string) int64 {
-	var err error
-	var l2GasFee int64
-	re := regexp.MustCompile(`Gas fee charged:\s*(\d+)`)
-
-	for _, line := range outs {
-		matches := re.FindStringSubmatch(line)
-		if len(matches) > 1 {
-			l2GasFee, err = strconv.ParseInt(matches[1], 10, 64)
-			require.NoError(t, err)
+	t.Helper()
+
+	rawOutput := strings.Join(outs, "\n")
+	decoder := json.NewDecoder(strings.NewReader(rawOutput))
+
+	for {
+		var receipt format.ChainReceiptOutput
+		if err := decoder.Decode(&receipt); err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+			require.FailNowf(t, "failed to decode CLI output", "error: %v\noutput:\n%s", err, rawOutput)
+		}
+		if receipt.Type != "chain_receipt" {
+			continue
 		}
+		l2GasFee, err := strconv.ParseInt(receipt.GasFeeCharged, 10, 64)
+		require.NoError(t, err)
+		return l2GasFee
 	}
-	return l2GasFee
+
+	panic("gas fee not found")
 }
 
 func findRequestIDInOutput(out []string) string {

tools/wasp-cli/chain/accounts.go

@@ -20,6 +20,7 @@ import (
 	"github.com/iotaledger/wasp/v2/packages/vm/core/governance"
 	"github.com/iotaledger/wasp/v2/tools/wasp-cli/cli/cliclients"
 	"github.com/iotaledger/wasp/v2/tools/wasp-cli/cli/config"
+	"github.com/iotaledger/wasp/v2/tools/wasp-cli/format"
 	"github.com/iotaledger/wasp/v2/tools/wasp-cli/log"
 	"github.com/iotaledger/wasp/v2/tools/wasp-cli/util"
 	"github.com/iotaledger/wasp/v2/tools/wasp-cli/waspcmd"
@@ -50,20 +51,25 @@ func initBalanceCmd() *cobra.Command {
 				return err
 			}
 
-			header := []string{"token", "amount"}
-			rows := make([][]string, len(balance.Coins)+1)
-
-			rows[0] = []string{"base", balance.BaseTokens}
-			for k, v := range balance.Coins {
+			coins := make([]format.ChainBalanceCoin, 0, len(balance.Coins)+1)
+			coins = append(coins, format.ChainBalanceCoin{
+				Token:  "base",
+				Amount: balance.BaseTokens,
+			})
+			for _, v := range balance.Coins {
 				if lo.Must(coin.IsBaseToken(v.CoinType)) {
 					continue
 				}
-
-				rows[k+1] = []string{v.CoinType, v.Balance}
+				coins = append(coins, format.ChainBalanceCoin{
+					Token:  v.CoinType,
+					Amount: v.Balance,
+				})
 			}
 
-			log.PrintTable(header, rows)
-			return nil
+			output := format.ChainBalanceOutput{
+				Coins: coins,
+			}
+			return format.FormatSuccess("chain_balance", output.ToMap())
 		},
 	}
 
@@ -226,7 +232,11 @@ func initDepositCmd() *cobra.Command {
 			}
 
 			if printReceipt {
-				log.Printf("L1 Gas Fee: %d\n", res.Effects.Data.GasFee())
+				if err := format.FormatSuccess("l1_gas_fee", map[string]interface{}{
+					"amount": res.Effects.Data.GasFee(),
+				}); err != nil {
+					return err
+				}
 				ref, err := res.GetCreatedObjectByName("request", "Request")
 				if err != nil {
 					return err

tools/wasp-cli/chain/blocklog.go

@@ -105,7 +105,7 @@ func logRequestsInBlock(ctx context.Context, client *apiclient.APIClient, index
 
 	for i, receipt := range receipts {
 		r := receipt
-		util.LogReceipt(r, i)
+		util.LogReceipt(r, i) //nolint:contextcheck
 	}
 	return nil
 }

tools/wasp-cli/format/glazed_formatter.go

@@ -140,6 +140,7 @@ func wrapText(text string, width int) []string {
 }
 
 // formatTable outputs data as a table using glazed with proper output handling
+// context.Background() is acceptable here for table formatting
 func (gf *GlazedFormatter) formatTable(data map[string]interface{}) error {
 	ctx := context.Background()
 

tools/wasp-cli/format/output_structs.go

@@ -0,0 +1,84 @@
+package format
+
+import "github.com/iotaledger/wasp/v2/tools/wasp-cli/log"
+
+// ChainReceiptAsset mirrors the asset snippet included in chain receipt logs.
+type ChainReceiptAsset struct {
+	CoinType string `json:"coin_type"`
+	Balance  string `json:"balance"`
+}
+
+// ChainReceiptOutput documents the JSON payload emitted when a chain receipt is logged.
+//
+// It contains both the formatter metadata (type/status/timestamp) and the receipt-specific
+// fields so other packages (tests, tooling) can unmarshal CLI output without relying on
+// map[string]interface{}.
+type ChainReceiptOutput struct {
+	Type               string              `json:"type,omitempty"`
+	Status             string              `json:"status,omitempty"`
+	Timestamp          string              `json:"timestamp,omitempty"`
+	RequestID          string              `json:"request_id"`
+	Kind               string              `json:"kind"`
+	Sender             string              `json:"sender"`
+	ContractHName      string              `json:"contract_hname"`
+	FunctionHName      string              `json:"function_hname"`
+	ParamsHex          []string            `json:"params_hex"`
+	ArgumentsRaw       interface{}         `json:"arguments_raw"`
+	DecodedKnownParams []log.TreeItem      `json:"decoded_known_params"`
+	Error              string              `json:"error"`
+	GasBudget          string              `json:"gas_budget"`
+	GasBurned          string              `json:"gas_burned"`
+	GasFeeCharged      string              `json:"gas_fee_charged"`
+	StorageDeposit     string              `json:"storage_deposit"`
+	Assets             []ChainReceiptAsset `json:"assets"`
+	Index              *int                `json:"index,omitempty"`
+}
+
+// ToMap converts the struct into the map representation expected by FormatSuccess.
+func (c ChainReceiptOutput) ToMap() map[string]interface{} {
+	data := map[string]interface{}{
+		"request_id":           c.RequestID,
+		"kind":                 c.Kind,
+		"sender":               c.Sender,
+		"contract_hname":       c.ContractHName,
+		"function_hname":       c.FunctionHName,
+		"params_hex":           c.ParamsHex,
+		"arguments_raw":        c.ArgumentsRaw,
+		"decoded_known_params": c.DecodedKnownParams,
+		"error":                c.Error,
+		"gas_budget":           c.GasBudget,
+		"gas_burned":           c.GasBurned,
+		"gas_fee_charged":      c.GasFeeCharged,
+		"storage_deposit":      c.StorageDeposit,
+		"assets":               c.Assets,
+	}
+	if c.Index != nil {
+		data["index"] = *c.Index
+	}
+	return data
+}
+
+// ChainBalanceCoin represents a single coin balance entry.
+type ChainBalanceCoin struct {
+	Token  string `json:"token"`
+	Amount string `json:"amount"`
+}
+
+// ChainBalanceOutput documents the JSON payload emitted when a chain balance is logged.
+//
+// It contains both the formatter metadata (type/status/timestamp) and the balance-specific
+// fields so other packages (tests, tooling) can unmarshal CLI output without relying on
+// map[string]interface{}.
+type ChainBalanceOutput struct {
+	Type      string             `json:"type,omitempty"`
+	Status    string             `json:"status,omitempty"`
+	Timestamp string             `json:"timestamp,omitempty"`
+	Coins     []ChainBalanceCoin `json:"coins"`
+}
+
+// ToMap converts the struct into the map representation expected by FormatSuccess.
+func (c ChainBalanceOutput) ToMap() map[string]interface{} {
+	return map[string]interface{}{
+		"coins": c.Coins,
+	}
+}