import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.rometools.utils.Strings;
import com.createsgin.HmacAlgorithmEnum;
public class TestCase {

    public static String host="https://api-v2.uzx.com";
    public static String UZXACCESSKEY2 = "{APIKey}";
    public static String UZXACCESSSECRET2 = "{SecretKey}";
    public static String UZXACCESSPASSPHRASE2 = "{Passphrase}";

    public static void testPostOrder(){
        String timestamp = System.currentTimeMillis()/1000 +"";
        String method = "POST";
        String requestPath = "/v2/trade/spot/order";
        String body = "{\"product_name\":\"BTC-USDT\",\"order_type\":2,\"price\":\"103000\",\"amount\":\"1000\",\"order_buy_or_sell\":1}";
        String data = timestamp + method + requestPath  + body;
        System.out.println(data);
        String signature = OpenAPiUtils.generate(timestamp,method,requestPath,null,body,UZXACCESSSECRET2,HmacAlgorithmEnum.HMAC_SHA_256);
        System.out.println(signature);


        HttpResponse resp = HttpUtil.createPost(host+requestPath  ).body(body)
                .header("UZX-ACCESS-KEY",UZXACCESSKEY2)
                .header("UZX-ACCESS-SIGN",signature)
                .header("UZX-ACCESS-TIMESTAMP",timestamp)
                .header("UZX-ACCESS-PASSPHRASE",UZXACCESSPASSPHRASE2).execute();
        System.out.println(resp.body());
    }

    public static void main(String[] args) {
        testPostOrder();
    }
}

import time
import hmac
import hashlib
import base64
import requests
import json

host = "https://api-v2.uzx.com"
APIKey = "{APIKey}"
SecretKey = "{SecretKey}"
Passphrase = "{Passphrase}"

def generate_signature(timestamp, method, path, query, body, secret):
    query = '?' + query if query else ''
    body = body if body else ''
    prehash = f"{timestamp}{method.upper()}{path}{query}{body}"
    signature = hmac.new(secret.encode(), prehash.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def test_post_order():
    timestamp = str(int(time.time()))
    method = "POST"
    path = "/v2/trade/spot/order"
    body = {
      "product_name": "BTC-USDT",
      "order_type": 2,
      "price": "103000",
      "amount": "1000",
      "order_buy_or_sell": 1
    }
    body_str = json.dumps(body, separators=(',', ':')) 
    signature = generate_signature(timestamp, method, path, None, body_str, SecretKey)

    headers = {
        "UZX-ACCESS-KEY": APIKey,
        "UZX-ACCESS-SIGN": signature,
        "UZX-ACCESS-TIMESTAMP": timestamp,
        "UZX-ACCESS-PASSPHRASE": Passphrase,
        "Content-Type": "application/json"
    }

    resp = requests.post(host + path, headers=headers, data=body_str)
    print(resp.status_code, resp.text)

test_post_order()

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/http"
    "time"
    "strings"
    "io/ioutil"
)

const (
    host       = "https://api-v2.uzx.com"
    APIKey     = "{APIKey}"
    SecretKey  = "{SecretKey}"
    Passphrase = "{Passphrase}"
)

func generateSignature(timestamp, method, path, query, body, secret string) string {
    if query != "" {
        query = "?" + query
    }
    preHash := timestamp + strings.ToUpper(method) + path + query + body
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(preHash))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

func testPostOrder() {
    timestamp := fmt.Sprintf("%d", time.Now().Unix())
    method := "POST"
    path := "/v2/trade/spot/order"
    body := `{"product_name":"BTC-USDT","order_type":2,"price":"103000","amount":"1000","order_buy_or_sell":1}`
    signature := generateSignature(timestamp, method, path, "", body, SecretKey)

    req, err := http.NewRequest(method, host+path, bytes.NewBuffer([]byte(body)))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("UZX-ACCESS-KEY", APIKey)
    req.Header.Set("UZX-ACCESS-SIGN", signature)
    req.Header.Set("UZX-ACCESS-TIMESTAMP", timestamp)
    req.Header.Set("UZX-ACCESS-PASSPHRASE", Passphrase)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    bodyResp, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(bodyResp))
}

func main() {
    testPostOrder()
}

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.digest.HmacAlgorithms;
import org.apache.commons.codec.digest.HmacUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;

import java.io.UnsupportedEncodingException;

public class OpenAPiUtils {
    public static final String GET = "GET";
    public static final String POST = "POST";
    public static final String DELETE = "DELETE";


    public static String generate(final String timestamp, String method, final String requestPath,
                                  String queryString, String body, final String secret, final HmacAlgorithmEnum alg) {
        body = StringUtils.defaultIfBlank(body, StringUtils.EMPTY);
        queryString = StringUtils.isEmpty(queryString) ? "" : "?" + queryString;
        final String preHash = timestamp + method + requestPath + queryString + body;
        return encodeBase64(alg, secret, preHash);
    }

    public static String encodeBase64(final HmacAlgorithmEnum alg, final String secret, final String data) {
        Validate.notNull(alg, "SignatureAlgorithm cannot be null.");
        Validate.notNull(data, "Signing Secret cannot be null.");
        switch (alg) {
            case HMAC_MD5:
                return Base64.encodeBase64String(new HmacUtils(HmacAlgorithms.HMAC_MD5, secret).hmac(data));
            case HMAC_SHA_1:
                return Base64.encodeBase64String(new HmacUtils(HmacAlgorithms.HMAC_SHA_1, secret).hmac(data));
            case HMAC_SHA_224:
                return Base64.encodeBase64String(new HmacUtils(HmacAlgorithms.HMAC_SHA_224, secret).hmac(data));
            case HMAC_SHA_256:
                try {
                    return Base64.encodeBase64String(new HmacUtils(HmacAlgorithms.HMAC_SHA_256,
                            secret.getBytes("UTF-8")).hmac(data.getBytes("UTF-8")));
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException(e.getMessage());
                }
            case HMAC_SHA_384:
                return Base64.encodeBase64String(new HmacUtils(HmacAlgorithms.HMAC_SHA_384, secret).hmac(data));
            case HMAC_SHA_512:
                return Base64.encodeBase64String(new HmacUtils(HmacAlgorithms.HMAC_SHA_512, secret).hmac(data));
            default:
                throw new IllegalArgumentException("The '" + alg.name() + "' algorithm cannot be used for signing.");
        }
    }
}

import hmac
import hashlib
import base64

def generate_signature(timestamp, method, request_path, query_string, body, secret):
    method = method.upper()
    query_string = '?' + query_string if query_string else ''
    body = body if body else ''
    pre_hash = f"{timestamp}{method}{request_path}{query_string}{body}"

    signature = hmac.new(
        secret.encode('utf-8'),
        pre_hash.encode('utf-8'),
        hashlib.sha256
    ).digest()

    return base64.b64encode(signature).decode('utf-8')

package main

import (
  "crypto/hmac"
  "crypto/sha256"
  "encoding/base64"
  "strings"
)

func GenerateSignature(timestamp, method, requestPath, queryString, body, secret string) string {
  method = strings.ToUpper(method)
  if queryString != "" {
    queryString = "?" + queryString
  }
  preHash := timestamp + method + requestPath + queryString + body

  mac := hmac.New(sha256.New, []byte(secret))
  mac.Write([]byte(preHash))
  signature := base64.StdEncoding.EncodeToString(mac.Sum(nil))

  return signature
}

{
  "product_name": "BTC-USDT",
  "order_type": 2,
  "price": "103000",
  "amount": "1000",
  "order_buy_or_sell": 1
}

import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.rometools.utils.Strings;
import com.createsgin.HmacAlgorithmEnum;
public class TestCase {

    public static String host="https://api-v2.uzx.com";
    public static String UZXACCESSKEY2 = "{APIKey}";
    public static String UZXACCESSSECRET2 = "{SecretKey}";
    public static String UZXACCESSPASSPHRASE2 = "{Passphrase}";

    public static void testPostApi(){
        String timestamp = System.currentTimeMillis()/1000 +"";
        String method = "POST";
        String requestPath = "/v2/trade/spot/order";
        String body = "{\"product_name\":\"BTC-USDT\",\"order_type\":2,\"price\":\"103000\",\"amount\":\"1000\",\"order_buy_or_sell\":1}";
        String data = timestamp + method + requestPath  + body;
        System.out.println(data);
        String signature = OpenAPiUtils.generate(timestamp,method,requestPath,null,body,UZXACCESSSECRET2,HmacAlgorithmEnum.HMAC_SHA_256);
        System.out.println(signature);


        HttpResponse resp = HttpUtil.createPost(host+requestPath  ).body(body)
                .header("UZX-ACCESS-KEY",UZXACCESSKEY2)
                .header("UZX-ACCESS-SIGN",signature)
                .header("UZX-ACCESS-TIMESTAMP",timestamp)
                .header("UZX-ACCESS-PASSPHRASE",UZXACCESSPASSPHRASE2).execute();
        System.out.println(resp.body());
    }

    public static void main(String[] args) {
        testPostApi();
    }
}

import time
import hmac
import hashlib
import base64
import requests
import json

host = "https://api-v2.uzx.com"
APIKey = "{APIKey}"
SecretKey = "{SecretKey}"
Passphrase = "{Passphrase}"

def generate_signature(timestamp, method, path, query, body, secret):
    query = '?' + query if query else ''
    body = body if body else ''
    prehash = f"{timestamp}{method.upper()}{path}{query}{body}"
    signature = hmac.new(secret.encode(), prehash.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def test_post_api():
    timestamp = str(int(time.time()))
    method = "POST"
    path = "/v2/trade/spot/order"
    body = {
      "product_name": "BTC-USDT",
      "order_type": 2,
      "price": "103000",
      "amount": "1000",
      "order_buy_or_sell": 1
    }
    body_str = json.dumps(body, separators=(',', ':')) 
    signature = generate_signature(timestamp, method, path, None, body_str, SecretKey)

    headers = {
        "UZX-ACCESS-KEY": APIKey,
        "UZX-ACCESS-SIGN": signature,
        "UZX-ACCESS-TIMESTAMP": timestamp,
        "UZX-ACCESS-PASSPHRASE": Passphrase,
        "Content-Type": "application/json"
    }

    resp = requests.post(host + path, headers=headers, data=body_str)
    print(resp.status_code, resp.text)

test_post_api()

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/http"
    "time"
    "strings"
    "io/ioutil"
)

const (
    host       = "https://api-v2.uzx.com"
    APIKey     = "{APIKey}"
    SecretKey  = "{SecretKey}"
    Passphrase = "{Passphrase}"
)

func generateSignature(timestamp, method, path, query, body, secret string) string {
    if query != "" {
        query = "?" + query
    }
    preHash := timestamp + strings.ToUpper(method) + path + query + body
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(preHash))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

func testPostApi() {
    timestamp := fmt.Sprintf("%d", time.Now().Unix())
    method := "POST"
    path := "/v2/trade/spot/order"
    body := `{"product_name":"BTC-USDT","order_type":2,"price":"103000","amount":"1000","order_buy_or_sell":1}`
    signature := generateSignature(timestamp, method, path, "", body, SecretKey)

    req, err := http.NewRequest(method, host+path, bytes.NewBuffer([]byte(body)))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("UZX-ACCESS-KEY", APIKey)
    req.Header.Set("UZX-ACCESS-SIGN", signature)
    req.Header.Set("UZX-ACCESS-TIMESTAMP", timestamp)
    req.Header.Set("UZX-ACCESS-PASSPHRASE", Passphrase)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    bodyResp, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(bodyResp))
}

func main() {
    testPostApi()
}

{
  "code": 200,
  "msg": "success",
  "data": {
    "order_id": "2508810000100425939"
  }
}

[
  {
    "product_name": "BTC-USDT",
    "order_type": 2,
    "price": "103000",
    "amount": "1000",
    "order_buy_or_sell": 1
  }
]

import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.rometools.utils.Strings;
import com.createsgin.HmacAlgorithmEnum;
public class TestCase {

    public static String host="https://api-v2.uzx.com";
    public static String UZXACCESSKEY2 = "{APIKey}";
    public static String UZXACCESSSECRET2 = "{SecretKey}";
    public static String UZXACCESSPASSPHRASE2 = "{Passphrase}";

    public static void testPostApi(){
        String timestamp = System.currentTimeMillis()/1000 +"";
        String method = "POST";
        String requestPath = "/v2/trade/spot/batch-orders";
        String body = "[{\"product_name\":\"BTC-USDT\",\"order_type\":2,\"price\":\"103000\",\"amount\":\"1000\",\"order_buy_or_sell\":1}]";
        String data = timestamp + method + requestPath  + body;
        System.out.println(data);
        String signature = OpenAPiUtils.generate(timestamp,method,requestPath,null,body,UZXACCESSSECRET2,HmacAlgorithmEnum.HMAC_SHA_256);
        System.out.println(signature);


        HttpResponse resp = HttpUtil.createPost(host+requestPath  ).body(body)
                .header("UZX-ACCESS-KEY",UZXACCESSKEY2)
                .header("UZX-ACCESS-SIGN",signature)
                .header("UZX-ACCESS-TIMESTAMP",timestamp)
                .header("UZX-ACCESS-PASSPHRASE",UZXACCESSPASSPHRASE2).execute();
        System.out.println(resp.body());
    }

    public static void main(String[] args) {
        testPostApi();
    }
}

import time
import hmac
import hashlib
import base64
import requests
import json

host = "https://api-v2.uzx.com"
APIKey = "{APIKey}"
SecretKey = "{SecretKey}"
Passphrase = "{Passphrase}"

def generate_signature(timestamp, method, path, query, body, secret):
    query = '?' + query if query else ''
    body = body if body else ''
    prehash = f"{timestamp}{method.upper()}{path}{query}{body}"
    signature = hmac.new(secret.encode(), prehash.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def test_post_api():
    timestamp = str(int(time.time()))
    method = "POST"
    path = "/v2/trade/spot/batch-orders"
    body = [
        {
            "product_name": "BTC-USDT",
            "order_type": 2,
            "price": "103000",
            "amount": "1000", 
            "order_buy_or_sell": 1
        }
    ]
    body_str = json.dumps(body, separators=(',', ':')) 
    signature = generate_signature(timestamp, method, path, None, body_str, SecretKey)

    headers = {
        "UZX-ACCESS-KEY": APIKey,
        "UZX-ACCESS-SIGN": signature,
        "UZX-ACCESS-TIMESTAMP": timestamp,
        "UZX-ACCESS-PASSPHRASE": Passphrase,
        "Content-Type": "application/json"
    }

    resp = requests.post(host + path, headers=headers, data=body_str)
    print(resp.status_code, resp.text)

test_post_api()

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/http"
    "time"
    "strings"
    "io/ioutil"
)

const (
    host       = "https://api-v2.uzx.com"
    APIKey     = "{APIKey}"
    SecretKey  = "{SecretKey}"
    Passphrase = "{Passphrase}"
)

func generateSignature(timestamp, method, path, query, body, secret string) string {
    if query != "" {
        query = "?" + query
    }
    preHash := timestamp + strings.ToUpper(method) + path + query + body
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(preHash))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

func testPostApi() {
    timestamp := fmt.Sprintf("%d", time.Now().Unix())
    method := "POST"
    path := "/v2/trade/spot/batch-orders"
    body := `[{"product_name":"BTC-USDT","order_type":2,"price":"103000","amount":"1000","order_buy_or_sell":1}]`
    signature := generateSignature(timestamp, method, path, "", body, SecretKey)

    req, err := http.NewRequest(method, host+path, bytes.NewBuffer([]byte(body)))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("UZX-ACCESS-KEY", APIKey)
    req.Header.Set("UZX-ACCESS-SIGN", signature)
    req.Header.Set("UZX-ACCESS-TIMESTAMP", timestamp)
    req.Header.Set("UZX-ACCESS-PASSPHRASE", Passphrase)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    bodyResp, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(bodyResp))
}

func main() {
    testPostApi()
}

{
  "code": 200,
  "msg": "success",
  "data": [
    {
      "code": 200,
      "order_id": "2509820413501205367"
    }
  ]
}

{
  "product_name": "BTCUSDT",
  "order_type": 2,
  "number": 1,
  "price": "107000",
  "amount": "1",
  "trade_ccy": 1,
  "pos_side": "LG",
  "order_buy_or_sell": 1
}

import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.rometools.utils.Strings;
import com.createsgin.HmacAlgorithmEnum;
public class TestCase {

    public static String host="https://api-v2.uzx.com";
    public static String UZXACCESSKEY2 = "{APIKey}";
    public static String UZXACCESSSECRET2 = "{SecretKey}";
    public static String UZXACCESSPASSPHRASE2 = "{Passphrase}";

    public static void testPostApi(){
        String timestamp = System.currentTimeMillis()/1000 +"";
        String method = "POST";
        String requestPath = "/v2/trade/swap/order";
        String body = "{\"product_name\":\"BTCUSDT\",\"order_type\":2,\"number\":1,\"price\":\"107000\",\"amount\":\"1\",\"trade_ccy\":1,\"pos_side\":\"LG\",\"order_buy_or_sell\":1}";
        String data = timestamp + method + requestPath  + body;
        System.out.println(data);
        String signature = OpenAPiUtils.generate(timestamp,method,requestPath,null,body,UZXACCESSSECRET2,HmacAlgorithmEnum.HMAC_SHA_256);
        System.out.println(signature);


        HttpResponse resp = HttpUtil.createPost(host+requestPath  ).body(body)
                .header("UZX-ACCESS-KEY",UZXACCESSKEY2)
                .header("UZX-ACCESS-SIGN",signature)
                .header("UZX-ACCESS-TIMESTAMP",timestamp)
                .header("UZX-ACCESS-PASSPHRASE",UZXACCESSPASSPHRASE2).execute();
        System.out.println(resp.body());
    }

    public static void main(String[] args) {
        testPostApi();
    }
}

import time
import hmac
import hashlib
import base64
import requests
import json

host = "https://api-v2.uzx.com"
APIKey = "{APIKey}"
SecretKey = "{SecretKey}"
Passphrase = "{Passphrase}"

def generate_signature(timestamp, method, path, query, body, secret):
    query = '?' + query if query else ''
    body = body if body else ''
    prehash = f"{timestamp}{method.upper()}{path}{query}{body}"
    signature = hmac.new(secret.encode(), prehash.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def test_post_api():
    timestamp = str(int(time.time()))
    method = "POST"
    path = "/v2/trade/swap/order"
    body = {
      "product_name": "BTCUSDT",
      "order_type": 2,
      "number": 1,
      "price": "107000",
      "amount": "1",
      "trade_ccy": 1,
      "pos_side": "LG",
      "order_buy_or_sell": 1
    }
    body_str = json.dumps(body, separators=(',', ':')) 
    signature = generate_signature(timestamp, method, path, None, body_str, SecretKey)

    headers = {
        "UZX-ACCESS-KEY": APIKey,
        "UZX-ACCESS-SIGN": signature,
        "UZX-ACCESS-TIMESTAMP": timestamp,
        "UZX-ACCESS-PASSPHRASE": Passphrase,
        "Content-Type": "application/json"
    }

    resp = requests.post(host + path, headers=headers, data=body_str)
    print(resp.status_code, resp.text)

test_post_api()

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/http"
    "time"
    "strings"
    "io/ioutil"
)

const (
    host       = "https://api-v2.uzx.com"
    APIKey     = "{APIKey}"
    SecretKey  = "{SecretKey}"
    Passphrase = "{Passphrase}"
)

func generateSignature(timestamp, method, path, query, body, secret string) string {
    if query != "" {
        query = "?" + query
    }
    preHash := timestamp + strings.ToUpper(method) + path + query + body
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(preHash))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

func testPostApi() {
    timestamp := fmt.Sprintf("%d", time.Now().Unix())
    method := "POST"
    path := "/v2/trade/swap/order"
    body := `{"product_name":"BTCUSDT","order_type":2,"number":1,"price":"107000","amount":"1","trade_ccy":1,"pos_side":"LG","order_buy_or_sell":1}`
    signature := generateSignature(timestamp, method, path, "", body, SecretKey)

    req, err := http.NewRequest(method, host+path, bytes.NewBuffer([]byte(body)))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("UZX-ACCESS-KEY", APIKey)
    req.Header.Set("UZX-ACCESS-SIGN", signature)
    req.Header.Set("UZX-ACCESS-TIMESTAMP", timestamp)
    req.Header.Set("UZX-ACCESS-PASSPHRASE", Passphrase)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    bodyResp, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(bodyResp))
}

func main() {
    testPostApi()
}

{
  "code": 200,
  "msg": "success",
  "data": {
    "order_id": "2517820683201827363"
  }
}

[
  {
    "product_name": "BTCUSDT",
    "order_type": 2,
    "number": 1,
    "price": "102001",
    "amount": "316.89",
    "pos_side": "LG",
    "order_buy_or_sell": 1
  }
]

import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.rometools.utils.Strings;
import com.createsgin.HmacAlgorithmEnum;
public class TestCase {

    public static String host="https://api-v2.uzx.com";
    public static String UZXACCESSKEY2 = "{APIKey}";
    public static String UZXACCESSSECRET2 = "{SecretKey}";
    public static String UZXACCESSPASSPHRASE2 = "{Passphrase}";

    public static void testPostApi(){
        String timestamp = System.currentTimeMillis()/1000 +"";
        String method = "POST";
        String requestPath = "/v2/trade/swap/batch-orders";
        String body = "[{\"product_name\":\"BTCUSDT\",\"order_type\":2,\"number\":1,\"price\":\"102001\",\"amount\":\"316.89\",\"pos_side\":\"LG\",\"order_buy_or_sell\":1}]";
        String data = timestamp + method + requestPath  + body;
        System.out.println(data);
        String signature = OpenAPiUtils.generate(timestamp,method,requestPath,null,body,UZXACCESSSECRET2,HmacAlgorithmEnum.HMAC_SHA_256);
        System.out.println(signature);


        HttpResponse resp = HttpUtil.createPost(host+requestPath  ).body(body)
                .header("UZX-ACCESS-KEY",UZXACCESSKEY2)
                .header("UZX-ACCESS-SIGN",signature)
                .header("UZX-ACCESS-TIMESTAMP",timestamp)
                .header("UZX-ACCESS-PASSPHRASE",UZXACCESSPASSPHRASE2).execute();
        System.out.println(resp.body());
    }

    public static void main(String[] args) {
        testPostApi();
    }
}

import time
import hmac
import hashlib
import base64
import requests
import json

host = "https://api-v2.uzx.com"
APIKey = "{APIKey}"
SecretKey = "{SecretKey}"
Passphrase = "{Passphrase}"

def generate_signature(timestamp, method, path, query, body, secret):
    query = '?' + query if query else ''
    body = body if body else ''
    prehash = f"{timestamp}{method.upper()}{path}{query}{body}"
    signature = hmac.new(secret.encode(), prehash.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def test_post_api():
    timestamp = str(int(time.time()))
    method = "POST"
    path = "/v2/trade/swap/batch-orders"
    body = [
      {
        "product_name": "BTCUSDT",
        "order_type": 2,
        "number": 1,
        "price": "102001",
        "amount": "316.89",
        "pos_side": "LG",
        "order_buy_or_sell": 1
      }
    ]
    body_str = json.dumps(body, separators=(',', ':')) 
    signature = generate_signature(timestamp, method, path, None, body_str, SecretKey)

    headers = {
        "UZX-ACCESS-KEY": APIKey,
        "UZX-ACCESS-SIGN": signature,
        "UZX-ACCESS-TIMESTAMP": timestamp,
        "UZX-ACCESS-PASSPHRASE": Passphrase,
        "Content-Type": "application/json"
    }

    resp = requests.post(host + path, headers=headers, data=body_str)
    print(resp.status_code, resp.text)

test_post_api()

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/http"
    "time"
    "strings"
    "io/ioutil"
)

const (
    host       = "https://api-v2.uzx.com"
    APIKey     = "{APIKey}"
    SecretKey  = "{SecretKey}"
    Passphrase = "{Passphrase}"
)

func generateSignature(timestamp, method, path, query, body, secret string) string {
    if query != "" {
        query = "?" + query
    }
    preHash := timestamp + strings.ToUpper(method) + path + query + body
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(preHash))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

func testPostApi() {
    timestamp := fmt.Sprintf("%d", time.Now().Unix())
    method := "POST"
    path := "/v2/trade/swap/batch-orders"
    body := `[{"product_name":"BTCUSDT","order_type":2,"number":1,"price":"102001","amount":"316.89","pos_side":"LG","order_buy_or_sell":1}]`
    signature := generateSignature(timestamp, method, path, "", body, SecretKey)

    req, err := http.NewRequest(method, host+path, bytes.NewBuffer([]byte(body)))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("UZX-ACCESS-KEY", APIKey)
    req.Header.Set("UZX-ACCESS-SIGN", signature)
    req.Header.Set("UZX-ACCESS-TIMESTAMP", timestamp)
    req.Header.Set("UZX-ACCESS-PASSPHRASE", Passphrase)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    bodyResp, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(bodyResp))
}

func main() {
    testPostApi()
}

{
  "code": 200,
  "msg": "success",
  "data": [
    {
      "order_id": "2517720561802636780"
    },
    {
      "order_id": "2517720561802636781"
    }
  ]
}

{
  "product_name": "BTCUSDT",
  "pos_side": "LG"
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class TestCase {
    public static String host = "https://api-v2.uzx.com";
    public static String UZXACCESSKEY2 = "{APIKey}";
    public static String UZXACCESSSECRET2 = "{SecretKey}";
    public static String UZXACCESSPASSPHRASE2 = "{Passphrase}";

    public enum HmacAlgorithmEnum {
        HMAC_SHA_256("HmacSHA256"),
        HMAC_SHA_512("HmacSHA512");

        private final String algorithmName;

        HmacAlgorithmEnum(String algorithmName) {
            this.algorithmName = algorithmName;
        }

        public String getAlgorithmName() {
            return algorithmName;
        }
    }

    public static String generate(String timestamp, String method, String requestPath,
                                 String queryString, String body, String secret,
                                 HmacAlgorithmEnum algorithm) throws Exception {
        String data = timestamp + method + requestPath + (queryString != null ? queryString : "") + body;

        Mac mac = Mac.getInstance(algorithm.getAlgorithmName());
        SecretKeySpec secretKeySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), algorithm.getAlgorithmName());
        mac.init(secretKeySpec);

        byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hash);
    }

    public static void testPutApi() throws Exception {
        String timestamp = System.currentTimeMillis() / 1000 + "";
        String method = "PUT";
        String requestPath = "/v2/trade/swap/close-position";
        String body = "{\"product_name\":\"BTCUSDT\",\"pos_side\":\"LG\"}";
        String data = timestamp + method + requestPath + body;
        System.out.println(data);

        String signature = generate(timestamp, method, requestPath, null, body, UZXACCESSSECRET2, HmacAlgorithmEnum.HMAC_SHA_256);
        System.out.println(signature);

        URL url = new URL(host + requestPath);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("PUT");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("UZX-ACCESS-KEY", UZXACCESSKEY2);
        conn.setRequestProperty("UZX-ACCESS-SIGN", signature);
        conn.setRequestProperty("UZX-ACCESS-TIMESTAMP", timestamp);
        conn.setRequestProperty("UZX-ACCESS-PASSPHRASE", UZXACCESSPASSPHRASE2);
        conn.setDoOutput(true);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = body.getBytes(StandardCharsets.UTF_8);
            os.write(input, 0, input.length);
        }

        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
            StringBuilder response = new StringBuilder();
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
            System.out.println(response.toString());
        }
    }

    public static void main(String[] args) {
        try {
            testPutApi();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import time
import hmac
import hashlib
import base64
import requests
import json

host = "https://api-v2.uzx.com"
APIKey = "{APIKey}"
SecretKey = "{SecretKey}"
Passphrase = "{Passphrase}"

def generate_signature(timestamp, method, path, query, body, secret):
    query = '?' + query if query else ''
    body = body if body else ''
    prehash = f"{timestamp}{method.upper()}{path}{query}{body}"
    signature = hmac.new(secret.encode(), prehash.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def test_put_api():
    timestamp = str(int(time.time()))
    method = "PUT"
    path = "/v2/trade/swap/close-position"
    body = {
      "product_name": "BTCUSDT",
      "pos_side": "LG"
    }
    body_str = json.dumps(body, separators=(',', ':')) 
    signature = generate_signature(timestamp, method, path, None, body_str, SecretKey)

    headers = {
        "UZX-ACCESS-KEY": APIKey,
        "UZX-ACCESS-SIGN": signature,
        "UZX-ACCESS-TIMESTAMP": timestamp,
        "UZX-ACCESS-PASSPHRASE": Passphrase,
        "Content-Type": "application/json"
    }

    resp = requests.put(host + path, headers=headers, data=body_str)
    print(resp.status_code, resp.text)

test_put_api()

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/http"
    "time"
    "strings"
    "io/ioutil"
)

const (
    host       = "https://api-v2.uzx.com"
    APIKey     = "{APIKey}"
    SecretKey  = "{SecretKey}"
    Passphrase = "{Passphrase}"
)

func generateSignature(timestamp, method, path, query, body, secret string) string {
    if query != "" {
        query = "?" + query
    }
    preHash := timestamp + strings.ToUpper(method) + path + query + body
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(preHash))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

func testPutApi() {
    timestamp := fmt.Sprintf("%d", time.Now().Unix())
    method := "PUT"
    path := "/v2/trade/swap/close-position"
    body := `{"product_name":"BTCUSDT","pos_side":"LG"}`
    signature := generateSignature(timestamp, method, path, "", body, SecretKey)

    req, err := http.NewRequest(method, host+path, bytes.NewBuffer([]byte(body)))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("UZX-ACCESS-KEY", APIKey)
    req.Header.Set("UZX-ACCESS-SIGN", signature)
    req.Header.Set("UZX-ACCESS-TIMESTAMP", timestamp)
    req.Header.Set("UZX-ACCESS-PASSPHRASE", Passphrase)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    bodyResp, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(bodyResp))
}

func main() {
    testPutApi()
}

{
  "code": 200,
  "msg": "string",
  "data": {}
}