/api/transactions/locker/put-no-sum

const API_HOST = 'http://localhost:8080';

// Upload coins to locker with per-coin authentication
async function lockerPutNoSum(lockerKey, amount, walletPath = null) {
    let url = `${API_HOST}/api/transactions/locker/put-no-sum?` +
              `locker_key=${encodeURIComponent(lockerKey)}&` +
              `amount=${amount}`;

    if (walletPath) {
        url += `&wallet_path=${encodeURIComponent(walletPath)}`;
    }

    const response = await fetch(url);
    const result = await response.json();

    if (result.status === 'success') {
        console.log(`Accepted ${result.coins_accepted}/${result.coins_sent} coins`);
        console.log(`Value accepted: ${result.value_accepted} CC`);

        // Check per-coin results
        for (const coin of result.coin_results) {
            const status = coin.accepted ? 'ACCEPTED' : 'REJECTED';
            console.log(`  SN ${coin.serial_number} (${coin.denomination} CC): ` +
                        `${coin.raida_pass}/25 RAIDA - ${status}`);
        }
    } else {
        console.error('Put failed:', result.message);
    }
    return result;
}

// Examples:
// Upload 500 CloudCoins
lockerPutNoSum('CUP-1974', 500);

// Upload 100 CloudCoins from specific wallet
lockerPutNoSum('GIFT-CODE', 100, 'E:/Wallets/MyWallet');

// Upload 1 CloudCoin (test)
lockerPutNoSum('TEST-KEY', 1);

package main

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

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

type CoinResult struct {
    SerialNumber int     `json:"serial_number"`
    Denomination float64 `json:"denomination"`
    RaidaPass    int     `json:"raida_pass"`
    Accepted     bool    `json:"accepted"`
}

type LockerPutNoSumResponse struct {
    Status         string       `json:"status"`
    Operation      string       `json:"operation"`
    AmountReq      int          `json:"amount_requested"`
    CoinsSent      int          `json:"coins_sent"`
    CoinsAccepted  int          `json:"coins_accepted"`
    CoinsMoved     int          `json:"coins_moved"`
    ValueAccepted  int          `json:"value_accepted"`
    LockerKey      string       `json:"locker_key"`
    RaidaResponded int          `json:"raida_responded"`
    CoinResults    []CoinResult `json:"coin_results"`
    TaskID         string       `json:"task_id"`
    Message        string       `json:"message,omitempty"`
}

func lockerPutNoSum(lockerKey string, amount int, walletPath string) (*LockerPutNoSumResponse, error) {
    params := url.Values{}
    params.Add("locker_key", lockerKey)
    params.Add("amount", fmt.Sprintf("%d", amount))
    if walletPath != "" {
        params.Add("wallet_path", walletPath)
    }

    fullURL := fmt.Sprintf("%s/api/transactions/locker/put-no-sum?%s",
                           ApiHost, params.Encode())

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

    body, _ := ioutil.ReadAll(resp.Body)
    var result LockerPutNoSumResponse
    json.Unmarshal(body, &result)
    return &result, nil
}

func main() {
    result, err := lockerPutNoSum("CUP-1974", 500, "")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Status: %s\n", result.Status)
    fmt.Printf("Coins: %d sent, %d accepted\n",
               result.CoinsSent, result.CoinsAccepted)
    fmt.Printf("Value accepted: %d CC\n", result.ValueAccepted)

    // Print per-coin results
    for _, coin := range result.CoinResults {
        status := "REJECTED"
        if coin.Accepted {
            status = "ACCEPTED"
        }
        fmt.Printf("  SN %d (%g CC): %d/25 RAIDA - %s\n",
                    coin.SerialNumber, coin.Denomination,
                    coin.RaidaPass, status)
    }
}