跳转至

用户资产☍

版本：v1

认证方式：Bearer Token

目录☍

接口列表☍

获取用户资产☍

接口说明

根据用户ID获取用户的资产列表

基本信息☍

  • 接口名称：获取用户资产
  • 请求方式：GET
  • 请求路径：/UserCurrency/{appKey}/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 用户ID 是
appKey - - 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/UserCurrency/{appKey}/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/UserCurrency/{appKey}/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

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

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/UserCurrency/{appKey}/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/UserCurrency/{appKey}/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/UserCurrency/{appKey}/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/UserCurrency/{appKey}/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/UserCurrency/{appKey}/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/UserCurrency/{appKey}/{id}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/UserCurrency/{appKey}/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/UserCurrency/{appKey}/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 用户资产的唯一标识符。,
          "userID": "0"          // 与用户资产关联的用户ID。,
          "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
          "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array<UserCurrency> 响应数据 否
error string 错误信息 否

充值虚拟币☍

接口说明

根据提供的参数进行虚拟币充值

基本信息☍

  • 接口名称：充值虚拟币
  • 请求方式：POST
  • 请求路径：/UserCurrency/{appKey}/CurrencyRecharge

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
nonce string - 随机数 是
timestamp integer - 时间戳（允许与服务器时间误差在1分钟内） 是
signature string - 签名 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
currency string - 虚拟币代码 是
balance integer - 充值额 是
remark string - 备注 否
description string - 描述 否
tags string - 标签 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/UserCurrency/{appKey}/CurrencyRecharge"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import requests

url = "{server}/UserCurrency/{appKey}/CurrencyRecharge"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}

response = requests.post(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package main

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

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/UserCurrency/{appKey}/CurrencyRecharge", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const axios = require('axios');


const data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

const config = {
    method: 'post',
    url: '{server}/UserCurrency/{appKey}/CurrencyRecharge',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?php

$url = "{server}/UserCurrency/{appKey}/CurrencyRecharge";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/UserCurrency/{appKey}/CurrencyRecharge", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
require 'net/http'
require 'json'

uri = URI("{server}/UserCurrency/{appKey}/CurrencyRecharge")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
const data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

fetch("{server}/UserCurrency/{appKey}/CurrencyRecharge", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/UserCurrency/{appKey}/CurrencyRecharge")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import Foundation

let url = URL(string: "{server}/UserCurrency/{appKey}/CurrencyRecharge")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

兑换虚拟币☍

接口说明

根据提供的参数进行虚拟币兑换

基本信息☍

  • 接口名称：兑换虚拟币
  • 请求方式：POST
  • 请求路径：/UserCurrency/{appKey}/CurrencyExchange

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
nonce string - 随机数 是
timestamp integer - 时间戳（允许与服务器时间误差在1分钟内） 是
signature string - 签名 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
fromCurrency string - 源虚拟币代码 是
currency string - 目标虚拟币代码 是
balance integer - 兑换额 是
remark string - 备注 否
description string - 描述 否
tags string - 标签 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/UserCurrency/{appKey}/CurrencyExchange"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import requests

url = "{server}/UserCurrency/{appKey}/CurrencyExchange"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}

response = requests.post(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package main

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

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/UserCurrency/{appKey}/CurrencyExchange", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const axios = require('axios');


const data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

const config = {
    method: 'post',
    url: '{server}/UserCurrency/{appKey}/CurrencyExchange',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php

$url = "{server}/UserCurrency/{appKey}/CurrencyExchange";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/UserCurrency/{appKey}/CurrencyExchange", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
require 'net/http'
require 'json'

uri = URI("{server}/UserCurrency/{appKey}/CurrencyExchange")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
const data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

fetch("{server}/UserCurrency/{appKey}/CurrencyExchange", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/UserCurrency/{appKey}/CurrencyExchange")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import Foundation

let url = URL(string: "{server}/UserCurrency/{appKey}/CurrencyExchange")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

消费虚拟币☍

接口说明

根据提供的参数进行虚拟币消费

基本信息☍

  • 接口名称：消费虚拟币
  • 请求方式：POST
  • 请求路径：/UserCurrency/{appKey}/CurrencyConsume

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
nonce string - 随机数 是
timestamp integer - 时间戳（允许与服务器时间误差在1分钟内） 是
signature string - 签名 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
currency string - 虚拟币代码 是
balance integer - 消费额 是
remark string - 备注 否
description string - 描述 否
tags string - 标签 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/UserCurrency/{appKey}/CurrencyConsume"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import requests

url = "{server}/UserCurrency/{appKey}/CurrencyConsume"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}

response = requests.post(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package main

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

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/UserCurrency/{appKey}/CurrencyConsume", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const axios = require('axios');


const data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

const config = {
    method: 'post',
    url: '{server}/UserCurrency/{appKey}/CurrencyConsume',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?php

$url = "{server}/UserCurrency/{appKey}/CurrencyConsume";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/UserCurrency/{appKey}/CurrencyConsume", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
require 'net/http'
require 'json'

uri = URI("{server}/UserCurrency/{appKey}/CurrencyConsume")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
const data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};

fetch("{server}/UserCurrency/{appKey}/CurrencyConsume", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/UserCurrency/{appKey}/CurrencyConsume")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import Foundation

let url = URL(string: "{server}/UserCurrency/{appKey}/CurrencyConsume")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

虚拟币交易记录☍

接口说明

根据提供的参数获取虚拟币交易记录

基本信息☍

  • 接口名称：虚拟币交易记录
  • 请求方式：GET
  • 请求路径：/UserCurrency/{appKey}/CurrencyTransactions

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
transType string - 交易类型 否
curCode string - 货币代码 否
startTime string - 开始时间 否
endTime string - 结束时间 否
skip integer - 跳过的条数 否
take integer - 拉取的条数 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/UserCurrency/{appKey}/CurrencyTransactions"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/UserCurrency/{appKey}/CurrencyTransactions"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

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

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/UserCurrency/{appKey}/CurrencyTransactions", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/UserCurrency/{appKey}/CurrencyTransactions',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/UserCurrency/{appKey}/CurrencyTransactions";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/UserCurrency/{appKey}/CurrencyTransactions");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/UserCurrency/{appKey}/CurrencyTransactions")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/UserCurrency/{appKey}/CurrencyTransactions", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/UserCurrency/{appKey}/CurrencyTransactions")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/UserCurrency/{appKey}/CurrencyTransactions")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
{
    "code": 200          // 状态码,
    "data": {
    "total": "0",
    "data": [
      {
          "id": "0"          // 货币交易记录的唯一标识符。,
          "fromUserID": "0"          // 发起交易的发送方用户ID，若为转账交易时必填。,
          "userID": "0"          // 进行货币交易的用户ID。,
          "transactionType": ""          // 货币交易的类型，例如 '消费', '奖励', '兑换', '转账' 等。,
          "currencyType": ""          // 交易的货币类型，例如 'USD', 'CNY' 等。,
          "currencyChange": "0"          // 货币的变动数量，正数表示增加，负数表示减少。,
          "currencyBalance": "0"          // 交易完成后的货币余额。,
          "description": ""          // 描述货币变动的具体原因或相关交易详情。,
          "status": ""          // 货币交易的当前状态，例如 '成功', '失败', '待审核' 等。,
          "remark": ""          // 交易的额外信息或管理员的备注。,
          "tags": ""          // 用于分类或标记交易的标签。,
          "createDate": ""          // 货币交易发生的时间，默认为当前时间。
      }
    ]
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data UserCurrencyCurrencyTransResult - 否
error string 错误信息 否

数据结构☍

BooleanApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

CurrencyConsumeRequest☍

1
2
3
4
5
6
7
{
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 消费额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
字段名 类型 描述 是否必填
currency string 虚拟币代码 是
balance integer 消费额 是
remark string 备注 否
description string 描述 否
tags string 标签 否

CurrencyTransaction☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
    "id": "0"          // 货币交易记录的唯一标识符。,
    "fromUserID": "0"          // 发起交易的发送方用户ID，若为转账交易时必填。,
    "userID": "0"          // 进行货币交易的用户ID。,
    "transactionType": ""          // 货币交易的类型，例如 '消费', '奖励', '兑换', '转账' 等。,
    "currencyType": ""          // 交易的货币类型，例如 'USD', 'CNY' 等。,
    "currencyChange": "0"          // 货币的变动数量，正数表示增加，负数表示减少。,
    "currencyBalance": "0"          // 交易完成后的货币余额。,
    "description": ""          // 描述货币变动的具体原因或相关交易详情。,
    "status": ""          // 货币交易的当前状态，例如 '成功', '失败', '待审核' 等。,
    "remark": ""          // 交易的额外信息或管理员的备注。,
    "tags": ""          // 用于分类或标记交易的标签。,
    "createDate": ""          // 货币交易发生的时间，默认为当前时间。
}
字段名 类型 描述 是否必填
id integer 货币交易记录的唯一标识符。 否
fromUserID integer 发起交易的发送方用户ID，若为转账交易时必填。 否
userID integer 进行货币交易的用户ID。 否
transactionType string 货币交易的类型，例如 '消费', '奖励', '兑换', '转账' 等。 否
currencyType string 交易的货币类型，例如 'USD', 'CNY' 等。 否
currencyChange integer 货币的变动数量，正数表示增加，负数表示减少。 否
currencyBalance number 交易完成后的货币余额。 否
description string 描述货币变动的具体原因或相关交易详情。 否
status string 货币交易的当前状态，例如 '成功', '失败', '待审核' 等。 否
remark string 交易的额外信息或管理员的备注。 否
tags string 用于分类或标记交易的标签。 否
createDate string 货币交易发生的时间，默认为当前时间。 否

ExchangeCurrencyRequest☍

1
2
3
4
5
6
7
8
{
    "fromCurrency": ""          // 源虚拟币代码,
    "currency": ""          // 目标虚拟币代码,
    "balance": "0"          // 兑换额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
字段名 类型 描述 是否必填
fromCurrency string 源虚拟币代码 是
currency string 目标虚拟币代码 是
balance integer 兑换额 是
remark string 备注 否
description string 描述 否
tags string 标签 否

RechargePointRequest☍

1
2
3
4
5
6
7
{
    "currency": ""          // 虚拟币代码,
    "balance": "0"          // 充值额,
    "remark": ""          // 备注,
    "description": ""          // 描述,
    "tags": ""          // 标签
}
字段名 类型 描述 是否必填
currency string 虚拟币代码 是
balance integer 充值额 是
remark string 备注 否
description string 描述 否
tags string 标签 否

UserCurrency☍

1
2
3
4
5
6
{
    "id": "0"          // 用户资产的唯一标识符。,
    "userID": "0"          // 与用户资产关联的用户ID。,
    "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
    "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
}
字段名 类型 描述 是否必填
id integer 用户资产的唯一标识符。 否
userID integer 与用户资产关联的用户ID。 否
currencyCode string 用户资产的货币代码，例如 'USD', 'CNY' 等。 否
balance integer 用户的账户余额，表示当前持有的货币数量。 否

UserCurrencyCurrencyTransResult☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
{
    "total": "0",
    "data": [
      {
          "id": "0"          // 货币交易记录的唯一标识符。,
          "fromUserID": "0"          // 发起交易的发送方用户ID，若为转账交易时必填。,
          "userID": "0"          // 进行货币交易的用户ID。,
          "transactionType": ""          // 货币交易的类型，例如 '消费', '奖励', '兑换', '转账' 等。,
          "currencyType": ""          // 交易的货币类型，例如 'USD', 'CNY' 等。,
          "currencyChange": "0"          // 货币的变动数量，正数表示增加，负数表示减少。,
          "currencyBalance": "0"          // 交易完成后的货币余额。,
          "description": ""          // 描述货币变动的具体原因或相关交易详情。,
          "status": ""          // 货币交易的当前状态，例如 '成功', '失败', '待审核' 等。,
          "remark": ""          // 交易的额外信息或管理员的备注。,
          "tags": ""          // 用于分类或标记交易的标签。,
          "createDate": ""          // 货币交易发生的时间，默认为当前时间。
      }
    ]
}
字段名 类型 描述 是否必填
total integer - 否
data array - 否

UserCurrencyCurrencyTransResultApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
{
    "code": 200          // 状态码,
    "data": {
    "total": "0",
    "data": [
      {
          "id": "0"          // 货币交易记录的唯一标识符。,
          "fromUserID": "0"          // 发起交易的发送方用户ID，若为转账交易时必填。,
          "userID": "0"          // 进行货币交易的用户ID。,
          "transactionType": ""          // 货币交易的类型，例如 '消费', '奖励', '兑换', '转账' 等。,
          "currencyType": ""          // 交易的货币类型，例如 'USD', 'CNY' 等。,
          "currencyChange": "0"          // 货币的变动数量，正数表示增加，负数表示减少。,
          "currencyBalance": "0"          // 交易完成后的货币余额。,
          "description": ""          // 描述货币变动的具体原因或相关交易详情。,
          "status": ""          // 货币交易的当前状态，例如 '成功', '失败', '待审核' 等。,
          "remark": ""          // 交易的额外信息或管理员的备注。,
          "tags": ""          // 用于分类或标记交易的标签。,
          "createDate": ""          // 货币交易发生的时间，默认为当前时间。
      }
    ]
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

UserCurrencyListApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 用户资产的唯一标识符。,
          "userID": "0"          // 与用户资产关联的用户ID。,
          "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
          "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

通用错误码☍

错误码 说明
200 成功