/api/tools/serial-numbers

# Get list of serial numbers from Bank folder (Windows path)
curl -X GET "http://localhost:8080/api/tools/serial-numbers?folder_path=C:/CloudCoin/Wallets/Default/Bank"

# Get list from Fracked folder (Linux path)
curl -X GET "http://localhost:8080/api/tools/serial-numbers?folder_path=/home/user/CloudCoin/Wallets/Default/Fracked"

# Pretty print with jq
curl -X GET "http://localhost:8080/api/tools/serial-numbers?folder_path=C:/CloudCoin/Wallets/Default/Bank" | jq '.'

# Get only serial numbers (extract just the serial_number field)
curl -X GET "http://localhost:8080/api/tools/serial-numbers?folder_path=C:/CloudCoin/Wallets/Default/Bank" \
  | jq '.coins[].serial_number'

# Find specific serial number
curl -X GET "http://localhost:8080/api/tools/serial-numbers?folder_path=C:/CloudCoin/Wallets/Default/Bank" \
  | jq '.coins[] | select(.serial_number == 1234567)'

# Count total coins
curl -X GET "http://localhost:8080/api/tools/serial-numbers?folder_path=C:/CloudCoin/Wallets/Default/Bank" \
  | jq '.total_coins'

package main

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

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

type Coin struct {
    SerialNumber int    `json:"serial_number"`
    Denomination int    `json:"denomination"`
    Filename     string `json:"filename"`
}

type ListResponse struct {
    Status     string `json:"status"`
    Operation  string `json:"operation"`
    FolderPath string `json:"folder_path"`
    Coins      []Coin `json:"coins"`
    TotalCoins int    `json:"total_coins"`
}

// Denomination code to value mapping
var denominationValues = map[int]float64{
    -8: 0.00000001, -7: 0.0000001, -1: 0.1,
    0: 1, 1: 5, 2: 25, 3: 100, 4: 250, 5: 1000,
    6: 5000, 7: 25000, 8: 100000, 9: 250000, 10: 1000000,
}

func main() {
    // Specify folder path
    folderPath := "C:/CloudCoin/Wallets/Default/Bank"

    // Build URL with query parameter
    apiUrl := fmt.Sprintf("%s/api/tools/serial-numbers?folder_path=%s",
        ApiHost, url.QueryEscape(folderPath))

    resp, err := http.Get(apiUrl)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)

    var result ListResponse
    if err := json.Unmarshal(body, &result); err != nil {
        panic(err)
    }

    if result.Status == "error" {
        fmt.Println("Error:", result.Operation)
        return
    }

    fmt.Printf("Folder: %s\n", result.FolderPath)
    fmt.Printf("Total Coins: %d\n\n", result.TotalCoins)

    // Display all coins
    for _, coin := range result.Coins {
        value := denominationValues[coin.Denomination]
        fmt.Printf("SN %d - %.2fcc - %s\n", coin.SerialNumber, value, coin.Filename)
    }

    // Calculate total value
    var totalValue float64
    for _, coin := range result.Coins {
        if val, ok := denominationValues[coin.Denomination]; ok {
            totalValue += val
        }
    }
    fmt.Printf("\nTotal Value: %.2fcc\n", totalValue)
}

import requests
from collections import defaultdict
from urllib.parse import urlencode

API_HOST = "http://localhost:8080"

# Denomination code to value mapping
DENOMINATION_MAP = {
    -8: 0.00000001, -7: 0.0000001, -1: 0.1,
    0: 1, 1: 5, 2: 25, 3: 100, 4: 250, 5: 1000,
    6: 5000, 7: 25000, 8: 100000, 9: 250000, 10: 1000000,
    11: 'Special'
}

def list_serial_numbers(folder_path):
    try:
        # Build URL with query parameter
        params = {'folder_path': folder_path}
        url = f"{API_HOST}/api/tools/serial-numbers?{urlencode(params)}"

        response = requests.get(url)
        result = response.json()

        if result['status'] == 'error':
            print(f"Error: {result['message']}")
            return

        print(f"Folder: {result['folder_path']}")
        print(f"Total Coins: {result['total_coins']}\n")

        # Display all coins
        for coin in result['coins']:
            value = DENOMINATION_MAP[coin['denomination']]
            print(f"SN {coin['serial_number']} - {value}cc - {coin['filename']}")

        # Calculate total value
        total_value = sum(
            DENOMINATION_MAP[coin['denomination']]
            for coin in result['coins']
            if isinstance(DENOMINATION_MAP[coin['denomination']], (int, float))
        )
        print(f"\nTotal Value: {total_value}cc")

        # Find duplicates (serial numbers appearing multiple times)
        serial_counts = defaultdict(int)
        for coin in result['coins']:
            serial_counts[coin['serial_number']] += 1

        duplicates = {sn: count for sn, count in serial_counts.items() if count > 1}
        if duplicates:
            print("\n⚠️  Duplicate Serial Numbers:")
            for sn, count in duplicates.items():
                print(f"  SN {sn} appears {count} times")

    except requests.RequestException as e:
        print(f"Error fetching serial numbers: {e}")

if __name__ == "__main__":
    # Example: List coins from Bank folder
    list_serial_numbers('C:/CloudCoin/Wallets/Default/Bank')

    # Example: List coins from Fracked folder
    # list_serial_numbers('C:/CloudCoin/Wallets/Default/Fracked')