/api/wallet/encryption/key-struct

# Get encryption key structure
curl -X GET "http://localhost:8080/api/wallet/encryption/key-struct"

# Get with formatted output using jq
curl -s "http://localhost:8080/api/wallet/encryption/key-struct" | jq '.'

# Check encryption mode only
curl -s "http://localhost:8080/api/wallet/encryption/key-struct" | jq '.mode'

# Count unique serial numbers (detect fracked keys)
curl -s "http://localhost:8080/api/wallet/encryption/key-struct" \
  | jq '.key_struct | map(.serial_number) | unique | length'

# Show which coin is used per RAIDA
curl -s "http://localhost:8080/api/wallet/encryption/key-struct" \
  | jq '.key_struct[] | "RAIDA \(.raida_id): SN \(.serial_number), Denom \(.denomination)"'

# Example: Full diagnostic script
#!/bin/bash
echo "=== Encryption Key Diagnostic ==="
RESPONSE=$(curl -s "http://localhost:8080/api/wallet/encryption/key-struct")

MODE=$(echo "$RESPONSE" | jq -r '.mode')
echo "Mode: $MODE"

if [ "$MODE" = "fracked" ]; then
    echo "⚠️ WARNING: Encryption keys are fracked!"
    UNIQUE_COUNT=$(echo "$RESPONSE" | jq '.key_struct | map(.serial_number) | unique | length')
    echo "Using $UNIQUE_COUNT different coins"
    echo "Run: curl -X GET 'http://localhost:8080/api/program/fix-encryption'"
elif [ "$MODE" = "bank" ]; then
    echo "✓ Encryption keys are healthy"
    SN=$(echo "$RESPONSE" | jq -r '.key_struct[0].serial_number')
    echo "Using coin SN: $SN"
elif [ "$MODE" = "none" ]; then
    echo "✗ ERROR: No encryption keys available"
fi

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

const ApiHost = "http://localhost:8080"

type KeyStructItem struct {
    RaidaID      int    `json:"raida_id"`
    Denomination int    `json:"denomination"`
    SerialNumber int    `json:"serial_number"`
    AN           string `json:"an"`
}

type EncryptionKeyStructResponse struct {
    Status    string          `json:"status"`
    Operation string          `json:"operation"`
    Mode      string          `json:"mode"`
    Message   string          `json:"message"`
    KeyStruct []KeyStructItem `json:"key_struct"`
}

func getEncryptionKeyStruct() (*EncryptionKeyStructResponse, error) {
    resp, err := http.Get(fmt.Sprintf("%s/api/wallet/encryption/key-struct", ApiHost))
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("read failed: %w", err)
    }

    var result EncryptionKeyStructResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, fmt.Errorf("JSON parse failed: %w", err)
    }

    return &result, nil
}

func analyzeEncryptionKeys(result *EncryptionKeyStructResponse) {
    fmt.Printf("Encryption Mode: %s\n", result.Mode)
    fmt.Printf("Message: %s\n", result.Message)

    switch result.Mode {
    case "fracked":
        fmt.Println("⚠️ WARNING: Encryption keys are fracked!")

        // Count unique serial numbers
        uniqueSNs := make(map[int]bool)
        for _, item := range result.KeyStruct {
            uniqueSNs[item.SerialNumber] = true
        }
        fmt.Printf("Using %d different coins for encryption\n", len(uniqueSNs))

        // Show breakdown per RAIDA
        fmt.Println("\nRAIDA Breakdown:")
        for _, item := range result.KeyStruct {
            fmt.Printf("  RAIDA %2d: SN %d, Denom %d, AN %s...\n",
                item.RaidaID,
                item.SerialNumber,
                item.Denomination,
                item.AN[:16])
        }

        fmt.Println("\n💡 Run /api/program/fix-encryption to consolidate keys")

    case "bank":
        fmt.Println("✓ Encryption keys are healthy")
        coin := result.KeyStruct[0]
        fmt.Printf("Using coin SN %d, Denomination %d\n",
            coin.SerialNumber,
            coin.Denomination)

    case "none":
        fmt.Println("✗ ERROR: No encryption keys available")
        fmt.Println("Wallet has no coins - import coins to enable encryption")
    }
}

func main() {
    fmt.Println("Fetching encryption key structure...")

    result, err := getEncryptionKeyStruct()
    if err != nil {
        panic(err)
    }

    fmt.Println("\n=== Encryption Key Analysis ===")
    analyzeEncryptionKeys(result)

    // Optional: Save full structure to file for debugging
    if result.Mode == "fracked" {
        fmt.Println("\nSaving full key structure to key_struct.json...")
        jsonData, _ := json.MarshalIndent(result, "", "  ")
        if err := ioutil.WriteFile("key_struct.json", jsonData, 0644); err != nil {
            fmt.Printf("Warning: Failed to save file: %v\n", err)
        } else {
            fmt.Println("Saved to key_struct.json")
        }
    }
}