/api/transactions/locker/download

# Download coins from locker to specific wallet (automatically grades to Bank/Fracked/Counterfeit)
curl -X GET "http://localhost:8080/api/transactions/locker/download?wallet_path=E:/Client_Data/Wallets/Default&locker_key=0123456789abcdef0123456789abcdef"

# Example output:
# {
#   "status": "success",
#   "operation": "locker_download",
#   "coins_found": 5,
#   "coins_saved": 5,
#   "graded_to_bank": 4,
#   "graded_to_fracked": 1,
#   "graded_to_counterfeit": 0,
#   "wallet_path": "E:/Client_Data/Wallets/Default",
#   "locker_key": "0123456789abcdef0123456789abcdef"
# }

# Optional: Fix fracked coins if any were downloaded
curl -X GET "http://localhost:8080/api/coins/fix?wallet_path=E:/Client_Data/Wallets/Default"

package main

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

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

type LockerDownloadResponse struct {
    Status             string `json:"status"`
    Operation          string `json:"operation"`
    CoinsFound         int    `json:"coins_found"`
    CoinsSaved         int    `json:"coins_saved"`
    GradedToBank       int    `json:"graded_to_bank"`
    GradedToFracked    int    `json:"graded_to_fracked"`
    GradedToCounterfeit int   `json:"graded_to_counterfeit"`
    WalletPath         string `json:"wallet_path"`
    LockerKey          string `json:"locker_key"`
}

type ErrorResponse struct {
    Error   bool   `json:"error"`
    Message string `json:"message"`
    Code    int    `json:"code"`
    Detail  string `json:"detail,omitempty"`
}

func downloadFromLocker(walletPath, lockerKey string) error {
    reqUrl := fmt.Sprintf("%s/api/transactions/locker/download?wallet_path=%s&locker_key=%s",
        ApiHost, url.QueryEscape(walletPath), lockerKey)

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

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

    if resp.StatusCode == 200 {
        var result LockerDownloadResponse
        if err := json.Unmarshal(body, &result); err != nil {
            return err
        }

        fmt.Printf("Success! Downloaded and graded %d coins to %s\n", result.CoinsSaved, result.WalletPath)
        fmt.Printf("Total coins found: %d\n", result.CoinsFound)
        fmt.Printf("Graded to Bank: %d\n", result.GradedToBank)
        fmt.Printf("Graded to Fracked: %d\n", result.GradedToFracked)
        fmt.Printf("Graded to Counterfeit: %d\n", result.GradedToCounterfeit)

        // Optional: Fix fracked coins if any
        if result.GradedToFracked > 0 {
            fmt.Println("Running fix for fracked coins...")
            fixFrackedCoins(walletPath)
        }

        return nil
    } else {
        var errResp ErrorResponse
        if err := json.Unmarshal(body, &errResp); err != nil {
            return err
        }
        return fmt.Errorf("Error %d: %s (%s)", errResp.Code, errResp.Message, errResp.Detail)
    }
}

func fixFrackedCoins(walletPath string) error {
    resp, err := http.Get(fmt.Sprintf("%s/api/coins/fix?wallet_path=%s", ApiHost, url.QueryEscape(walletPath)))
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    fmt.Println("Fix complete")
    return nil
}

func main() {
    walletPath := "E:/Client_Data/Wallets/Default"
    lockerKey := "0123456789abcdef0123456789abcdef"

    if err := downloadFromLocker(walletPath, lockerKey); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}