[
  {
    "symbol": "BTC/USDT",
    "lastPrice": "26842.50",
    "high": "27100.00",
    "low": "26550.00",
    "volume": "123.4567",
    "change_24h": "-0.511",
    "time": "1706601123456"
  },
  {
    "symbol": "ETH/USDT",
    "lastPrice": "1720.40",
    "high": "1758.00",
    "low": "1682.90",
    "volume": "987.6543",
    "change_24h": "3.511",
    "time": "1706601123456"
  }
]

[
  "BTC/USDT",
  "ETH/USDT",
  "SHIB/USDT"
]

[
  {
    "price": "26840.10",
    "qty": "0.005",
    "quoteQty": "134.2005",
    "time": 1706601123456,
    "isBuyerMaker": false
  },
  {
    "price": "26838.90",
    "qty": "0.015",
    "quoteQty": "402.5835",
    "time": 1706601119789,
    "isBuyerMaker": true
  }
]

{
  "bids": [
    ["26840.00", "0.532"],
    ["26839.50", "0.127"]
  ],
  "asks": [
    ["26841.00", "0.418"],
    ["26841.20", "0.296"]
  ]
}

[
  {
    "asset": "BTC",
    "name": "Bitcoin",
    "status": "ACTIVE",
    "networks": [
      {
        "name": "BTC",
        "deposit": {
          "min": "0.0005",
          "confirmations": 2,
          "enabled": true
        },
        "withdraw": {
          "min": "0.001",
          "max": "2",
          "fee": "0.0004",
          "enabled": true
        }
      }
    ]
  },
  {
    "asset": "ETH",
    "name": "Ethereum",
    "status": "ACTIVE",
    "networks": [
      {
        "name": "ERC20",
        "deposit": {
          "min": "0.01",
          "confirmations": 20,
          "enabled": true
        },
        "withdraw": {
          "min": "0.02",
          "max": "100",
          "fee": "0.0015",
          "enabled": true
        }
      }
    ]
  }
]

#!/usr/bin/env python3
import time
import hmac
import hashlib
import requests
import json

BASE_URL = "https://api.giottus.com"
API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_API_SECRET"


def stringify_value(val):
    """Stringify primitives and objects consistently with Postman script."""
    if val is None:
        return ""
    if isinstance(val, (dict, list)):
        return json.dumps(val, separators=(",", ":"))  # compact JSON
    return str(val)


def canonical(params: dict) -> str:
    """
    Convert dict to canonical string (sorted keys, skip None/signature).
    Example: {'b':2,'a':1} -> 'a=1&b=2'
    """
    if not isinstance(params, dict):
        return ""
    items = []
    for key in sorted(params.keys()):
        if key.lower() == "signature":
            continue
        val = params[key]
        if val is None:
            continue
        items.append(f"{key}={stringify_value(val)}")
    return "&".join(items)


def sign(query: dict, body: dict) -> str:
    """Build Postman-style payload and return hex HMAC-SHA256 signature."""
    payload = (canonical(query) or "") + (canonical(body) or "")
    return hmac.new(API_SECRET.encode(), payload.encode(), hashlib.sha256).hexdigest()


def place_order():
    timestamp = str(int(time.time() * 1000))
    query = {
        "timestamp": timestamp,
        "recvWindow": "5000",
    }

    body = {
        "symbol": "BTC/INR",
        "action": "BUY",
        "type": "LIMIT",
        "price": "2250000",
        "quantity": "0.001",
    }

    # Compute signature same as Postman
    signature = sign(query, body)
    query["signature"] = signature

    url = f"{BASE_URL}/api/v1/spot/order/create"
    headers = {
        "X-GIOTTUS-APIKEY": API_KEY,
        "Content-Type": "application/json",
    }

    # Send JSON body
    resp = requests.post(url, params=query, data=json.dumps(body), headers=headers, timeout=10)

    try:
        print("Status:", resp.status_code)
        print(json.dumps(resp.json(), indent=2))
    except ValueError:
        print("Status:", resp.status_code)
        print(resp.text)


if __name__ == "__main__":
    place_order()

package main

import (
  "bytes"
  "crypto/hmac"
  "crypto/sha256"
  "crypto/tls"
  "encoding/hex"
  "encoding/json"
  "fmt"
  "io"
  "log"
  "net/http"
  "net/url"
  "sort"
  "strings"
  "time"
)

// canonical builds sorted key=value pairs joined by '&', skipping "signature"
func canonical(params map[string]interface{}) string {
  keys := make([]string, 0, len(params))
  for k := range params {
    if strings.EqualFold(k, "signature") {
      continue
    }
    keys = append(keys, k)
  }
  sort.Strings(keys)

  var parts []string
  for _, k := range keys {
    v := params[k]
    if v == nil {
      continue
    }
    switch val := v.(type) {
    case string:
      if val == "" {
        continue
      }
      parts = append(parts, fmt.Sprintf("%s=%s", k, val))
    default:
      jsonVal, _ := json.Marshal(val)
      parts = append(parts, fmt.Sprintf("%s=%s", k, string(jsonVal)))
    }
  }
  return strings.Join(parts, "&")
}

func sign(query, body map[string]interface{}, secret string) string {
  payload := canonical(query) + canonical(body)
  mac := hmac.New(sha256.New, []byte(secret))
  mac.Write([]byte(payload))
  return hex.EncodeToString(mac.Sum(nil))
}

func main() {
  const (
    BASE_URL   = "https://api.giottus.com"
    API_KEY    = "YOUR_API_KEY"
    API_SECRET = "YOUR_API_SECRET"
  )

  // --- Query params ---
  query := map[string]interface{}{
    "timestamp":  fmt.Sprintf("%d", time.Now().UnixNano()/1e6), // ms
    "recvWindow": "5000",
  }

  // --- JSON body ---
  body := map[string]interface{}{
    "symbol":   "BTC/INR",
    "action":   "BUY",
    "type":     "LIMIT",
    "price":    "2250000",
    "quantity": "0.001",
  }

  // --- Compute signature ---
  signature := sign(query, body, API_SECRET)
  query["signature"] = signature

  // Build query string
  q := url.Values{}
  for k, v := range query {
    q.Set(k, fmt.Sprintf("%v", v))
  }

  reqURL := fmt.Sprintf("%s/api/v1/spot/order/create?%s", BASE_URL, q.Encode())

  // Encode JSON body
  jsonBody, err := json.Marshal(body)
  if err != nil {
    log.Fatalf("json marshal error: %v", err)
  }

  req, err := http.NewRequest(http.MethodPost, reqURL, bytes.NewBuffer(jsonBody))
  if err != nil {
    log.Fatalf("request build error: %v", err)
  }

  req.Header.Set("X-GIOTTUS-APIKEY", API_KEY)
  req.Header.Set("Content-Type", "application/json")

  // --- HTTP client (with proper SSL verification) ---
  client := &http.Client{
      Transport: &http.Transport{
          TLSClientConfig: &tls.Config{}, // default verification enabled
      },
      Timeout: 10 * time.Second,
  }

  resp, err := client.Do(req)
  if err != nil {
    log.Fatalf("request error: %v", err)
  }
  defer resp.Body.Close()

  bodyResp, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatalf("read response error: %v", err)
  }

  fmt.Println("Status:", resp.Status)
  fmt.Println("Body:", string(bodyResp))
}

import crypto from 'crypto';
import https from 'https';
import fetch from 'node-fetch'; // needed for Node < 18

const BASE_URL = 'https://api.giottus.com'; // or your prod URL
const API_KEY = 'YOUR_API_KEY';
const API_SECRET = 'YOUR_API_SECRET';

// --- Helper: stringify primitive or object ---
function stringifyValue(value) {
  if (value === undefined || value === null) return '';
  if (typeof value === 'object' && !Array.isArray(value)) {
    return JSON.stringify(value);
  }
  return String(value);
}

// --- Helper: canonical string builder (sorted, skip "signature") ---
function canonical(obj = {}) {
  const entries = Object.entries(obj)
    .filter(([k]) => k.toLowerCase() !== 'signature')
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([k, v]) => `${k}=${stringifyValue(v)}`);
  return entries.join('&');
}

// --- Compute signature ---
function sign(query, body) {
  const payload = (canonical(query) || '') + (canonical(body) || '');
  return crypto.createHmac('sha256', API_SECRET).update(payload).digest('hex');
}

async function placeOrder() {
  const timestamp = Date.now().toString();

  const query = {
    timestamp,
    recvWindow: '5000'
  };

  const body = {
    symbol: 'BTC/INR',
    action: 'BUY',
    type: 'LIMIT',
    price: '2250000',
    quantity: '0.001'
  };

  // --- Generate signature ---
  const signature = sign(query, body);
  query.signature = signature;

  // --- Build query string ---
  const fullQuery = new URLSearchParams(query).toString();
  const url = `${BASE_URL}/api/v1/spot/order/create?${fullQuery}`;

  // --- Send JSON body (no "&" between query and body) ---
  const resp = await fetch(url, {
    method: 'POST',
    headers: {
      'X-GIOTTUS-APIKEY': API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(body)
  });

  const data = await resp.json().catch(async () => ({
    text: await resp.text()
  }));

  console.log('Status:', resp.status);
  console.log('Response:', data);
}

placeOrder().catch(err => console.error('Order failed:', err));

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.*;
import com.fasterxml.jackson.databind.ObjectMapper;

public class SimpleGiottusOrder {

    private static final String BASE_URL = "https://api.giottus.com";
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String API_SECRET = "YOUR_API_SECRET";

    public static void main(String[] args) throws Exception {
        // --- Query params ---
        Map<String, Object> query = new LinkedHashMap<>();
        query.put("timestamp", String.valueOf(System.currentTimeMillis()));
        query.put("recvWindow", "5000");

        // --- JSON body ---
        Map<String, Object> body = new LinkedHashMap<>();
        body.put("symbol", "BTC/INR");
        body.put("action", "BUY");
        body.put("type", "LIMIT");
        body.put("price", "2250000");
        body.put("quantity", "0.001");

        // --- Build signing payload ---
        String payload = canonical(query) + canonical(body);

        // --- Sign ---
        String signature = hmacSHA256(payload, API_SECRET);
        query.put("signature", signature);

        // --- Build query string ---
        String queryString = encodeParams(query);

        // --- Build full URL ---
        URI uri = new URI(BASE_URL + "/api/v1/spot/order/create?" + queryString);

        // --- Convert body to JSON ---
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(body);

        // --- Build secure request ---
        HttpRequest req = HttpRequest.newBuilder(uri)
                .header("X-GIOTTUS-APIKEY", API_KEY)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // --- Default secure HTTP client (SSL verified) ---
        HttpClient client = HttpClient.newHttpClient();

        // --- Send request ---
        HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status: " + resp.statusCode());
        System.out.println("Response: " + resp.body());
    }

    // Canonical builder: sorted, skip "signature", stringify values
    private static String canonical(Map<String, Object> params) throws Exception {
        List<String> keys = new ArrayList<>(params.keySet());
        Collections.sort(keys);
        List<String> pairs = new ArrayList<>();

        ObjectMapper mapper = new ObjectMapper();
        for (String k : keys) {
            if ("signature".equalsIgnoreCase(k)) continue;
            Object v = params.get(k);
            if (v == null) continue;

            String val;
            if (v instanceof Map || v instanceof List) {
                val = mapper.writeValueAsString(v);
            } else {
                val = v.toString();
            }
            if (!val.isEmpty()) pairs.add(k + "=" + val);
        }
        return String.join("&", pairs);
    }

    // URL-encode key=value pairs
    private static String encodeParams(Map<String, Object> params) {
        StringBuilder sb = new StringBuilder();
        boolean first = true;
        for (Map.Entry<String, Object> e : params.entrySet()) {
            if (!first) sb.append('&');
            first = false;
            sb.append(URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8))
                    .append('=')
                    .append(URLEncoder.encode(String.valueOf(e.getValue()), StandardCharsets.UTF_8));
        }
        return sb.toString();
    }

    // HMAC-SHA256 signature (hex lowercase)
    private static String hmacSHA256(String data, String secret) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec keySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        mac.init(keySpec);
        byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder hex = new StringBuilder(hash.length * 2);
        for (byte b : hash) {
            hex.append(String.format("%02x", b));
        }
        return hex.toString();
    }
}

[
  {
    "asset": "BTC",
    "free": "0.015",
    "locked": "0.002",
    "lockedFd": "0.001",
    "lockedStaking": "0",
    "lockedOtc": "0"
  },
  {
    "asset": "USDT",
    "free": "152.34",
    "locked": "25.00",
    "lockedFd": "0",
    "lockedStaking": "10",
    "lockedOtc": "0"
  }
]

[
  {
    "action": "Deposit",
    "asset": "ETH",
    "cryptoAmount": "1.5000",
    "status": "SUCCESS",
    "transactionHash": "0xabc123...",
    "time": 1706480012345,
    "network": "ERC20",
    "fromAddress": null,
    "toAddress": "0x4be3...9c42",
    "fee": "0"
  }
]

[
  {
    "action": "Deposit",
    "asset": "ETH",
    "cryptoAmount": "1.5000",
    "status": "SUCCESS",
    "transactionHash": "0xabc123...",
    "time": 1699954412345,
    "network": "ERC20",
    "fromAddress": null,
    "toAddress": "0x4be3...9c42",
    "fee": "0"
  }
]

[
  {
    "action": "Withdrawal",
    "asset": "BTC",
    "cryptoAmount": "0.0200",
    "status": "PENDING",
    "transactionHash": null,
    "time": 1706554410000,
    "network": "BTC",
    "fromAddress": "bc1qxyz...",
    "toAddress": null,
    "fee": "0.0004"
  }
]

[
  {
    "action": "Withdrawal",
    "asset": "BTC",
    "cryptoAmount": "0.0150",
    "status": "SUCCESS",
    "transactionHash": "5d8fabc...",
    "time": 1698800010000,
    "network": "BTC",
    "fromAddress": "bc1qxyz...",
    "toAddress": "bc1qarchive...",
    "fee": "0.0004"
  }
]

[
  {
    "action": "Deposit",
    "amount": "50000",
    "fee": "0",
    "status": "SUCCESS",
    "referenceId": "RCP987654321",
    "time": 1706400005123
  }
]

[
  {
    "action": "Deposit",
    "amount": "75000",
    "fee": "0",
    "status": "SUCCESS",
    "referenceId": "RCP123456789",
    "time": 1697452205123
  }
]

[
  {
    "action": "Withdrawal",
    "amount": "25000",
    "fee": "15",
    "status": "PENDING",
    "referenceId": "WD123456789",
    "time": 1706491122334
  }
]

[
  {
    "action": "Withdrawal",
    "amount": "40000",
    "fee": "15",
    "status": "SUCCESS",
    "referenceId": "WD987654321",
    "time": 1698127722334
  }
]

POST /api/v1/spot/order/create?timestamp=1706602000123&recvWindow=5000&signature=<calculated> HTTP/1.1
Host: https://api.giottus.com
X-GIOTTUS-APIKEY: YOUR_API_KEY
Content-Type: application/json

{"symbol":"BTC/INR","action":"BUY","type":"LIMIT","price":"2250000","quantity":"0.001"}

{
  "data": {
    "order_id": "1-91234567-1"
  }
}

POST /api/v1/spot/order/cancel?timestamp=1706602005123&signature=<calculated> HTTP/1.1
Host: https://api.giottus.com
X-GIOTTUS-APIKEY: YOUR_API_KEY
Content-Type: application/json

{"order_id":"1-91234567-1"}

[
  {
    "symbol": "ETH/USDT",
    "orderId": "1-91234567-1",
    "price": "1705.00",
    "origQty": "2",
    "executedQty": "0.5",
    "remainingQty": "1.5",
    "status": "PARTIALLY_FILLED",
    "type": "LIMIT",
    "side": "BUY",
    "time": 1706598822000
  }
]

[
  {
    "symbol": "BTC/USDT",
    "id": 601234,
    "orderId": "1-123-1",
    "price": "26800.50",
    "qty": "0.002",
    "quoteQty": "53.601",
    "commission": "0.000002",
    "commissionAsset": "BTC",
    "tds": "0",
    "time": 1706599900456,
    "isBuyer": true,
    "isMaker": false
  }
]

[
  {
    "symbol": "BTC/USDT",
    "id": 412345,
    "orderId": "1-123-1",
    "price": "25800.50",
    "qty": "0.002",
    "quoteQty": "51.601",
    "commission": "0.000001",
    "commissionAsset": "BTC",
    "tds": "0",
    "time": 1695000000456,
    "isBuyer": false,
    "isMaker": true
  }
]

[
  {
    "symbol": "BTC/INR",
    "id": 340012,
    "price": "2250000",
    "qty": "0.001",
    "quoteQty": "2250",
    "commission": "0.90",
    "commissionAsset": "INR",
    "tds": "0.30",
    "time": 1706595555000,
    "isBuyer": true,
    "isMaker": false
  }
]