Merge branch 'main' into sim/cli_descriptions

Author: ivpusic

authconfig/identity.go

@@ -0,0 +1,68 @@
+package authconfig
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"gopkg.in/yaml.v3"
+)
+
+// UserIdentity holds the cached identity resolved from the API key.
+type UserIdentity struct {
+	CustomerID string `yaml:"customer_id"`  // e.g. "user_123" or "team_456"
+	APIKeyHash string `yaml:"api_key_hash"` // SHA-256 of the API key for cache invalidation
+}
+
+// identityFileName is the file storing the cached user identity.
+const identityFileName = "user_identity.yaml"
+
+// LoadIdentity reads the cached user identity. Returns nil, nil if the file does not exist.
+func LoadIdentity() (*UserIdentity, error) {
+	dir, err := Dir()
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := os.ReadFile(filepath.Join(dir, identityFileName))
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	var id UserIdentity
+	if err := yaml.Unmarshal(data, &id); err != nil {
+		return nil, err
+	}
+	return &id, nil
+}
+
+// SaveIdentity writes the user identity cache to disk.
+func SaveIdentity(id *UserIdentity) error {
+	dir, err := Dir()
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return err
+	}
+
+	data, err := yaml.Marshal(id)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(filepath.Join(dir, identityFileName), data, 0o600)
+}
+
+// HashAPIKey returns the hex-encoded SHA-256 hash of an API key.
+func HashAPIKey(apiKey string) string {
+	h := sha256.Sum256([]byte(apiKey))
+	return fmt.Sprintf("%x", h)
+}

authconfig/identity_test.go

@@ -0,0 +1,38 @@
+package authconfig_test
+
+import (
+	"testing"
+
+	"github.com/duneanalytics/cli/authconfig"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSaveAndLoadIdentity(t *testing.T) {
+	setupTempDir(t)
+
+	want := &authconfig.UserIdentity{
+		CustomerID: "user_42",
+		APIKeyHash: authconfig.HashAPIKey("test-api-key"),
+	}
+	require.NoError(t, authconfig.SaveIdentity(want))
+
+	got, err := authconfig.LoadIdentity()
+	require.NoError(t, err)
+	assert.Equal(t, want, got)
+}
+
+func TestLoadIdentityNonExistent(t *testing.T) {
+	setupTempDir(t)
+
+	id, err := authconfig.LoadIdentity()
+	assert.NoError(t, err)
+	assert.Nil(t, id)
+}
+
+func TestHashAPIKeyDeterministic(t *testing.T) {
+	h1 := authconfig.HashAPIKey("my-key")
+	h2 := authconfig.HashAPIKey("my-key")
+	assert.Equal(t, h1, h2)
+	assert.NotEqual(t, h1, authconfig.HashAPIKey("other-key"))
+}

cli/root.go

@@ -22,6 +22,7 @@ import (
 	"github.com/duneanalytics/cli/cmd/query"
 	"github.com/duneanalytics/cli/cmd/sim"
 	"github.com/duneanalytics/cli/cmd/usage"
+	"github.com/duneanalytics/cli/cmd/whoami"
 	"github.com/duneanalytics/cli/cmdutil"
 	"github.com/duneanalytics/cli/tracking"
 )
@@ -77,6 +78,13 @@ var rootCmd = &cobra.Command{
 		client := dune.NewDuneClient(env)
 		cmdutil.SetClient(cmd, client)
 
+		// Resolve customer identity for analytics (best-effort, never blocks the CLI).
+		if tr := cmdutil.TrackerFromCmd(cmd); tr != nil {
+			if customerID := resolveCustomerID(client, env.APIKey); customerID != "" {
+				tr.SetUserID(customerID)
+			}
+		}
+
 		return nil
 	},
 	PersistentPostRunE: func(cmd *cobra.Command, _ []string) error {
@@ -93,7 +101,8 @@ var rootCmd = &cobra.Command{
 			commandPath = parts[1]
 		}
 
-		tr.Track(commandPath, tracking.StatusSuccess, "", durationMs)
+		isSim := strings.HasPrefix(commandPath, "sim")
+		tr.Track(commandPath, tracking.StatusSuccess, "", durationMs, isSim)
 		return nil
 	},
 }
@@ -107,6 +116,7 @@ func init() {
 	rootCmd.AddCommand(query.NewQueryCmd())
 	rootCmd.AddCommand(execution.NewExecutionCmd())
 	rootCmd.AddCommand(usage.NewUsageCmd())
+	rootCmd.AddCommand(whoami.NewWhoAmICmd())
 	rootCmd.AddCommand(sim.NewSimCmd())
 }
 
@@ -115,11 +125,9 @@ func Execute(version, commit, date, amplitudeKey string) {
 	versionStr := fmt.Sprintf("%s (commit: %s, built: %s)", version, commit, date)
 
 	telemetryEnabled := duneconfig.IsTelemetryEnabled()
-	configDir, _ := authconfig.Dir()
 	tracker := tracking.New(tracking.Config{
 		AmplitudeKey: amplitudeKey,
 		CLIVersion:   version,
-		ConfigDir:    configDir,
 		Enabled:      telemetryEnabled,
 	})
 	defer tracker.Shutdown()
@@ -132,7 +140,8 @@ func Execute(version, commit, date, amplitudeKey string) {
 	); err != nil {
 		// Build best-effort command path from os.Args (strip flags).
 		commandPath := commandPathFromArgs(os.Args)
-		tracker.Track(commandPath, tracking.StatusError, err.Error(), 0)
+		isSim := strings.HasPrefix(commandPath, "sim")
+		tracker.Track(commandPath, tracking.StatusError, err.Error(), 0, isSim)
 		// Flush the event before exiting — os.Exit does not run deferred funcs,
 		// so defer tracker.Shutdown() above would never fire.
 		tracker.Shutdown()
@@ -142,6 +151,34 @@ func Execute(version, commit, date, amplitudeKey string) {
 	}
 }
 
+// resolveCustomerID returns the customer_id associated with the given API key.
+// The customer_id may represent a user ("user_123") or a team ("team_456").
+// It uses a local cache to avoid calling /api/whoami on every invocation.
+// On any error it returns "" silently — analytics should never block the CLI.
+func resolveCustomerID(client dune.DuneClient, apiKey string) string {
+	keyHash := authconfig.HashAPIKey(apiKey)
+
+	// Try the cache first.
+	cached, err := authconfig.LoadIdentity()
+	if err == nil && cached != nil && cached.APIKeyHash == keyHash && cached.CustomerID != "" {
+		return cached.CustomerID
+	}
+
+	// Cache miss or stale — call the API.
+	resp, err := client.WhoAmI()
+	if err != nil || resp == nil || resp.CustomerID == "" {
+		return ""
+	}
+
+	// Persist for next time (best-effort).
+	_ = authconfig.SaveIdentity(&authconfig.UserIdentity{
+		CustomerID: resp.CustomerID,
+		APIKeyHash: keyHash,
+	})
+
+	return resp.CustomerID
+}
+
 // commandPathFromArgs extracts the subcommand path from os.Args, skipping
 // the binary name, flags, and flag values so the tracked path is e.g.
 // "query list" even when invoked as "dune --api-key KEY query list --limit 10".

cmd/sim/evm/defi_positions.go

@@ -65,64 +65,67 @@ type defiPositionsResponse struct {
 }
 
 type defiAggregations struct {
-	TotalUSDValue float64            `json:"total_usd_value"`
+	TotalValueUSD float64            `json:"total_value_usd"`
 	TotalByChain  map[string]float64 `json:"total_by_chain,omitempty"`
 }
 
-// defiPosition is a flat struct matching the polymorphic DefiPosition schema.
+// defiTokenInfo represents a token object returned by the API with address,
+// name, symbol, and optional numeric fields depending on position type.
+type defiTokenInfo struct {
+	Address  string  `json:"address,omitempty"`
+	Name     string  `json:"name,omitempty"`
+	Symbol   string  `json:"symbol,omitempty"`
+	Decimals int     `json:"decimals,omitempty"`
+	Holdings float64 `json:"holdings,omitempty"`
+	PriceUSD float64 `json:"price_usd,omitempty"`
+}
+
+// nftTokenDetails holds per-token data inside an NFT concentrated-liquidity position.
+type nftTokenDetails struct {
+	PriceUSD float64 `json:"price_usd"`
+	Holdings float64 `json:"holdings,omitempty"`
+	Rewards  float64 `json:"rewards,omitempty"`
+}
+
+// defiPosition matches the polymorphic DefiPosition schema returned by the API.
 // Fields are optional depending on the `type` discriminator.
 type defiPosition struct {
-	Type    string  `json:"type"`
-	ChainID int64   `json:"chain_id"`
-	USDVal  float64 `json:"usd_value"`
-	Logo    *string `json:"logo,omitempty"`
+	Type     string  `json:"type"`
+	Chain    string  `json:"chain,omitempty"`
+	ChainID  int64   `json:"chain_id"`
+	ValueUSD float64 `json:"value_usd"`
+	Logo     *string `json:"logo,omitempty"`
 
 	// Erc4626 / Tokenized fields
-	TokenType               string `json:"token_type,omitempty"`
-	Token                   string `json:"token,omitempty"`
-	TokenName               string `json:"token_name,omitempty"`
-	TokenSymbol             string `json:"token_symbol,omitempty"`
-	UnderlyingToken         string `json:"underlying_token,omitempty"`
-	UnderlyingTokenName     string `json:"underlying_token_name,omitempty"`
-	UnderlyingTokenSymbol   string `json:"underlying_token_symbol,omitempty"`
-	UnderlyingTokenDecimals int    `json:"underlying_token_decimals,omitempty"`
+	TokenType       string         `json:"token_type,omitempty"`
+	Token           *defiTokenInfo `json:"token,omitempty"`
+	UnderlyingToken *defiTokenInfo `json:"underlying_token,omitempty"`
+	LendingPool     string         `json:"lending_pool,omitempty"`
 
 	// Erc4626 / Tokenized / UniswapV2 fields
-	CalculatedBalance float64 `json:"calculated_balance,omitempty"`
-	PriceInUSD        float64 `json:"price_in_usd,omitempty"`
+	Balance  float64 `json:"balance,omitempty"`
+	PriceUSD float64 `json:"price_usd,omitempty"`
 
 	// UniswapV2 / Nft / NftV4 fields
-	Protocol       string  `json:"protocol,omitempty"`
-	Pool           string  `json:"pool,omitempty"`
-	PoolID         []int   `json:"pool_id,omitempty"`
-	PoolManager    string  `json:"pool_manager,omitempty"`
-	Salt           []int   `json:"salt,omitempty"`
-	Token0         string  `json:"token0,omitempty"`
-	Token0Name     string  `json:"token0_name,omitempty"`
-	Token0Symbol   string  `json:"token0_symbol,omitempty"`
-	Token0Decimals int     `json:"token0_decimals,omitempty"`
-	Token1         string  `json:"token1,omitempty"`
-	Token1Name     string  `json:"token1_name,omitempty"`
-	Token1Symbol   string  `json:"token1_symbol,omitempty"`
-	Token1Decimals int     `json:"token1_decimals,omitempty"`
-	LPBalance      string  `json:"lp_balance,omitempty"`
-	Token0Price    float64 `json:"token0_price,omitempty"`
-	Token1Price    float64 `json:"token1_price,omitempty"`
+	Protocol    string         `json:"protocol,omitempty"`
+	Pool        string         `json:"pool,omitempty"`
+	PoolID      string         `json:"pool_id,omitempty"`
+	PoolManager string         `json:"pool_manager,omitempty"`
+	Salt        string         `json:"salt,omitempty"`
+	Token0      *defiTokenInfo `json:"token0,omitempty"`
+	Token1      *defiTokenInfo `json:"token1,omitempty"`
+	LPBalance   string         `json:"lp_balance,omitempty"`
 
 	// Nft / NftV4 concentrated liquidity positions
 	Positions []nftPositionDetails `json:"positions,omitempty"`
 }
 
 type nftPositionDetails struct {
-	TickLower      int     `json:"tick_lower"`
-	TickUpper      int     `json:"tick_upper"`
-	TokenID        string  `json:"token_id"`
-	Token0Price    float64 `json:"token0_price"`
-	Token0Holdings float64 `json:"token0_holdings,omitempty"`
-	Token0Rewards  float64 `json:"token0_rewards,omitempty"`
-	Token1Price    float64 `json:"token1_price"`
-	Token1Holdings float64 `json:"token1_holdings,omitempty"`
-	Token1Rewards  float64 `json:"token1_rewards,omitempty"`
+	TickLower int              `json:"tick_lower"`
+	TickUpper int              `json:"tick_upper"`
+	TokenID   string           `json:"token_id"`
+	Token0    *nftTokenDetails `json:"token0,omitempty"`
+	Token1    *nftTokenDetails `json:"token1,omitempty"`
 }
 
 func runDefiPositions(cmd *cobra.Command, args []string) error {
@@ -169,7 +172,7 @@ func runDefiPositions(cmd *cobra.Command, args []string) error {
 				p.Type,
 				fmt.Sprintf("%d", p.ChainID),
 				p.Protocol,
-				output.FormatUSD(p.USDVal),
+				output.FormatUSD(p.ValueUSD),
 				positionDetails(p),
 			}
 		}
@@ -184,18 +187,26 @@ func runDefiPositions(cmd *cobra.Command, args []string) error {
 
 // positionDetails returns a human-readable summary for a DeFi position,
 // varying by position type.
+// tokenSymbol safely extracts the symbol from a token info pointer.
+func tokenSymbol(t *defiTokenInfo) string {
+	if t == nil {
+		return ""
+	}
+	return t.Symbol
+}
+
 func positionDetails(p defiPosition) string {
 	switch p.Type {
 	case "Erc4626":
 		parts := []string{}
-		if p.TokenSymbol != "" {
-			parts = append(parts, p.TokenSymbol)
+		if sym := tokenSymbol(p.Token); sym != "" {
+			parts = append(parts, sym)
 		}
-		if p.UnderlyingTokenSymbol != "" {
-			parts = append(parts, fmt.Sprintf("-> %s", p.UnderlyingTokenSymbol))
+		if sym := tokenSymbol(p.UnderlyingToken); sym != "" {
+			parts = append(parts, fmt.Sprintf("-> %s", sym))
 		}
-		if p.CalculatedBalance != 0 {
-			parts = append(parts, fmt.Sprintf("bal=%.6g", p.CalculatedBalance))
+		if p.Balance != 0 {
+			parts = append(parts, fmt.Sprintf("bal=%.6g", p.Balance))
 		}
 		return strings.Join(parts, " ")
 
@@ -204,23 +215,23 @@ func positionDetails(p defiPosition) string {
 		if p.TokenType != "" {
 			parts = append(parts, p.TokenType)
 		}
-		if p.TokenSymbol != "" {
-			parts = append(parts, p.TokenSymbol)
+		if sym := tokenSymbol(p.Token); sym != "" {
+			parts = append(parts, sym)
 		}
-		if p.CalculatedBalance != 0 {
-			parts = append(parts, fmt.Sprintf("bal=%.6g", p.CalculatedBalance))
+		if p.Balance != 0 {
+			parts = append(parts, fmt.Sprintf("bal=%.6g", p.Balance))
 		}
 		return strings.Join(parts, " ")
 
 	case "UniswapV2":
-		pair := formatPair(p.Token0Symbol, p.Token1Symbol)
-		if p.CalculatedBalance != 0 {
-			return fmt.Sprintf("%s bal=%.6g", pair, p.CalculatedBalance)
+		pair := formatPair(tokenSymbol(p.Token0), tokenSymbol(p.Token1))
+		if p.Balance != 0 {
+			return fmt.Sprintf("%s bal=%.6g", pair, p.Balance)
 		}
 		return pair
 
 	case "Nft", "NftV4":
-		pair := formatPair(p.Token0Symbol, p.Token1Symbol)
+		pair := formatPair(tokenSymbol(p.Token0), tokenSymbol(p.Token1))
 		nPos := len(p.Positions)
 		if nPos == 1 {
 			return fmt.Sprintf("%s (1 position)", pair)
@@ -252,7 +263,7 @@ func printAggregations(w io.Writer, agg *defiAggregations) {
 		return
 	}
 
-	fmt.Fprintf(w, "\nTotal USD Value: %s\n", output.FormatUSD(agg.TotalUSDValue))
+	fmt.Fprintf(w, "\nTotal USD Value: %s\n", output.FormatUSD(agg.TotalValueUSD))
 
 	if len(agg.TotalByChain) > 0 {
 		fmt.Fprintln(w, "Breakdown by chain:")