# 简介
**Mefree.net** 是一家专注于为用户提供 **高效、便捷、价格实惠** 的波场（TRON）能量服务的专业平台。我们致力于帮助开发者和用户降低 TRON 链上操作成本，为您的 DApp 开发和链上交易提供充足的资源支持。
***
#### **我们的服务**
1. **波场能量租赁**
* 提供 TRON 链上的能量资源，帮助用户减少能量不足导致的交易失败或高手续费问题。
* 服务适用于个人用户、开发者及企业。
2. **快速交付**
* 实现能量的秒级到账，满足您的紧急需求。
3. **全天候支持**
* 专业客服团队提供 24/7 在线支持，随时解决您的疑问和问题。
***
#### **我们的优势**
1. **高效服务**
* 使用自动化技术，快速处理您的能量需求，让您无后顾之忧。
* 客服一直在线为您服务，及时解决您的问题。
2. **稳定可靠**
* 基于稳定的波场网络资源，确保服务始终可用。
* 自建波场节点，保证高峰期不卡壳。
3. **安全保障**
* 所有交易过程均经过严格加密，保障用户资产安全。
4. **便宜快捷**
* 为您节省超过70%的波场链上交易费用。
* 我们以市场为导向，提供灵活且具有竞争力的价格，确保物超所值。
***
#### **如何开始**
1. 访问我们的网站 [**Mefree.net**](https://mefree.net)。
2. 选择所需的能量套餐，并完成付款。
3. 等待能量自动分配到账，即可无忧使用。
4. 如需更高自助化服务，请登录我们的[**电报机器人 @SuperXCoinBot**](https://t.me/SuperXCoinBot)**。**
5. 如有任何问题，请联系在线客服([@mefreenet](https://t.me/mefreenet)) 。
***
选择 **Mefree.net**，为您的波场生态体验保驾护航！我们期待与您携手，共建更高效的区块链未来！
# 如何购买波场能量
Mefree.net 为用户提供两种便捷的能量购买方式，您可以选择 **直接转账购买** 或 **通过 API 购买**，根据需求快速获取所需的波场能量。以下是详细的购买指南：
***
#### **方法一：直接转账购买**
如果您希望快速购买能量并避免复杂的流程，可以选择直接转账方式。
**操作步骤：**
1. **确认接收地址**
* 请确保您的钱包地址已准备好接收能量，Mefree.net 系统会将购买的能量直接发送到您转账时使用的地址。
2. **转账至以下地址**：\
**`TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK`**
* 这是 Mefree.net 指定的收款地址。
3. **填写转账金额**
* 根据网站提供的能量价格表，选择您需要购买的能量数量，并转账相应的金额（TRX）。
* **注意：** 确保转账金额精确无误，否则可能导致能量分配异常。
4. **等待能量发送**
* 系统会在接收到转账后自动处理，**能量将在几秒钟内发送到您的钱包地址**。
* **无需手动申请**，购买过程自动完成，简单快捷。
***
#### **方法二：通过 API 购买**
如果您是开发者，或需要更高效、自动化的购买体验，可以通过调用 Mefree.net 提供的 API 实现能量购买。
请参阅[**API开发指南**](/zh/getting-started/how-to-buy-energy/buy-energy-by-api-quickstart)
***
#### **注意事项**
1. **确保资金充足**
* 无论使用哪种方式，请在发起购买前，确保您的钱包中有足够的 TRX 用于支付。
2. **转账金额精确**
* 如果选择直接转账购买，请严格按照 Mefree.net 网站的价格指引转账，避免因金额错误导致购买失败。
3. **API 调用安全**
* 如果使用 API，请妥善保管您的 **API Key**，避免密钥泄露导致账户安全风险。
4. **检查能量到账**
* 转账或 API 调用成功后，您可以在钱包中查看能量余额，确保资源已正确分配。
***
#### **两种方式对比**
| **购买方式** | **优点** | **适合人群** |
| ------------ | ---------------- | --------- |
| **直接转账购买** | 简单快捷，无需额外配置，到账迅速 | 普通用户、非开发者 |
| **API 调用购买** | 自动化、高效处理，可与程序集成 | 开发者、量化团队 |
***
通过以上两种方式，您可以轻松购买波场能量，满足链上交易和 DApp 运行的需求！如有疑问，请随时访问 [**Mefree.net**](https://mefree.net) 或联系客服获取帮助。
# 直接转账购买
以下是通过 **TronLink 钱包** 在 Mefree.net 直接转账购买能量的详细教程，只需简单几步，即可快速获取波场（TRON）能量。
***
#### **第一步：安装并配置 TronLink 钱包**
1. **安装 TronLink**
* 如果尚未安装 TronLink 钱包，请在 **Chrome 商店** 或手机应用商店搜索 **TronLink** 并安装。
* 下载地址：[TronLink 官方网站](https://www.tronlink.org/)
2. **创建或导入钱包**
* **新用户**：按照提示创建新钱包，备份助记词，设置钱包密码。
* **已有钱包**：选择导入钱包，输入助记词或私钥完成导入。
3. **确保钱包内有足够的 TRX**
* 确认钱包中存有足够的 TRX（用于支付购买能量的金额），并留有少量 TRX 用于手续费。
***
#### **第二步：确认 Mefree.net 的收款地址和价格**
1. **收款地址**\
Mefree.net 提供的指定能量购买收款地址为：\
**`TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK`**
* 该地址为系统专用，请勿向其他地址转账。
2. **能量价格**
* 登录 Mefree.net 查看当前的能量购买价格表。
* 选择您需要的能量数量，并计算所需转账金额（以 TRX 为单位）。
***
#### **第三步：在 TronLink 钱包进行转账操作**
1. **打开 TronLink 钱包**
* 在浏览器扩展或手机应用中打开 TronLink 钱包。
2. **进入转账页面**
* 点击 **“发送”** 或 **“Transfer”** 按钮，进入转账页面。
3. **填写转账信息**
* **收款地址**：粘贴 Mefree.net 提供的收款地址：\
**`TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK`**
* **转账金额**：填写根据购买需求计算的 TRX 金额。
* **备注（Memo）**：此项可留空，无需填写备注信息。
4. **确认并发送**
* 仔细核对收款地址和金额，确认无误后，点击 **“发送”** 按钮。
* 输入您的钱包密码或完成指纹验证，提交转账请求。
5. **等待转账完成**
* 转账通常会在几秒内完成，您可以在钱包的交易记录中查看交易状态。
***
#### **第四步：检查能量到账**
1. **等待系统处理**
* Mefree.net 系统会自动监控该收款地址的转账记录，一旦确认收到转账，能量将在几秒内发送至您的钱包地址。
2. **查看能量余额**
* 打开 TronLink 钱包，检查您的能量余额是否增加。
* 如果能量未及时到账，请确认转账信息无误并耐心等待，或联系客服寻求帮助。
***
#### **注意事项**
1. **确保收款地址正确**
* 收款地址 **`TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK`** 是固定的，请勿向其他地址转账。
2. **转账金额精准**
* 按照 Mefree.net 的价格指引计算金额，转账金额必须准确无误，否则可能导致能量分配失败或延迟。
3. **避免重复转账**
* 转账后，耐心等待能量到账，避免因重复操作导致多次支付。
4. **手续费留存**
* 转账时请确保账户中留有足够的 TRX 作为手续费，避免转账失败。
***
#### **常见问题**
1. **为什么能量未及时到账？**
* 检查是否转账到正确的地址并确认金额是否准确。
* 如果转账正常，但未收到能量，请联系 Mefree.net 客服提供转账哈希以核查。
2. **转账失败怎么办？**
* 确认钱包中是否有足够的 TRX 支付转账金额和手续费。
* 检查网络状态，确保钱包与区块链网络正常连接。
***
通过以上步骤，您可以轻松地使用 TronLink 钱包在 Mefree.net 直接购买波场能量，为您的链上操作提供资源支持！如有疑问，请访问 [**Mefree.net**](https://mefree.net) 或联系客服获取更多帮助。
# 使用API购买
本指南将帮助您快速上手如何连接并使用 Mefree.NET 的REST API。
***
#### **1. 准备工作**
**1.1 注册并获取 API 密钥**
1. 登录Mefree.NET的电报机器人（[@SuperXCoinBot](https://t.me/SuperXCoinBot)）。
2. 进入 **个人中心** 界面，点击 **API购买**：
* 保存 API KEY(API ACCESS KEY)。
* 保存秘钥(API SECRET)。
**1.2 工具准备**
* **测试工具**：Postman、Curl 或命令行工具。
* **开发环境**：Python（推荐使用 `requests` 库），或其他支持 HTTP 请求的编程语言。
**1.3 文档参考**
访问 [Mefree.NET官方API文档](/zh/api/config) 获取更详细的接口说明。
***
#### **2. API 基础知识**
**2.1 Base URL**
* **生产环境**：`https://api.mefree.net`
**2.2 API Headers**
所有请求需要添加以下 HTTP 头信息：
```plaintext
Content-Type: application/json
MF-ACCESS-KEY: 您的API Key
MF-ACCESS-SIGN: 请求签名（见后续签名规则）
MF-ACCESS-TIMESTAMP: 当前时间戳
```
**2.3 时间戳格式**
`MF-ACCESS-TIMESTAMP` 需使用 ISO 8601 格式的 UTC 时间，例如：`2023-01-01T12:00:00.000Z`。
**2.4 签名规则**
签名用于验证请求身份，生成签名的步骤：
1. 拼接待签名字符串：
```plaintext
sign = timestamp + method + requestPath
```
* `timestamp`：`MF-ACCESS-TIMESTAMP` 的值。
* `method`：HTTP 方法（如 GET、POST）。
* `requestPath`：请求的路径, :warning: **注意：如果有query参数一定要带上**
（如 `/api/config`、`/api/order?quantity=65000&period=1&target_address=Txxx...7n`）。
2. 使用 HMAC-SHA256 算法和 API 的 Secret Key 对签名字符串进行哈希处理。
3. 将结果用 Base64 编码，得到最终签名值。
***
#### **3. 快速请求示例**
以下是使用 Python 连接 Mefree API 的示例代码。
**3.1 准备代码环境**
确保已安装 `requests` 和 `datetime` 库：
```bash
pip install requests
```
**3.2 查询账户余额**
**请求说明**：
* URL: `GET /api/config`
* 功能：获取账户信息。
**代码实现：**
```python
import requests
import time
import base64
import hmac
import json
from datetime import datetime
# API 配置信息
BASE_URL = "https://api.mefree.net"
API_KEY = "your_api_key"
SECRET_KEY = "your_secret_key"
# 签名生成函数
def generate_signature(timestamp, method, request_path, secret_key):
message = f"{timestamp}{method}{request_path}"
mac = hmac.new(secret_key.encode('utf-8'), message.encode('utf-8'), digestmod='sha256')
return base64.b64encode(mac.digest()).decode()
# 当前 UTC 时间戳
timestamp = datetime.utcnow().isoformat(timespec='milliseconds') + 'Z'
# 设置请求信息
method = "GET"
request_path = "/api/config"
url = BASE_URL + request_path
body = None # GET 请求无需 Body
# 生成签名
signature = generate_signature(timestamp, method, request_path, SECRET_KEY)
# 请求头
headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
}
# 发起请求
response = requests.get(url, headers=headers)
if response.status_code == 200:
print("账户信息：", response.json())
else:
print("请求失败：", response.status_code, response.text)
```
**3.3 下单交易示例**
**请求说明**：
* URL: `POST /api/order`
* 功能：购买能量。
**代码实现：**
```python
# 生成签名
timestamp = datetime.utcnow().isoformat(timespec='milliseconds') + 'Z'
method = "POST"
request_path = "/api/order?quantity=65000&target_address=TDYk....4rnPfkdPZ&period=1"
signature = generate_signature(timestamp, method, request_path, SECRET_KEY)
# 请求头
headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
}
# 发起请求
response = requests.post(BASE_URL + request_path, headers=headers, json=body)
if response.status_code == 200:
print("订单已创建：", response.json())
else:
print("请求失败：", response.status_code, response.text)
```
***
#### **4. 常见问题与解决方法**
1. **HTTP 状态码 401 Unauthorized**：
* 检查 `MF-ACCESS-KEY`、`MF-ACCESS-SIGN` 是否正确。
* 确保 API 密钥权限已启用。
2. **HTTP 状态码 400 Bad Request**：
* 检查请求参数是否正确（如交易对、价格、数量等）。
3. **签名错误**：
* 确保时间戳使用 UTC 时间，并严格按照签名规则生成签名。
***
#### **5. 后续操作**
* 阅读 [Mefree API 文档](/zh/api/config)，熟悉更多功能接口（如获取订单详情，可用能量等）。
* 根据需求，扩展 API 的集成功能，开发私有能量交易系统。
通过本指南，您已完成连接Mefree API 的基本操作。祝您一切顺利！
# Java调用Mefree.NET API
本指南详细介绍如何使用 **Java** 实现对 Mefree.NET API 的调用，包括生成签名的方法、构建 HTTP 请求以及完整的调用流程。
***
#### **1. 签名规则概述**
Mefree.NET API 使用签名机制对请求进行身份验证。以下是签名的详细规则：
**1.1 签名字符串规则**
签名生成的格式如下：
```
sign = timestamp + method + requestPath
```
* **timestamp**：UTC 时间，格式为 ISO 8601，例如：`2024-11-26T12:34:56.789Z`。
* **method**：HTTP 方法，例如 `GET` 或 `POST`。
* **requestPath**：API 请求路径（包括查询参数），例如：
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 签名生成流程**
1. 拼接签名字符串，格式为 `timestamp + method + requestPath`。
2. 使用 **HMAC-SHA256** 算法，用 API 的 **Secret Key** 对拼接的字符串进行加密。
3. 对加密结果进行 **Base64** 编码，生成最终的签名。
**1.3 请求头参数**
每次请求需要包含以下 HTTP 头：
* `Content-Type: application/json`
* `MF-ACCESS-KEY`: 您的 API Key。
* `MF-ACCESS-SIGN`: 生成的签名值。
* `MF-ACCESS-TIMESTAMP`: 当前的 UTC 时间戳。
***
#### **2. Java实现签名方法**
**2.1 签名生成函数**
以下代码展示了如何用 Java 生成 API 的签名：
```java
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class MefreeApiUtils {
/**
* 生成 Mefree API 的签名
* @param timestamp UTC 时间戳 (ISO 8601 格式)
* @param method HTTP 方法 (GET/POST)
* @param requestPath API 请求路径（含参数）
* @param secretKey API 的 Secret Key
* @return 签名字符串 (Base64 编码)
* @throws Exception
*/
public static String generateSignature(String timestamp, String method, String requestPath, String secretKey) throws Exception {
// 拼接待签名字符串
String stringToSign = timestamp + method + requestPath;
// 使用 HMAC-SHA256 生成签名
Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes("UTF-8"), "HmacSHA256");
sha256_HMAC.init(secretKeySpec);
// 加密并进行 Base64 编码
byte[] hash = sha256_HMAC.doFinal(stringToSign.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(hash);
}
}
```
***
#### **3. API 请求构建**
**3.1 基础配置**
在 Java 项目中，定义以下常量用于配置 API 的基础信息：
```java
// Mefree API 配置信息
public class Config {
public static final String BASE_URL = "https://api.mefree.net"; // Mefree API 基础地址
public static final String API_KEY = "your_api_key"; // 替换为实际的 API Key
public static final String SECRET_KEY = "your_secret_key"; // 替换为实际的 Secret Key
}
```
**3.2 通用请求方法**
使用 **HttpURLConnection** 构建通用的 HTTP 请求方法：
```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class HttpRequestUtil {
/**
* 发起 API 请求
* @param method HTTP 方法 (GET/POST)
* @param requestPath API 请求路径（含参数）
* @param apiKey API Key
* @param secretKey Secret Key
* @return 响应内容
* @throws Exception
*/
public static String sendRequest(String method, String requestPath, String apiKey, String secretKey) throws Exception {
// 当前 UTC 时间戳
String timestamp = java.time.Instant.now().toString();
// 生成签名
String signature = MefreeApiUtils.generateSignature(timestamp, method, requestPath, secretKey);
// 构造 URL
URL url = new URL(Config.BASE_URL + requestPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 设置请求方法和头信息
conn.setRequestMethod(method);
conn.setRequestProperty("Content-Type", "application/json");
conn.setRequestProperty("MF-ACCESS-KEY", apiKey);
conn.setRequestProperty("MF-ACCESS-SIGN", signature);
conn.setRequestProperty("MF-ACCESS-TIMESTAMP", timestamp);
// 读取响应
int responseCode = conn.getResponseCode();
BufferedReader br = new BufferedReader(new InputStreamReader(
(responseCode < 400) ? conn.getInputStream() : conn.getErrorStream()
));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
return response.toString();
}
}
```
***
#### **4. 示例接口调用**
**4.1 获取账户信息**
**接口描述**：
* 请求路径：`/api/config`
* HTTP 方法：`GET`
**调用代码**：
```java
public class Main {
public static void main(String[] args) {
try {
String response = HttpRequestUtil.sendRequest("GET", "/api/config", Config.API_KEY, Config.SECRET_KEY);
System.out.println("账户信息: " + response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
***
**4.2 创建订单**
**接口描述**：
* 请求路径：`/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* HTTP 方法：`POST`
**调用代码**：
```java
public class Main {
public static void main(String[] args) {
try {
String requestPath = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1";
String response = HttpRequestUtil.sendRequest("POST", requestPath, Config.API_KEY, Config.SECRET_KEY);
System.out.println("订单已创建: " + response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
***
**4.3 查询订单状态**
**接口描述**：
* 请求路径：`/api/order/{pay_hash}`
* HTTP 方法：`GET`
**调用代码**：
```java
public class Main {
public static void main(String[] args) {
try {
String payHash = "abcd1234"; // 替换为实际的 pay_hash
String requestPath = "/api/order/" + payHash;
String response = HttpRequestUtil.sendRequest("GET", requestPath, Config.API_KEY, Config.SECRET_KEY);
System.out.println("订单状态: " + response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
***
#### **5. 常见问题**
**5.1 签名无效 (401 Unauthorized)**
* 确认 `MF-ACCESS-KEY` 是否正确。
* 确保签名按照规则生成：
* 拼接顺序为：`timestamp + method + requestPath`。
* 时间戳格式是否为 UTC。
* 使用正确的 `SECRET_KEY`。
**5.2 请求参数错误 (400 Bad Request)**
* 检查请求路径是否正确，尤其是查询参数是否完整。
* 确认 `Content-Type` 是否为 `application/json`。
**5.3 请求频率限制 (429 Too Many Requests)**
* 添加合理的请求间隔（例如每秒最多 2 次请求）。
***
#### **6. 总结**
通过本指南，您可以使用 Java 实现对 Mefree.NET API 的调用，包括生成签名、发送请求和解析响应数据。对重要的操作（如订单创建）建议添加重试机制，确保请求可靠性。如遇问题，请联系 Mefree 官方支持团队。
# Python调用Mefree.NET API
本指南介绍如何使用 **Python** 调用 Mefree.NET API，包括生成签名的方法、构建 HTTP 请求，以及调用示例。
***
#### **1. 签名规则概述**
Mefree.NET API 使用签名机制对请求进行身份验证。以下是签名规则的详细说明：
**1.1 签名字符串规则**
签名生成的格式如下：
```
sign = timestamp + method + requestPath
```
* **timestamp**：UTC 时间，格式为 ISO 8601，例如：`2024-11-26T12:34:56.789Z`。
* **method**：HTTP 方法，例如 `GET` 或 `POST`。
* **requestPath**：API 请求路径（包括查询参数），例如：
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 签名生成流程**
1. 拼接签名字符串，格式为 `timestamp + method + requestPath`。
2. 使用 **HMAC-SHA256** 算法，结合 API 的 **Secret Key** 对拼接字符串进行加密。
3. 将加密结果用 **Base64** 编码，生成最终的签名。
**1.3 请求头参数**
每次请求需要包含以下 HTTP 头：
* `Content-Type: application/json`
* `MF-ACCESS-KEY`: 您的 API Key。
* `MF-ACCESS-SIGN`: 生成的签名值。
* `MF-ACCESS-TIMESTAMP`: 当前的 UTC 时间戳。
***
#### **2. Python实现签名方法**
**2.1 签名生成函数**
以下代码展示了如何用 Python 生成 API 的签名：
```python
import hmac
import hashlib
import base64
from datetime import datetime, timezone
def generate_signature(timestamp, method, request_path, secret_key):
"""
生成 Mefree API 的签名
:param timestamp: 当前 UTC 时间戳 (ISO 8601 格式)
:param method: HTTP 方法 (GET/POST)
:param request_path: API 请求路径（含参数）
:param secret_key: API 的 Secret Key
:return: 签名字符串 (Base64 编码)
"""
# 拼接待签名字符串
string_to_sign = timestamp + method + request_path
# 使用 HMAC-SHA256 生成签名
signature = hmac.new(
secret_key.encode('utf-8'),
string_to_sign.encode('utf-8'),
hashlib.sha256
).digest()
# 返回 Base64 编码的签名
return base64.b64encode(signature).decode('utf-8')
```
**2.2 获取 UTC 时间戳**
```python
def get_utc_timestamp():
"""
获取当前 UTC 时间戳 (ISO 8601 格式)
"""
return datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
```
***
#### **3. 通用请求方法**
使用 **requests** 库构建通用的 HTTP 请求方法。
```python
import requests
BASE_URL = "https://api.mefree.net" # Mefree API 基础地址
API_KEY = "your_api_key" # 替换为您的 API Key
SECRET_KEY = "your_secret_key" # 替换为您的 Secret Key
def send_request(method, request_path):
"""
发起 API 请求
:param method: HTTP 方法 (GET/POST)
:param request_path: API 请求路径（含参数）
:return: 响应内容
"""
try:
# 获取当前 UTC 时间戳
timestamp = get_utc_timestamp()
# 生成签名
signature = generate_signature(timestamp, method, request_path, SECRET_KEY)
# 构造请求头
headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
}
# 构造完整 URL
url = BASE_URL + request_path
# 发起请求
if method == "GET":
response = requests.get(url, headers=headers)
elif method == "POST":
response = requests.post(url, headers=headers, json={}) # POST 请求无 body 数据
# 返回响应内容
return response.json()
except Exception as e:
print(f"请求失败: {e}")
return None
```
***
#### **4. 示例接口调用**
**4.1 获取账户信息**
**接口描述**：
* 请求路径：`/api/config`
* HTTP 方法：`GET`
**调用代码**：
```python
if __name__ == "__main__":
response = send_request("GET", "/api/config")
print("账户信息:", response)
```
***
**4.2 创建订单**
**接口描述**：
* 请求路径：`/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* HTTP 方法：`POST`
**调用代码**：
```python
if __name__ == "__main__":
request_path = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"
response = send_request("POST", request_path)
print("订单已创建:", response)
```
***
**4.3 查询订单状态**
**接口描述**：
* 请求路径：`/api/order/{pay_hash}`
* HTTP 方法：`GET`
**调用代码**：
```python
if __name__ == "__main__":
pay_hash = "abcd1234" # 替换为实际的 pay_hash
request_path = f"/api/order/{pay_hash}"
response = send_request("GET", request_path)
print("订单状态:", response)
```
***
#### **5. 常见问题**
**5.1 签名无效 (401 Unauthorized)**
* 确认 `MF-ACCESS-KEY` 是否正确。
* 确保签名按照规则生成：
* 拼接顺序为：`timestamp + method + requestPath`。
* 时间戳格式是否为 UTC。
* 使用正确的 `SECRET_KEY`。
**5.2 请求参数错误 (400 Bad Request)**
* 检查请求路径是否正确，尤其是查询参数是否完整。
* 确认 `Content-Type` 是否为 `application/json`。
**5.3 请求频率限制 (429 Too Many Requests)**
* 添加合理的请求间隔（例如每秒最多 2 次请求）。
***
#### **6. 总结**
通过本指南，您可以使用 Python 调用 Mefree.NET API，包括生成签名、构建请求以及解析响应数据。对于重要操作（如订单创建），建议添加重试机制，提升调用的可靠性。如有疑问，请联系 Mefree 官方支持团队。
# Node.js 调用 Mefree.NET API
本指南介绍如何使用 **Node.js** 调用 Mefree.NET API，包括签名生成、HTTP 请求构建，以及接口调用示例。
***
#### **1. 签名规则概述**
**1.1 签名字符串规则**
Mefree.NET API 使用签名机制验证身份，请确保按照以下规则生成签名：
1. 拼接待签名字符串：
```
sign = timestamp + method + requestPath
```
* **timestamp**：UTC 时间，格式为 ISO 8601，例如：`2024-11-26T12:34:56.789Z`。
* **method**：HTTP 方法，例如 `GET` 或 `POST`。
* **requestPath**：API 请求路径（包括查询参数），例如：
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
2. 使用 **HMAC-SHA256** 算法，结合 API 的 **Secret Key** 对拼接字符串进行加密。
3. 将加密结果用 **Base64** 编码，得到最终的签名值。
***
**1.2 请求头参数**
每个请求必须包含以下 HTTP 头：
* `Content-Type: application/json`
* `MF-ACCESS-KEY`: 您的 API Key。
* `MF-ACCESS-SIGN`: 生成的签名值。
* `MF-ACCESS-TIMESTAMP`: 当前 UTC 时间戳。
***
#### **2. 环境准备**
确保您的开发环境已安装 **Node.js** 和 **npm**。以下是需要安装的依赖包：
```bash
npm install axios crypto dayjs
```
***
#### **3. 签名生成方法**
以下是基于 **Node.js** 的签名生成方法：
```javascript
const crypto = require("crypto");
const dayjs = require("dayjs");
const utc = require("dayjs/plugin/utc");
dayjs.extend(utc);
/**
* 生成签名
* @param {string} timestamp - UTC 时间戳
* @param {string} method - HTTP 方法 (GET/POST)
* @param {string} requestPath - 请求路径
* @param {string} secretKey - API 的 Secret Key
* @returns {string} 签名字符串
*/
function generateSignature(timestamp, method, requestPath, secretKey) {
const stringToSign = `${timestamp}${method}${requestPath}`;
const hmac = crypto.createHmac("sha256", secretKey);
hmac.update(stringToSign);
return hmac.digest("base64");
}
/**
* 获取当前 UTC 时间戳 (ISO 8601 格式)
* @returns {string} UTC 时间戳
*/
function getUtcTimestamp() {
return dayjs.utc().format("YYYY-MM-DDTHH:mm:ss.SSS[Z]");
}
```
***
#### **4. 通用请求方法**
以下代码展示了一个通用的 HTTP 请求函数，使用 **axios** 库发起 API 调用。
```javascript
const axios = require("axios");
// 配置基础信息
const BASE_URL = "https://api.mefree.net"; // Mefree API 基础地址
const API_KEY = "your_api_key"; // 替换为您的 API Key
const SECRET_KEY = "your_secret_key"; // 替换为您的 Secret Key
/**
* 发送 API 请求
* @param {string} method - HTTP 方法 (GET/POST)
* @param {string} requestPath - 请求路径（包括参数）
* @returns {object} 响应数据
*/
async function sendRequest(method, requestPath) {
try {
// 获取当前 UTC 时间戳
const timestamp = getUtcTimestamp();
// 生成签名
const signature = generateSignature(timestamp, method, requestPath, SECRET_KEY);
// 构造请求头
const headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
};
// 构造完整 URL
const url = `${BASE_URL}${requestPath}`;
// 发起请求
const response = await axios({
method,
url,
headers,
});
// 返回响应数据
return response.data;
} catch (error) {
console.error("请求失败：", error.response?.data || error.message);
return null;
}
}
```
***
#### **5. 示例接口调用**
**5.1 获取账户信息**
**接口描述**：
* 请求路径：`/api/config`
* HTTP 方法：`GET`
**调用代码**：
```javascript
(async () => {
const response = await sendRequest("GET", "/api/config");
console.log("账户信息：", response);
})();
```
***
**5.2 创建订单**
**接口描述**：
* 请求路径：`/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* HTTP 方法：`POST`
**调用代码**：
```javascript
(async () => {
const requestPath = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1";
const response = await sendRequest("POST", requestPath);
console.log("订单已创建：", response);
})();
```
***
**5.3 查询订单状态**
**接口描述**：
* 请求路径：`/api/order/{pay_hash}`
* HTTP 方法：`GET`
**调用代码**：
```javascript
(async () => {
const payHash = "abcd1234"; // 替换为实际的 pay_hash
const requestPath = `/api/order/${payHash}`;
const response = await sendRequest("GET", requestPath);
console.log("订单状态：", response);
})();
```
***
#### **6. 常见问题**
**6.1 签名无效 (401 Unauthorized)**
* 确认 `MF-ACCESS-KEY` 是否正确。
* 确保签名按照规则生成：
* 拼接顺序为：`timestamp + method + requestPath`。
* 时间戳格式是否为 UTC。
* 使用正确的 `SECRET_KEY`。
**6.2 请求参数错误 (400 Bad Request)**
* 检查请求路径是否正确，尤其是查询参数是否完整。
* 确认 `Content-Type` 是否为 `application/json`。
**6.3 请求频率限制 (429 Too Many Requests)**
* 添加合理的请求间隔（例如每秒最多 2 次请求）。
***
#### **7. 总结**
通过本指南，您可以使用 **Node.js** 调用 Mefree.NET API，包括生成签名、构建请求以及解析响应数据。对于重要操作（如订单创建），建议添加重试机制以提高调用的可靠性。如有问题，请联系 Mefree 官方支持团队。
# PHP调用Mefree.NET API
本指南将详细介绍如何通过PHP实现对Mefree.NET的API调用，包括生成签名的方法、请求的构建以及接口调用的完整流程。
***
#### **1. 签名规则概述**
Mefree.NET API 的身份验证通过签名机制进行，签名的生成逻辑如下：
**1.1 签名字符串规则**
签名使用以下格式的字符串：
```
sign = timestamp + method + requestPath
```
* **timestamp**：UTC 时间，格式为 ISO 8601（例如：`2024-11-26T12:34:56.789Z`）。
* **method**：HTTP 方法，如 `GET` 或 `POST`。
* **requestPath**：API 请求路径（包括查询参数），例如：
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 签名生成流程**
1. 使用 **HMAC-SHA256** 算法，用 API 的 **Secret Key** 对拼接的字符串进行加密。
2. 将加密结果用 **Base64** 编码，得到签名值。
**1.3 请求头参数**
每次请求需要添加以下 HTTP 头：
* `Content-Type: application/json`
* `MF-ACCESS-KEY`: 您的 API Key。
* `MF-ACCESS-SIGN`: 生成的签名值。
* `MF-ACCESS-TIMESTAMP`: 当前的 UTC 时间戳。
***
#### **2. PHP实现签名方法**
**2.1 签名生成函数**
```php
/**
* 生成 Mefree API 的签名
* @param string $timestamp UTC 时间戳 (ISO 8601 格式)
* @param string $method HTTP 方法 (GET/POST)
* @param string $request_path API 请求路径（含参数）
* @param string $secret_key API 的 Secret Key
* @return string 返回 Base64 编码的签名
*/
function generate_signature($timestamp, $method, $request_path, $secret_key) {
// 拼接待签名字符串
$string_to_sign = $timestamp . $method . $request_path;
// 使用 HMAC-SHA256 算法对字符串进行加密
$hash = hash_hmac('sha256', $string_to_sign, $secret_key, true);
// 返回 Base64 编码的签名
return base64_encode($hash);
}
```
***
#### **3. API 请求构建**
**3.1 基础配置**
配置 API 的基础信息：
```php
// API 配置信息
$base_url = "https://api.mefree.net"; // Mefree API 基础地址
$api_key = "your_api_key"; // 替换为实际的 API Key
$secret_key = "your_secret_key"; // 替换为实际的 Secret Key
```
**3.2 发起请求的函数**
使用 `CURL` 构建通用的 HTTP 请求函数：
```php
/**
* 发起 Mefree API 请求
* @param string $method HTTP 方法 (GET/POST)
* @param string $request_path API 请求路径（含查询参数）
* @param string $base_url API 基础 URL
* @param string $api_key API Key
* @param string $secret_key API Secret Key
* @return mixed 返回 API 响应内容
*/
function send_request($method, $request_path, $base_url, $api_key, $secret_key) {
// 当前 UTC 时间戳
$timestamp = gmdate("Y-m-d\TH:i:s.v\Z");
// 生成签名
$signature = generate_signature($timestamp, $method, $request_path, $secret_key);
// 设置请求头
$headers = [
"Content-Type: application/json",
"MF-ACCESS-KEY: {$api_key}",
"MF-ACCESS-SIGN: {$signature}",
"MF-ACCESS-TIMESTAMP: {$timestamp}",
];
// 初始化 CURL
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $base_url . $request_path); // 设置 URL
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method); // 设置请求方法
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers); // 设置请求头
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); // 返回响应内容
// 执行请求
$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE); // 获取 HTTP 状态码
curl_close($ch);
// 返回结果
return [
"status_code" => $http_code,
"response" => $response
];
}
```
***
#### **4. 示例接口调用**
**4.1 获取账户信息**
**接口描述**：
* 请求路径：`/api/config`
* HTTP 方法：`GET`
**调用代码**：
```php
// 获取账户信息
$request_path = "/api/config"; // API 请求路径
$response = send_request("GET", $request_path, $base_url, $api_key, $secret_key);
// 处理返回结果
if ($response['status_code'] == 200) {
echo "账户信息：\n";
echo $response['response'];
} else {
echo "请求失败，HTTP 状态码：" . $response['status_code'] . "\n";
echo "响应内容：" . $response['response'];
}
```
***
**4.2 创建订单**
**接口描述**：
* 请求路径：`/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* HTTP 方法：`POST`
**调用代码**：
```php
// 创建订单
$request_path = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"; // API 请求路径
$response = send_request("POST", $request_path, $base_url, $api_key, $secret_key);
// 处理返回结果
if ($response['status_code'] == 200) {
echo "订单已创建：\n";
echo $response['response'];
} else {
echo "请求失败，HTTP 状态码：" . $response['status_code'] . "\n";
echo "响应内容：" . $response['response'];
}
```
***
**4.3 查询订单状态**
**接口描述**：
* 请求路径：`/api/order/{pay_hash}`
* HTTP 方法：`GET`
**调用代码**：
```php
// 查询订单状态
$pay_hash = "abcd1234"; // 替换为实际订单的 pay_hash
$request_path = "/api/order/" . $pay_hash; // API 请求路径
$response = send_request("GET", $request_path, $base_url, $api_key, $secret_key);
// 处理返回结果
if ($response['status_code'] == 200) {
echo "订单状态：\n";
echo $response['response'];
} else {
echo "请求失败，HTTP 状态码：" . $response['status_code'] . "\n";
echo "响应内容：" . $response['response'];
}
```
***
#### **5. 常见问题**
**5.1 签名无效 (401 Unauthorized)**
* 确认 `MF-ACCESS-KEY` 是否正确。
* 确保签名按照规则生成：
* 拼接顺序为：`timestamp + method + requestPath`。
* 时间戳需为 UTC 格式，格式示例：`2024-11-26T12:34:56.789Z`。
* 使用正确的 `SECRET_KEY` 生成签名。
**5.2 请求参数错误 (400 Bad Request)**
* 检查请求路径是否正确，尤其是查询参数是否完整。
* 确认 `Content-Type` 是否为 `application/json`。
**5.3 请求速率限制 (429 Too Many Requests)**
* Mefree API 对请求频率有限制，需避免在短时间内发起大量请求。
* 添加合理的请求间隔（例如每秒最多 2 次请求）。
***
#### **6. 总结**
通过以上文档，您可以使用 PHP 高效实现对 Mefree.NET API 的调用，包括生成签名、发送请求以及解析响应数据。对重要操作（如下单）时，建议加上重试机制以提高稳定性。如有疑问，请联系 Mefree 官方支持团队。
# Go语言调用 Mefree.NET API
本指南介绍如何使用 **Go语言** 调用 Mefree.NET API，包括签名生成、HTTP 请求构建以及接口调用示例。
***
#### **1. 签名规则概述**
**1.1 签名字符串规则**
Mefree.NET API 使用签名机制验证身份，请确保按照以下规则生成签名：
1. 拼接待签名字符串：
```
sign = timestamp + method + requestPath
```
* **timestamp**：UTC 时间，格式为 ISO 8601，例如：`2024-11-26T12:34:56.789Z`。
* **method**：HTTP 方法，例如 `GET` 或 `POST`。
* **requestPath**：API 请求路径（包括查询参数），例如：
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
2. 使用 **HMAC-SHA256** 算法，结合 API 的 **Secret Key** 对拼接字符串进行加密。
3. 将加密结果用 **Base64** 编码，得到最终的签名值。
***
**1.2 请求头参数**
每个请求必须包含以下 HTTP 头：
* `Content-Type: application/json`
* `MF-ACCESS-KEY`: 您的 API Key。
* `MF-ACCESS-SIGN`: 生成的签名值。
* `MF-ACCESS-TIMESTAMP`: 当前 UTC 时间戳。
***
#### **2. 环境准备**
确保您的开发环境已安装 **Go**。以下是需要导入的标准库和第三方库：
* **`crypto/hmac`**：用于生成 HMAC 签名。
* **`crypto/sha256`**：用于计算 SHA256 哈希。
* **`encoding/base64`**：用于 Base64 编码。
* **`time`**：用于获取 UTC 时间戳。
* **`net/http` 和 `io/ioutil`**：用于发送 HTTP 请求。
***
#### **3. 签名生成方法**
以下是基于 Go 语言的签名生成方法：
```go
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"fmt"
"time"
)
// 生成签名
func generateSignature(timestamp, method, requestPath, secretKey string) string {
message := timestamp + method + requestPath
h := hmac.New(sha256.New, []byte(secretKey))
h.Write([]byte(message))
signature := base64.StdEncoding.EncodeToString(h.Sum(nil))
return signature
}
// 获取当前 UTC 时间戳（ISO 8601 格式）
func getUtcTimestamp() string {
return time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
}
```
***
#### **4. 通用请求方法**
以下代码展示了一个通用的 HTTP 请求函数，包含签名生成和请求头构建：
```go
package main
import (
"bytes"
"fmt"
"io/ioutil"
"net/http"
)
// 配置基础信息
const (
BASE_URL = "https://api.mefree.net"
API_KEY = "your_api_key" // 替换为您的 API Key
SECRET_KEY = "your_secret_key" // 替换为您的 Secret Key
)
// 发送 API 请求
func sendRequest(method, requestPath string) ([]byte, error) {
// 获取当前 UTC 时间戳
timestamp := getUtcTimestamp()
// 生成签名
signature := generateSignature(timestamp, method, requestPath, SECRET_KEY)
// 构造请求
client := &http.Client{}
url := BASE_URL + requestPath
req, err := http.NewRequest(method, url, nil)
if err != nil {
return nil, err
}
// 添加请求头
req.Header.Add("Content-Type", "application/json")
req.Header.Add("MF-ACCESS-KEY", API_KEY)
req.Header.Add("MF-ACCESS-SIGN", signature)
req.Header.Add("MF-ACCESS-TIMESTAMP", timestamp)
// 发送请求
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
// 读取响应
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
}
return body, nil
}
```
***
#### **5. 示例接口调用**
**5.1 获取账户信息**
**接口描述**：
* 请求路径：`/api/config`
* HTTP 方法：`GET`
**调用代码**：
```go
func main() {
response, err := sendRequest("GET", "/api/config")
if err != nil {
fmt.Println("请求失败：", err)
return
}
fmt.Println("账户信息：", string(response))
}
```
***
**5.2 创建订单**
**接口描述**：
* 请求路径：`/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* HTTP 方法：`POST`
**调用代码**：
```go
func main() {
requestPath := "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"
response, err := sendRequest("POST", requestPath)
if err != nil {
fmt.Println("请求失败：", err)
return
}
fmt.Println("订单已创建：", string(response))
}
```
***
**5.3 查询订单状态**
**接口描述**：
* 请求路径：`/api/order/{pay_hash}`
* HTTP 方法：`GET`
**调用代码**：
```go
func main() {
payHash := "abcd1234" // 替换为实际的 pay_hash
requestPath := fmt.Sprintf("/api/order/%s", payHash)
response, err := sendRequest("GET", requestPath)
if err != nil {
fmt.Println("请求失败：", err)
return
}
fmt.Println("订单状态：", string(response))
}
```
***
#### **6. 常见问题**
**6.1 签名无效 (401 Unauthorized)**
* 确认 `MF-ACCESS-KEY` 是否正确。
* 确保签名按照规则生成：
* 拼接顺序为：`timestamp + method + requestPath`。
* 时间戳格式是否为 UTC。
* 使用正确的 `SECRET_KEY`。
**6.2 请求参数错误 (400 Bad Request)**
* 检查请求路径是否正确，尤其是查询参数是否完整。
* 确认 `Content-Type` 是否为 `application/json`。
**6.3 请求频率限制 (429 Too Many Requests)**
* 添加合理的请求间隔（例如每秒最多 2 次请求）。
***
#### **7. 总结**
通过本指南，您可以使用 **Go语言** 调用 Mefree.NET API，包括生成签名、构建请求以及解析响应数据。建议为重要操作（如订单创建）添加重试机制，提高调用可靠性。如有问题，请联系 Mefree 官方支持团队。
# 常见问题
#### **1. 账户与权限相关问题**
**1.1 为什么我的 API 密钥无法使用？**
* **原因**：
* API 密钥可能已被禁用或删除。
* **解决方案**：
1. 登录 [mefree电报机器人](https://t.me/SuperXCoinBot)，检查您的 API 密钥状态是否有效。
**1.2 如何为 API 密钥启用仅特定 IP 访问？**
* **解决方案**： 在创建或编辑 API 密钥时，填写您想绑定的 IP 地址。这样，API 密钥仅允许来自该 IP 地址的请求，提升安全性。
***
#### **2. 签名与身份验证问题**
**2.1 为什么返回 `401 Unauthorized`？**
* **原因**：
* `MF-ACCESS-KEY`、`MF-ACCESS-SIGN` 错误。
* 签名生成不正确。
* 时间戳偏差超过 5 秒。
* **解决方案**：
1. 确保 `MF-ACCESS-KEY` 与展示的API Key一致。
2. 确保签名按照 签名规则 生成，并验证生成逻辑。
3. 确保 `MF-ACCESS-TIMESTAMP` 是标准的 UTC 时间戳，且与服务器时间偏差小于 5 秒。
**2.2 签名生成如何检查？**
* **解决方案**：
1. 打印拼接的待签名字符串（`timestamp + method + requestPath`）。
2. 对比生成的签名和本地手动计算的签名是否一致。
校验例子:
timestamp = "2008-08-08T08:08:08.888Z"
method = "GET"
requestPath = "/api/config"
待签名字符串 = "2008-08-08T08:08:08.888ZGET/api/config"
SECRET_KEY = "8d3c3c07a47186c9d6d352d287263cf3"
通过调用API例子中 generate_signature()方法得到签名值SIGN是否跟下面字符串一致：
jY+BLq8s2cAFQmEDp1rbZw0PPG9Np67cmbmS7rhSdyw=
} - The JSON response from the API.
*/
async function sendRequest(method, requestPath) {
const timestamp = getUtcTimestamp();
const signature = generateSignature(timestamp, method, requestPath, SECRET_KEY);
const headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
};
const url = `${BASE_URL}${requestPath}`;
try {
const response = await axios({
method,
url,
headers,
});
return response.data;
} catch (error) {
console.error("Request failed:", error.response?.data || error.message);
throw error;
}
}
```
***
#### **5. Example API Calls**
**5.1 Get Account Information**
**API Endpoint**: `/api/config`\
**HTTP Method**: `GET`
**Code Example**:
```javascript
(async () => {
try {
const response = await sendRequest("GET", "/api/config");
console.log("Account Information:", response);
} catch (error) {
console.error("Failed to fetch account information.");
}
})();
```
***
**5.2 Create an Order**
**API Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`\
**HTTP Method**: `POST`
**Code Example**:
```javascript
(async () => {
try {
const requestPath = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1";
const response = await sendRequest("POST", requestPath);
console.log("Order Created:", response);
} catch (error) {
console.error("Failed to create order.");
}
})();
```
***
**5.3 Query Order Status**
**API Endpoint**: `/api/order/{pay_hash}`\
**HTTP Method**: `GET`
**Code Example**:
```javascript
(async () => {
try {
const payHash = "abcd1234"; // Replace with the actual pay_hash
const requestPath = `/api/order/${payHash}`;
const response = await sendRequest("GET", requestPath);
console.log("Order Status:", response);
} catch (error) {
console.error("Failed to fetch order status.");
}
})();
```
***
#### **6. Common Issues**
**6.1 Invalid Signature (401 Unauthorized)**
* Double-check the `MF-ACCESS-KEY` matches your API Key.
* Verify the signature generation logic:
* Ensure the string format is `timestamp + method + requestPath`.
* Use the correct `SECRET_KEY`.
* Ensure the timestamp is in UTC format and not older than 5 seconds.
**6.2 Bad Request (400)**
* Check that the request path and query parameters are correct.
* Ensure the `Content-Type` header is set to `application/json`.
**6.3 Too Many Requests (429)**
* Respect the API rate limits. Add throttling in your code if necessary.
***
#### **7. Summary**
This guide demonstrates how to interact with the Mefree.NET API using Node.js. It includes the signature generation logic, HTTP request handling, and examples for common API calls. For additional support, refer to the [official API documentation](https://mefree.net/) or contact Mefree support.
# PHP Guide for calling Mefree.NET API
This guide provides detailed instructions on using **PHP** to interact with the Mefree.NET API, including generating signatures, building requests, and completing the API call flow.
***
#### **1. Signature Rules Overview**
Mefree.NET API uses a signature-based authentication mechanism. The signature is generated using the following logic:
**1.1 Signature String Rules**
The signature string is created in the following format:
```
sign = timestamp + method + requestPath
```
* **timestamp**: UTC time in ISO 8601 format (e.g., `2024-11-26T12:34:56.789Z`).
* **method**: HTTP method, such as `GET` or `POST`.
* **requestPath**: API request path (including query parameters), for example:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Signature Generation Process**
1. Concatenate `timestamp`, `method`, and `requestPath` into a string.
2. Use the **HMAC-SHA256** algorithm to encrypt the concatenated string with your **API Secret Key**.
3. Encode the resulting hash using **Base64** to generate the signature.
**1.3 Required HTTP Headers**
Each API request must include the following headers:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Your API Key.
* `MF-ACCESS-SIGN`: The generated signature.
* `MF-ACCESS-TIMESTAMP`: Current UTC timestamp.
***
#### **2. Implementing Signature in PHP**
**2.1 Signature Generation Function**
Here’s how to generate the signature in PHP:
```php
/**
* Generate Mefree API signature
*
* @param string $timestamp UTC timestamp (ISO 8601 format)
* @param string $method HTTP method (GET/POST)
* @param string $request_path API request path (with parameters)
* @param string $secret_key API Secret Key
* @return string Base64-encoded signature
*/
function generate_signature($timestamp, $method, $request_path, $secret_key) {
// Concatenate the string to sign
$string_to_sign = $timestamp . $method . $request_path;
// Hash the string using HMAC-SHA256
$hash = hash_hmac('sha256', $string_to_sign, $secret_key, true);
// Return the Base64-encoded signature
return base64_encode($hash);
}
```
***
#### **3. Constructing API Requests**
**3.1 Configuration**
Set up the API base URL and keys:
```php
// API Configuration
$base_url = "https://api.mefree.net"; // Mefree API base URL
$api_key = "your_api_key"; // Replace with your actual API Key
$secret_key = "your_secret_key"; // Replace with your actual Secret Key
```
**3.2 General HTTP Request Function**
Here’s a reusable function to make API requests:
```php
/**
* Send an HTTP request to Mefree API
*
* @param string $method HTTP method (GET/POST)
* @param string $request_path API request path (with query parameters)
* @param string $base_url API base URL
* @param string $api_key API Key
* @param string $secret_key API Secret Key
* @return array Response data including HTTP status and body
*/
function send_request($method, $request_path, $base_url, $api_key, $secret_key) {
// Current UTC timestamp in ISO 8601 format
$timestamp = gmdate("Y-m-d\TH:i:s.v\Z");
// Generate the signature
$signature = generate_signature($timestamp, $method, $request_path, $secret_key);
// Set the request headers
$headers = [
"Content-Type: application/json",
"MF-ACCESS-KEY: {$api_key}",
"MF-ACCESS-SIGN: {$signature}",
"MF-ACCESS-TIMESTAMP: {$timestamp}",
];
// Initialize CURL
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $base_url . $request_path); // Set the URL
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method); // Set the HTTP method
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers); // Add headers
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); // Return response as a string
// Execute the request
$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Get HTTP status code
curl_close($ch);
// Return the HTTP status code and response
return [
"status_code" => $http_code,
"response" => $response
];
}
```
***
#### **4. API Call Examples**
**4.1 Fetch Account Information**
**Endpoint**: `/api/config`\
**HTTP Method**: `GET`
**Code Example**:
```php
// Fetch account information
$request_path = "/api/config"; // API request path
$response = send_request("GET", $request_path, $base_url, $api_key, $secret_key);
// Process the response
if ($response['status_code'] == 200) {
echo "Account Information:\n";
echo $response['response'];
} else {
echo "Request failed, HTTP Status: " . $response['status_code'] . "\n";
echo "Response: " . $response['response'];
}
```
***
**4.2 Create an Order**
**Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`\
**HTTP Method**: `POST`
**Code Example**:
```php
// Create an order
$request_path = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"; // API request path
$response = send_request("POST", $request_path, $base_url, $api_key, $secret_key);
// Process the response
if ($response['status_code'] == 200) {
echo "Order created successfully:\n";
echo $response['response'];
} else {
echo "Request failed, HTTP Status: " . $response['status_code'] . "\n";
echo "Response: " . $response['response'];
}
```
***
**4.3 Check Order Status**
**Endpoint**: `/api/order/{pay_hash}`\
**HTTP Method**: `GET`
**Code Example**:
```php
// Check order status
$pay_hash = "abcd1234"; // Replace with the actual order pay_hash
$request_path = "/api/order/" . $pay_hash; // API request path
$response = send_request("GET", $request_path, $base_url, $api_key, $secret_key);
// Process the response
if ($response['status_code'] == 200) {
echo "Order Status:\n";
echo $response['response'];
} else {
echo "Request failed, HTTP Status: " . $response['status_code'] . "\n";
echo "Response: " . $response['response'];
}
```
***
#### **5. Common Issues**
**5.1 Invalid Signature (401 Unauthorized)**
* Ensure `MF-ACCESS-KEY` matches your API Key.
* Confirm the signature string is constructed as `timestamp + method + requestPath`.
* Ensure the timestamp is in UTC and formatted correctly (e.g., `2024-11-26T12:34:56.789Z`).
* Use the correct **Secret Key** to generate the signature.
**5.2 Invalid Parameters (400 Bad Request)**
* Verify the request path and query parameters.
* Ensure `Content-Type` is set to `application/json`.
**5.3 Rate Limit Exceeded (429 Too Many Requests)**
* Mefree API imposes rate limits. Avoid making excessive requests in a short time.
* Add delays or throttle requests if necessary (e.g., limit to 2 requests/second).
***
#### **6. Conclusion**
This guide demonstrates how to efficiently interact with the Mefree.NET API using PHP, including generating signatures, making requests, and handling responses. For critical operations such as placing orders, implementing retry mechanisms is recommended to enhance reliability. For further assistance, contact Mefree's official support team.
# Golang Guide for calling Mefree.NET API
This guide provides detailed instructions on how to use **Go (Golang)** to interact with the Mefree.NET API, including generating signatures, building requests, and handling API responses.
***
#### **1. Signature Rules Overview**
Mefree.NET API uses a signature-based authentication mechanism. The signature is generated as follows:
**1.1 Signature String Rules**
The signature string is constructed in the following format:
```
sign = timestamp + method + requestPath
```
* **timestamp**: UTC time in ISO 8601 format (e.g., `2024-11-26T12:34:56.789Z`).
* **method**: HTTP method, such as `GET` or `POST`.
* **requestPath**: API request path (including query parameters), for example:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Signature Generation Process**
1. Concatenate `timestamp`, `method`, and `requestPath` into a string.
2. Use the **HMAC-SHA256** algorithm to hash the concatenated string with your **API Secret Key**.
3. Encode the resulting hash using **Base64** to generate the signature.
**1.3 Required HTTP Headers**
Each API request must include the following headers:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Your API Key.
* `MF-ACCESS-SIGN`: The generated signature.
* `MF-ACCESS-TIMESTAMP`: Current UTC timestamp.
***
#### **2. Implementing Signature in Go**
**2.1 Signature Generation Function**
Here’s how to generate the signature in Go:
```go
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
)
// GenerateSignature generates a Base64-encoded HMAC-SHA256 signature
func GenerateSignature(timestamp, method, requestPath, secretKey string) string {
// Create the string to sign
stringToSign := timestamp + method + requestPath
// Create a new HMAC by defining the hash type and the secret key
h := hmac.New(sha256.New, []byte(secretKey))
h.Write([]byte(stringToSign))
// Compute the HMAC and encode it in Base64
signature := base64.StdEncoding.EncodeToString(h.Sum(nil))
return signature
}
```
***
#### **3. Constructing API Requests**
**3.1 Configuration**
Define your API configuration:
```go
package main
// API Configuration
const BaseURL = "https://api.mefree.net" // Mefree API base URL
const APIKey = "your_api_key" // Replace with your actual API Key
const SecretKey = "your_secret_key" // Replace with your actual Secret Key
```
**3.2 General HTTP Request Function**
Here’s a reusable function to make API requests:
```go
package main
import (
"bytes"
"fmt"
"io/ioutil"
"net/http"
"time"
)
// SendRequest sends an HTTP request to the Mefree API
func SendRequest(method, requestPath string) (int, string, error) {
// Get current UTC timestamp in ISO 8601 format
timestamp := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
// Generate the signature
signature := GenerateSignature(timestamp, method, requestPath, SecretKey)
// Create the request
url := BaseURL + requestPath
req, err := http.NewRequest(method, url, nil)
if err != nil {
return 0, "", err
}
// Set headers
req.Header.Set("Content-Type", "application/json")
req.Header.Set("MF-ACCESS-KEY", APIKey)
req.Header.Set("MF-ACCESS-SIGN", signature)
req.Header.Set("MF-ACCESS-TIMESTAMP", timestamp)
// Send the request
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return 0, "", err
}
defer resp.Body.Close()
// Read the response
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return 0, "", err
}
return resp.StatusCode, string(body), nil
}
```
***
#### **4. API Call Examples**
**4.1 Fetch Account Information**
**Endpoint**: `/api/config`\
**HTTP Method**: `GET`
**Code Example**:
```go
package main
import "fmt"
func main() {
// Fetch account information
requestPath := "/api/config"
statusCode, response, err := SendRequest("GET", requestPath)
// Handle the response
if err != nil {
fmt.Println("Error:", err)
return
}
if statusCode == 200 {
fmt.Println("Account Information:")
fmt.Println(response)
} else {
fmt.Printf("Request failed with HTTP status code %d\n", statusCode)
fmt.Println("Response:", response)
}
}
```
***
**4.2 Create an Order**
**Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`\
**HTTP Method**: `POST`
**Code Example**:
```go
package main
import "fmt"
func main() {
// Create an order
requestPath := "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"
statusCode, response, err := SendRequest("POST", requestPath)
// Handle the response
if err != nil {
fmt.Println("Error:", err)
return
}
if statusCode == 200 {
fmt.Println("Order Created Successfully:")
fmt.Println(response)
} else {
fmt.Printf("Request failed with HTTP status code %d\n", statusCode)
fmt.Println("Response:", response)
}
}
```
***
**4.3 Check Order Status**
**Endpoint**: `/api/order/{pay_hash}`\
**HTTP Method**: `GET`
**Code Example**:
```go
package main
import "fmt"
func main() {
// Check order status
payHash := "abcd1234" // Replace with the actual order pay_hash
requestPath := "/api/order/" + payHash
statusCode, response, err := SendRequest("GET", requestPath)
// Handle the response
if err != nil {
fmt.Println("Error:", err)
return
}
if statusCode == 200 {
fmt.Println("Order Status:")
fmt.Println(response)
} else {
fmt.Printf("Request failed with HTTP status code %d\n", statusCode)
fmt.Println("Response:", response)
}
}
```
***
#### **5. Common Issues**
**5.1 Invalid Signature (401 Unauthorized)**
* Verify that `MF-ACCESS-KEY` matches your API Key.
* Ensure the signature string follows the format: `timestamp + method + requestPath`.
* Use the correct **Secret Key** to generate the signature.
* Ensure the timestamp is in UTC and formatted correctly (e.g., `2024-11-26T12:34:56.789Z`).
**5.2 Invalid Parameters (400 Bad Request)**
* Double-check the request path and query parameters.
* Ensure the `Content-Type` header is set to `application/json`.
**5.3 Rate Limit Exceeded (429 Too Many Requests)**
* Mefree API enforces rate limits. Avoid sending excessive requests within a short period.
* Add delays or throttle requests (e.g., no more than 2 requests per second).
***
#### **6. Conclusion**
This guide demonstrates how to interact with the Mefree.NET API using Go, including generating signatures, sending requests, and handling responses. For critical operations, such as placing orders, it is recommended to implement retry mechanisms for better reliability. If you encounter any issues, contact Mefree's official support team for assistance.
# Mefree.NET API Frequently Asked Questions (FAQ)
#### **Mefree.NET API Frequently Asked Questions (FAQ)**
This FAQ provides solutions to common issues users may encounter when using the Mefree.NET API.
***
#### **1. Account and Permission Issues**
**1.1 Why is my API key not working?**
**Possible Reasons:**
* The API key has been disabled or deleted.
**Solutions:**
* Log in to the Mefree Telegram bot and check the status of your API key to ensure it is active.
**1.2 How do I enable access for specific IP addresses only?**
**Solution:**
* When creating or editing your API key, specify the IP address you want to bind. This will restrict the API key to accept requests only from that IP address, enhancing security.
***
#### **2. Signature and Authentication Issues**
**2.1 Why am I getting a 401 Unauthorized error?**
**Possible Reasons:**
* Incorrect `MF-ACCESS-KEY` or `MF-ACCESS-SIGN`.
* Signature generation is incorrect.
* Timestamp deviation exceeds 5 seconds.
**Solutions:**
* Verify that the `MF-ACCESS-KEY` matches the provided API key.
* Ensure the signature is generated according to the [signature rules](https://chatgpt.com/c/6745148f-9d24-8013-8df8-a4395ce41e67). Double-check the logic for signature generation.
* Ensure `MF-ACCESS-TIMESTAMP` is a valid UTC timestamp and the deviation from server time is within 5 seconds.
**2.2 How can I verify signature generation?**
**Solution:**
* Print the concatenated string used for signing (`timestamp + method + requestPath`) for debugging.
* Compare the generated signature with one calculated manually.
```
Demo:
timestamp = "2008-08-08T08:08:08.888Z"
method = "GET"
requestPath = "/api/config"
waitSigningString = "2008-08-08T08:08:08.888ZGET/api/config"
SECRET_KEY = "8d3c3c07a47186c9d6d352d287263cf3"
By calling the generate_signature() method in the API Demo to find out whether the signature value is equal to
jY+BLq8s2cAFQmEDp1rbZw0PPG9Np67cmbmS7rhSdyw=
```
* Use tools like **Postman** or **Curl** to manually test your signature if needed.
***
#### **3. Request and Response Issues**
**3.1 Why am I getting a 400 Bad Request error?**
**Possible Reasons:**
* Missing or incorrect request parameters.
* Incorrect API endpoint path.
**Solutions:**
* Check the API documentation to ensure all required parameters and paths are correct.
* Verify that the `Content-Type` header is set to `application/json`.
* Ensure the request payload is properly formatted as JSON.
**3.2 Why am I getting a 429 Too Many Requests error?**
**Possible Reasons:**
* The request frequency exceeds the API rate limits.
**Solutions:**
* Review the API documentation to understand rate limits (e.g., maximum requests per second).
* Implement throttling in your code to control the number of requests sent per second.
* When using distributed systems, ensure the combined request rate does not exceed the limit.
**3.3 Why am I getting a 500 Internal Server Error?**
**Possible Reasons:**
* Temporary issues with the API server.
**Solutions:**
* Check your network connection to ensure the request was sent successfully.
* Wait a few seconds and retry the request.
* If the issue persists, contact Mefree support.
***
#### **4. Specific Endpoint Issues**
**4.1 Why can't I successfully place an order?**
**Possible Reasons:**
* Insufficient account balance.
* Incorrect order parameters (e.g., quantity or price).
* Account lacks the required trading permissions.
**Solutions:**
* Verify that your account balance is sufficient.
* Ensure that order parameters (e.g., quantity and period) meet the minimum requirements (refer to the "Place Order" section in the documentation).
***
#### **5. Development and Debugging Issues**
**5.1 How can I handle timeout issues?**
**Possible Reasons:**
* Network delays or unstable connections.
**Solutions:**
* Set a longer timeout for requests (e.g., `timeout=30`).
* Implement a retry mechanism for critical operations (e.g., retry 2–3 times).
* Test your network connectivity to the Mefree API server.
**5.2 How do I parse API responses?**
**Solution:**\
Mefree API responses are typically in JSON format and follow this structure:
```json
{
"code": "0",
"msg": "",
"data": {
"key": "value"
}
}
```
* **`code: 0`** indicates success; non-zero values indicate errors.
* **`data`** contains the main content; parse this to retrieve specific information.
***
#### **6. Other Issues**
**6.1 Why are timestamps often incorrect?**
**Possible Reasons:**
* Local time is not synchronized with UTC time.
**Solution:**
* Use Python’s `datetime.utcnow()` function or similar methods to generate UTC timestamps.
**6.2 How do I handle API upgrades?**
**Solution:**
* Subscribe to Mefree’s developer announcements for updates on API changes.
* Periodically update your code to accommodate the latest API versions.
* Use versioning (e.g., `v1`) in your code to avoid compatibility issues during upgrades.
**6.3 Failed -Out of Energy**
**Possible Reasons:**
When transferring USDT (TRC20) on the TRON network:
* If the recipient's address already holds USDT, the transaction requires **65,000 energy**.
* If the recipient's address does not hold USDT, the transaction requires **131,000 energy**.
***
#### **7. Contact Support**
If you cannot resolve an issue, contact Mefree technical support through the following channels:
* **Submit a Ticket**: Visit the Mefree Support Center.
* **Developer Documentation**: Refer to the [official API documentation](https://github.com/xcoin-blockchain/xcoin-energy/blob/doc-en/getting-started/broken-reference/README.md).
* **Contact Us:** [@mefreenet](https://t.me/mefreenet)
***
This FAQ aims to help you quickly resolve common issues when using the Mefree API. Happy coding! 🚀
# statement
Mefree has always been committed to the authentic and reliable energy business and always advocates integrity and credibility. We help users realize normal USDT transfers on the TRC20 chain to save handling fees. We resolutely refuse to provide services for any illegal industry involving 0 U attacks (address trailing of 0.0001 USDT), phishing, terrorist fraud, etc. Once such behavior is discovered, cooperation will be suspended immediately. If you find that our energy address is suspected to be used in the above-mentioned illegal industries, please give us feedback in time. Digital has no borders, and the world is based on the right path. Let us work together to maintain a clear and safe trading environment!
# Account Information
{% openapi src="/files/VOZ0twanUuUSjlUllBM0" path="/api/config" method="get" %}
[api.json](https://3248898104-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FLIQdCqMpkUtQ2eL2t8un%2Fuploads%2Fgit-blob-3ff62faf23c66ad0a12c79271d9e9b9610805c52%2Fapi.json?alt=media)
{% endopenapi %}
# Create Order
Create resource order
{% openapi src="/files/VOZ0twanUuUSjlUllBM0" path="/api/order" method="post" %}
[api.json](https://3248898104-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FLIQdCqMpkUtQ2eL2t8un%2Fuploads%2Fgit-blob-3ff62faf23c66ad0a12c79271d9e9b9610805c52%2Fapi.json?alt=media)
{% endopenapi %}
#### **Core API: Create Order (POST /order)**
When creating an order through Mefree.net's API, it is crucial to track the following three return values:
1. **`pay_hash` (Payment Hash / Order ID):**
* This is a unique identifier for the order.
* Use it to query the order details via the **GET `/order/{pay_hash}`** endpoint.
2. **`status` (Order Status):**
* Indicates the progress of the order.
* When the `status` is `DELEGATE_SUCCESS`, it means the energy transaction has been successfully submitted to the TRON blockchain.
* Note: A very small chance (\~0.1%) exists where the transaction may not be added to the chain.
3. **`confirm_status` (On-chain Confirmation Status):**
* Confirms whether the energy has been successfully transferred on-chain.
* When `confirm_status` is `DELEGATION_CONFIRMED`, it guarantees that the energy has been delivered to the target address.
***
#### **Q: How to ensure that energy is sent to the address?**
There are **two ways** to verify successful energy delivery:
1. **Query the energy balance of the address via the TRON API:**
* Use TRON's official API or a TRON wallet (e.g., TronLink) to check the target address's current energy balance.
* Endpoint Example (TRON Grid API):
```bash
curl --request POST \
--url https://api.trongrid.io/wallet/getaccountresource \
--header 'accept: application/json' \
--header 'content-type: application/json' \
--data '
{
"address": "TZ4UXDV5ZhNW7fb2AMSbgfAEZ7hWsnYS2g",
"visible": true
}
'
```
Parse the response to check the `energy_limit` or `energy_used` field.
2. **Check the `confirm_status` of the order:**
* Use the **GET `/order/{pay_hash}`** endpoint to retrieve the order details.
* If `confirm_status` is `DELEGATION_CONFIRMED`, the energy transaction has been confirmed on the blockchain, and the target address has received the energy.
***
#### **Example Workflow**
**1. Create an Order**
Request:
```http
POST /order?quantity=65000&target_address=TRON_ADDRESS&period=1
Host: https://api.mefree.net
Headers:
Content-Type: application/json
MF-ACCESS-KEY: {api_key}
MF-ACCESS-SIGN: {signature}
MF-ACCESS-TIMESTAMP: {timestamp}
```
Response:
```json
{
"pay_hash": "abcd1234",
"status": "DELEGATE_SUCCESS",
"confirm_status": "UNCONFIRMED"
}
```
**2. Query Order Details**
Request:
```http
GET /order/abcd1234
Host: https://api.mefree.net
Headers:
Content-Type: application/json
MF-ACCESS-KEY: {api_key}
MF-ACCESS-SIGN: {signature}
MF-ACCESS-TIMESTAMP: {timestamp}
```
Response:
```json
{
"pay_hash": "abcd1234",
"status": "DELEGATE_SUCCESS",
"confirm_status": "DELEGATION_CONFIRMED"
}
```
**3. Verify Energy Delivery**
* If `confirm_status` = `DELEGATION_CONFIRMED`, the energy has been delivered.
* Alternatively, check the energy balance of the receiver address via TRON’s blockchain API.
***
By combining order tracking (`pay_hash` and `confirm_status`) and on-chain verification, you can ensure that energy transactions are reliable and properly executed. If any issues arise, contact Mefree support([@mefreenet](https://t.me/mefreenet)) for assistance.
# Get Order Detail
{% openapi src="/files/VOZ0twanUuUSjlUllBM0" path="/api/order/{pay\_hash}" method="get" %}
[api.json](https://3248898104-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FLIQdCqMpkUtQ2eL2t8un%2Fuploads%2Fgit-blob-3ff62faf23c66ad0a12c79271d9e9b9610805c52%2Fapi.json?alt=media)
{% endopenapi %}
# Get Available Energy
{% openapi src="/files/VOZ0twanUuUSjlUllBM0" path="/api/available" method="get" %}
[api.json](https://3248898104-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FLIQdCqMpkUtQ2eL2t8un%2Fuploads%2Fgit-blob-3ff62faf23c66ad0a12c79271d9e9b9610805c52%2Fapi.json?alt=media)
{% endopenapi %}
# Energy Required to Transfer USDT
{% openapi src="/files/VOZ0twanUuUSjlUllBM0" path="/api/usdt/energy\_used" method="get" %}
[api.json](https://3248898104-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FLIQdCqMpkUtQ2eL2t8un%2Fuploads%2Fgit-blob-3ff62faf23c66ad0a12c79271d9e9b9610805c52%2Fapi.json?alt=media)
{% endopenapi %}
# Описание
#### **Описание Mefree.net**
Mefree.net — это профессиональная платформа, специализирующаяся на предоставлении **эффективных, удобных и доступных услуг** по аренде энергии для блокчейна TRON. Наша миссия — помочь разработчикам и пользователям сократить издержки на операции в сети TRON и предоставить необходимые ресурсы для разработки DApp и выполнения транзакций.
***
#### **Наши услуги**
1. **Аренда энергии TRON**
* Мы предоставляем энергетические ресурсы в сети TRON, что помогает избежать неудачных транзакций или высоких комиссий из-за недостатка энергии.
* Услуга подходит для индивидуальных пользователей, разработчиков и компаний.
2. **Мгновенная доставка**
* Энергия зачисляется на ваш адрес в течение нескольких секунд, удовлетворяя срочные потребности.
3. **Круглосуточная поддержка**
* Наша профессиональная служба поддержки работает 24/7, чтобы оперативно помочь вам с любыми вопросами или проблемами.
***
#### **Наши преимущества**
1. **Эффективность**
* Мы используем автоматизированные технологии для быстрого удовлетворения ваших потребностей в энергии.
* Наша служба поддержки всегда готова помочь в любое время.
2. **Стабильность и надежность**
* Наши услуги базируются на стабильной сети TRON, что гарантирует бесперебойную работу.
* Собственные узлы TRON обеспечивают высокую производительность даже в пиковые периоды.
3. **Безопасность**
* Все транзакции зашифрованы, что обеспечивает защиту ваших активов.
4. **Доступность и скорость**
* Сэкономьте более 70% на операциях в сети TRON.
* Мы предлагаем конкурентоспособные и гибкие тарифы, которые гарантируют отличное соотношение цены и качества.
***
#### **Как начать**
1. Посетите наш сайт: [Mefree.net](https://mefree.net/).
2. Выберите подходящий тарифный план и оплатите его.
3. Дождитесь автоматического зачисления энергии и начните пользоваться услугами без лишних забот.
Для более продвинутых и автоматизированных решений воспользуйтесь нашим Telegram-ботом: **@SuperXCoinBot**.\
Если у вас возникли вопросы, обратитесь в нашу службу поддержки: **@mefreenet**.
***
#### **Почему выбирают Mefree.net?**
Mefree.net — ваш надежный партнер для оптимизации работы в экосистеме TRON. Мы обеспечиваем стабильные и доступные решения, чтобы поддерживать вас на пути к успеху в блокчейне. Давайте вместе строить более эффективное будущее блокчейн-технологий!
# Как приобрести энергию TRON на Mefree.net?
#### **Как приобрести энергию TRON на Mefree.net?**
Mefree.net предлагает два удобных способа покупки энергии TRON: **прямая оплата переводом** или **покупка через API**. Выберите подходящий для вас метод и быстро получите необходимую энергию. Подробная инструкция представлена ниже.
***
#### **Метод 1: Покупка через прямой перевод**
Если вы хотите быстро и просто приобрести энергию без лишних сложностей, используйте прямой перевод.
**Шаги:**
1. **Убедитесь, что адрес для получения готов**
* Убедитесь, что ваш кошелек настроен для получения энергии. Система Mefree.net автоматически отправит энергию на адрес, с которого вы сделали перевод.
2. **Переведите средства на указанный адрес:**
```
TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK
```
* Это официальный адрес для получения средств на Mefree.net.
3. **Укажите точную сумму перевода**
* Ознакомьтесь с таблицей цен на энергию на сайте Mefree.net. Выберите необходимое количество энергии и переведите соответствующую сумму в TRX.\
**Внимание:** Убедитесь, что сумма перевода точна; неправильная сумма может привести к ошибкам при распределении энергии.
4. **Ожидайте зачисления энергии**
* После получения перевода система автоматически обработает вашу заявку, и энергия поступит на ваш кошелек в течение нескольких секунд.
* Никаких дополнительных действий не требуется — процесс полностью автоматизирован, простой и быстрый.
***
#### **Метод 2: Покупка через API**
Если вы разработчик или вам требуется более автоматизированный и удобный способ, используйте API, предоставляемый Mefree.net.
* Подробная инструкция доступна в **руководстве по API** на сайте.
***
#### **Важные замечания**
1. **Убедитесь в наличии достаточных средств**
* Независимо от выбранного метода убедитесь, что на вашем кошельке достаточно TRX для оплаты.
2. **Точная сумма перевода**
* При использовании метода прямого перевода строго следуйте ценовым рекомендациям на сайте Mefree.net, чтобы избежать ошибок из-за неверной суммы.
3. **Безопасность API**
* Если вы используете API, надежно храните ваш API-ключ, чтобы избежать утечки данных и угроз безопасности.
4. **Проверка зачисления энергии**
* После успешного перевода или вызова API проверьте баланс энергии в вашем кошельке, чтобы убедиться, что ресурсы были правильно распределены.
***
#### **Сравнение методов**
| Особенность | Покупка через перевод | Покупка через API |
| -------------------------- | ----------------------------- | ---------------------------- |
| **Скорость** | Мгновенное зачисление | Автоматизированное и быстрое |
| **Простота использования** | Удобно для всех пользователей | Требуются навыки разработки |
| **Подходит для** | Частных пользователей | Разработчиков |
| **Автоматизация** | Ручной перевод | Полностью автоматизировано |
***
Используя любой из этих методов, вы сможете легко приобрести энергию TRON для проведения транзакций в сети и работы ваших DApp!
Для дополнительной помощи посетите [Mefree.net](https://mefree.net/) или свяжитесь со службой поддержки.
# Покупка энергии TRON через прямой перевод
#### **Покупка энергии TRON через прямой перевод**
Ниже представлен подробный гайд по покупке энергии TRON на Mefree.net с использованием кошелька TronLink. Всего за несколько простых шагов вы сможете быстро приобрести энергию TRON.
***
#### **Шаг 1: Установка и настройка кошелька TronLink**
1. **Установите TronLink**
* Если TronLink еще не установлен, скачайте его через [официальный сайт TronLink](https://www.tronlink.org/) или найдите приложение в Chrome Web Store (для браузера) или в магазине приложений (для мобильных устройств).
2. **Создайте или импортируйте кошелек**
* **Для новых пользователей**: Следуйте инструкциям для создания кошелька, сохраните мнемоническую фразу и установите пароль.
* **Для существующих пользователей**: Импортируйте кошелек с помощью мнемонической фразы или приватного ключа.
3. **Пополните кошелек TRX**
* Убедитесь, что в кошельке достаточно TRX для оплаты энергии и оставьте небольшое количество TRX для оплаты комиссий за транзакции.
***
#### **Шаг 2: Проверка адреса получения и стоимости энергии**
1. **Адрес получения**
* Mefree.net предоставляет следующий адрес для оплаты:
```
TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK
```
Этот адрес используется исключительно для покупки энергии, не отправляйте средства на другие адреса.
2. **Стоимость энергии**
* Зайдите на сайт [Mefree.net](https://mefree.net/), чтобы узнать актуальные цены.
* Выберите необходимое количество энергии и рассчитайте сумму в TRX.
***
#### **Шаг 3: Выполнение перевода через TronLink**
1. **Откройте кошелек TronLink**
* Запустите расширение TronLink в браузере или приложение на телефоне.
2. **Перейдите на страницу перевода**
* Нажмите кнопку **"Отправить"** или **"Transfer"**, чтобы начать транзакцию.
3. **Введите данные для перевода**
* **Адрес получения**: Вставьте адрес Mefree.net:
```
TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK
```
* **Сумма перевода**: Укажите точную сумму в TRX в соответствии с расчетом на сайте.
* **Примечание (Memo)**: Оставьте поле пустым, эта информация не требуется.
4. **Подтвердите и отправьте перевод**
* Проверьте правильность данных (адрес и сумма), затем нажмите кнопку **"Отправить"**.
* Введите пароль кошелька или выполните аутентификацию (например, отпечатком пальца).
5. **Ожидайте завершения перевода**
* Транзакция обычно обрабатывается за несколько секунд. Вы можете проверить ее статус в истории операций кошелька.
***
#### **Шаг 4: Проверка поступления энергии**
1. **Дождитесь обработки системой**
* После подтверждения перевода система Mefree.net автоматически обработает вашу заявку. Энергия будет зачислена на ваш кошелек в течение нескольких секунд.
2. **Проверьте баланс энергии**
* Откройте кошелек TronLink и убедитесь, что баланс энергии увеличился.
* Если энергия не зачислена, проверьте данные перевода или свяжитесь с поддержкой Mefree.net.
***
#### **Важные замечания**
1. **Проверяйте адрес получения**
* Используйте только указанный адрес:
```
TUfAMQM81RLMdquBSaFytsXxEet7AKKKKK
```
Отправка на другой адрес может привести к потере средств.
2. **Точность суммы перевода**
* Переводите строго рассчитанную сумму TRX, чтобы избежать ошибок при распределении энергии.
3. **Оставляйте TRX на комиссии**
* После перевода оставьте немного TRX на вашем кошельке для покрытия сетевых комиссий.
***
#### **Часто задаваемые вопросы**
1. **Почему энергия не зачислена?**
* Проверьте правильность адреса и суммы перевода.
* Если перевод выполнен правильно, но энергия не зачислена, свяжитесь с поддержкой Mefree.net и предоставьте хэш транзакции.
2. **Что делать, если перевод не удался?**
* Убедитесь, что у вас достаточно TRX для оплаты и комиссий.
* Проверьте стабильность подключения кошелька к сети TRON.
***
Следуя этим шагам, вы легко сможете приобрести энергию TRON через TronLink и обеспечить стабильную работу ваших DApp и транзакций. Если у вас возникли вопросы, посетите [Mefree.net](https://mefree.net/) или свяжитесь с нашей поддержкой!
# Покупка энергии через API
####
Данное руководство поможет вам быстро освоить процесс подключения и использования REST API платформы **Mefree.NET** для автоматизированной покупки энергии TRON.
***
#### **1. Подготовка**
**1.1 Регистрация и получение API-ключей**
1. Войдите в Telegram-бот платформы Mefree.NET: [**@SuperXCoinBot**](https://t.me/SuperXCoinBot).
2. Перейдите в раздел **"Личный кабинет"** и выберите **"API Покупка"**.
3. Сохраните следующие данные:
* **API KEY (ACCESS KEY)**
* **SECRET KEY (API SECRET)**
**1.2 Инструменты для работы**
* **Тестирование API**: Postman, Curl или командная строка.
* **Язык разработки**: Python (рекомендуется библиотека `requests`) или любой язык, поддерживающий HTTP-запросы.
**1.3 Документация**
Ознакомьтесь с [официальной документацией Mefree.NET API](https://github.com/xcoin-blockchain/xcoin-energy/blob/doc-ru/getting-started/how-to-buy-energy/broken-reference/README.md) для получения более подробной информации об интерфейсах.
***
#### **2. Основы работы с API**
**2.1 Базовый URL**
Для продакшн-среды используйте:**`https://api.mefree.net`**
**2.2 Заголовки API**
Каждый запрос должен содержать следующие HTTP-заголовки:
* **Content-Type**: `application/json`
* **MF-ACCESS-KEY**: ваш API-ключ.
* **MF-ACCESS-SIGN**: подпись запроса (см. раздел о генерации подписи).
* **MF-ACCESS-TIMESTAMP**: текущая временная метка.
**2.3 Формат временной метки**
**MF-ACCESS-TIMESTAMP** должен быть в формате ISO 8601 (UTC). Пример: **`2023-01-01T12:00:00.000Z`**
**2.4 Правила подписи**
Подпись используется для проверки подлинности запроса. Алгоритм формирования подписи:
1. Составьте строку для подписи: **`sign = timestamp + method + requestPath`**
* `timestamp`: значение MF-ACCESS-TIMESTAMP.
* `method`: HTTP-метод (например, GET, POST).
* `requestPath`: путь запроса (включая параметры, если они есть).
Пример:\
`/api/order?quantity=65000&period=1&target_address=Txxx...7n`
2. Выполните хэширование строки с использованием алгоритма **HMAC-SHA256** и вашего **SECRET KEY**.
3. Закодируйте результат в формате Base64.
***
#### **3. Примеры запросов**
**3.1 Установка окружения**
Убедитесь, что библиотеки **requests** и **datetime** установлены:
```bash
pip install requests
```
**3.2 Пример запроса: Проверка баланса**
**Описание запроса**:
* URL: `GET /api/config`
* Функция: Получение информации о балансе аккаунта.
**Код на Python**:
```python
import requests
import hmac
import base64
from datetime import datetime
# Конфигурация API
BASE_URL = "https://api.mefree.net"
API_KEY = "your_api_key"
SECRET_KEY = "your_secret_key"
# Генерация подписи
def generate_signature(timestamp, method, request_path, secret_key):
message = f"{timestamp}{method}{request_path}"
mac = hmac.new(secret_key.encode(), message.encode(), digestmod="sha256")
return base64.b64encode(mac.digest()).decode()
# Текущая временная метка
timestamp = datetime.utcnow().isoformat(timespec="milliseconds") + "Z"
method = "GET"
request_path = "/api/config"
# Формирование подписи
signature = generate_signature(timestamp, method, request_path, SECRET_KEY)
# Заголовки запроса
headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
}
# Отправка запроса
response = requests.get(BASE_URL + request_path, headers=headers)
if response.status_code == 200:
print("Баланс аккаунта:", response.json())
else:
print("Ошибка:", response.status_code, response.text)
```
***
**3.3 Пример запроса: Создание заказа**
**Описание запроса**:
* URL: `POST /api/order`
* Функция: Создание заказа на покупку энергии.
**Код на Python**:
```python
# Параметры заказа
quantity = 65000 # количество энергии
target_address = "TDYk....4rnPfkdPZ"
period = 1 # срок аренды (в днях)
request_path = f"/api/order?quantity={quantity}&target_address={target_address}&period={period}"
# Генерация подписи
timestamp = datetime.utcnow().isoformat(timespec="milliseconds") + "Z"
method = "POST"
signature = generate_signature(timestamp, method, request_path, SECRET_KEY)
# Заголовки запроса
headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
}
# Отправка POST-запроса
response = requests.post(BASE_URL + request_path, headers=headers)
if response.status_code == 200:
print("Заказ успешно создан:", response.json())
else:
print("Ошибка:", response.status_code, response.text)
```
***
#### **4. Частые ошибки и их решение**
1. **HTTP 401 Unauthorized**:
* Проверьте, правильно ли указаны **MF-ACCESS-KEY** и **MF-ACCESS-SIGN**.
* Убедитесь, что API-ключ активен.
2. **HTTP 400 Bad Request**:
* Проверьте корректность параметров запроса.
3. **Ошибка подписи**:
* Убедитесь, что временная метка в формате UTC и подпись сформирована строго по правилам.
***
#### **5. Дальнейшие шаги**
* Изучите документацию API, чтобы освоить другие функции (например, проверку деталей заказа).
* Интегрируйте API в вашу систему для автоматизации процессов.
Следуя этому руководству, вы успешно подключитесь к API Mefree.NET и сможете автоматизировать покупку энергии TRON. Удачи!
# Инструкция по вызову API Mefree.NET на языке Java
Данное руководство подробно описывает, как с помощью Java взаимодействовать с API платформы **Mefree.NET**, включая генерацию подписи, создание запросов и обработку ответов от API.
***
#### **1. Общая информация о правилах подписи**
API Mefree.NET использует механизм аутентификации на основе подписи. Подпись создается следующим образом:
**1.1 Формирование строки для подписи**
Строка для подписи формируется по следующему шаблону:
```
sign = timestamp + method + requestPath
```
* **timestamp**: Временная метка в формате UTC (ISO 8601), например, `2024-11-26T12:34:56.789Z`.
* **method**: HTTP-метод, например, `GET` или `POST`.
* **requestPath**: Путь запроса API (включая параметры), например:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Процесс генерации подписи**
1. Объедините `timestamp`, `method` и `requestPath` в одну строку.
2. Используйте алгоритм **HMAC-SHA256**, чтобы зашифровать строку с использованием вашего **секретного ключа API (Secret Key)**.
3. Закодируйте результат с помощью **Base64**, чтобы получить подпись.
**1.3 Обязательные заголовки HTTP**
Каждый запрос к API должен содержать следующие заголовки:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Ваш API-ключ.
* `MF-ACCESS-SIGN`: Сгенерированная подпись.
* `MF-ACCESS-TIMESTAMP`: Текущая временная метка в формате UTC.
***
#### **2. Реализация генерации подписи в Java**
**2.1 Метод для генерации подписи**
Пример реализации метода для генерации подписи:
```java
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class MefreeSignatureUtil {
/**
* Генерация подписи для Mefree API.
*
* @param timestamp Временная метка (UTC в формате ISO 8601)
* @param method HTTP-метод (GET/POST)
* @param requestPath Путь запроса (с параметрами)
* @param secretKey Секретный ключ API
* @return Подпись в формате Base64
*/
public static String generateSignature(String timestamp, String method, String requestPath, String secretKey) {
try {
// Формируем строку для подписи
String stringToSign = timestamp + method + requestPath;
// Инициализируем HMAC-SHA256
Mac mac = Mac.getInstance("HmacSHA256");
SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(), "HmacSHA256");
mac.init(secretKeySpec);
// Вычисляем хэш и кодируем его в Base64
byte[] hmacBytes = mac.doFinal(stringToSign.getBytes());
return Base64.getEncoder().encodeToString(hmacBytes);
} catch (Exception e) {
throw new RuntimeException("Ошибка при генерации подписи", e);
}
}
}
```
***
#### **3. Создание запросов к API**
**3.1 Конфигурация**
Создайте конфигурацию с основными параметрами:
```java
public class MefreeConfig {
public static final String BASE_URL = "https://api.mefree.net"; // Базовый URL Mefree API
public static final String API_KEY = "your_api_key"; // Ваш API-ключ
public static final String SECRET_KEY = "your_secret_key"; // Ваш секретный ключ
}
```
**3.2 Универсальный метод для отправки запросов**
Используйте следующий метод для отправки HTTP-запросов:
```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.OutputStream;
import java.io.InputStream;
import java.util.Scanner;
public class MefreeApiRequest {
/**
* Отправка запроса к API Mefree.
*
* @param method HTTP-метод (GET/POST)
* @param requestPath Путь запроса (с параметрами)
* @return Ответ API в виде строки
* @throws Exception В случае ошибки
*/
public static String sendRequest(String method, String requestPath) throws Exception {
// Генерация временной метки (UTC)
String timestamp = java.time.Instant.now().toString();
// Генерация подписи
String signature = MefreeSignatureUtil.generateSignature(timestamp, method, requestPath, MefreeConfig.SECRET_KEY);
// Формируем полный URL
URL url = new URL(MefreeConfig.BASE_URL + requestPath);
// Настраиваем соединение
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod(method);
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("MF-ACCESS-KEY", MefreeConfig.API_KEY);
connection.setRequestProperty("MF-ACCESS-SIGN", signature);
connection.setRequestProperty("MF-ACCESS-TIMESTAMP", timestamp);
// Отправляем запрос и читаем ответ
InputStream responseStream = connection.getInputStream();
Scanner scanner = new Scanner(responseStream).useDelimiter("\\A");
return scanner.hasNext() ? scanner.next() : "";
}
}
```
***
#### **4. Примеры вызовов API**
**4.1 Получение информации об аккаунте**
**Endpoint**: `/api/config`\
**HTTP-метод**: `GET`
**Пример кода**:
```java
public class MefreeExample {
public static void main(String[] args) {
try {
// Вызов API для получения информации об аккаунте
String response = MefreeApiRequest.sendRequest("GET", "/api/config");
System.out.println("Информация об аккаунте:");
System.out.println(response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
***
**4.2 Создание заказа**
**Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`\
**HTTP-метод**: `POST`
**Пример кода**:
```java
public class MefreeExample {
public static void main(String[] args) {
try {
// Вызов API для создания заказа
String response = MefreeApiRequest.sendRequest("POST", "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1");
System.out.println("Заказ успешно создан:");
System.out.println(response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
***
**4.3 Проверка статуса заказа**
**Endpoint**: `/api/order/{pay_hash}`\
**HTTP-метод**: `GET`
**Пример кода**:
```java
public class MefreeExample {
public static void main(String[] args) {
try {
// Проверка статуса заказа
String payHash = "abcd1234"; // Замените на реальный pay_hash
String response = MefreeApiRequest.sendRequest("GET", "/api/order/" + payHash);
System.out.println("Статус заказа:");
System.out.println(response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
***
#### **5. Распространенные ошибки**
**5.1 Неверная подпись (401 Unauthorized)**
* Проверьте, что `MF-ACCESS-KEY` соответствует вашему API-ключу.
* Убедитесь, что строка для подписи сформирована в правильном порядке: `timestamp + method + requestPath`.
* Используйте корректный **SECRET\_KEY**.
* Убедитесь, что временная метка указана в формате UTC.
**5.2 Ошибки параметров (400 Bad Request)**
* Проверьте правильность пути запроса и параметров.
* Убедитесь, что заголовок `Content-Type` установлен в значение `application/json`.
**5.3 Ограничение частоты запросов (429 Too Many Requests)**
* API Mefree имеет ограничение на частоту запросов. Избегайте отправки слишком большого количества запросов за короткое время.
* Рекомендуется не превышать 2 запроса в секунду.
***
#### **6. Заключение**
В этом руководстве описано, как взаимодействовать с API Mefree.NET с использованием Java. Реализация включает генерацию подписи, выполнение запросов и обработку ответов. Для критически важных операций (например, создание заказа) рекомендуется реализовать механизм повторной попытки. В случае возникновения вопросов обратитесь в службу поддержки Mefree.
# Руководство по вызову Mefree.NET API на Python
Данное руководство объясняет, как взаимодействовать с API платформы **Mefree.NET** с использованием Python. Оно включает процесс генерации подписи, создание запросов и обработку ответов от API.
***
#### **1. Общая информация о правилах подписи**
Для аутентификации Mefree.NET API использует подпись, которая генерируется следующим образом:
**1.1 Формирование строки для подписи**
Строка для подписи формируется по следующему шаблону:
```plaintext
sign = timestamp + method + requestPath
```
* **timestamp**: Метка времени в формате UTC (ISO 8601), например: `2024-11-26T12:34:56.789Z`.
* **method**: HTTP-метод, например, `GET` или `POST`.
* **requestPath**: Путь запроса (включая параметры), например:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Процесс генерации подписи**
1. Объедините `timestamp`, `method` и `requestPath` в строку.
2. Используйте алгоритм **HMAC-SHA256**, чтобы зашифровать строку с использованием вашего **секретного ключа API (Secret Key)**.
3. Закодируйте результат с помощью **Base64**, чтобы получить финальную подпись.
**1.3 Заголовки HTTP-запроса**
Каждый запрос к API должен содержать следующие заголовки:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Ваш API-ключ.
* `MF-ACCESS-SIGN`: Сгенерированная подпись.
* `MF-ACCESS-TIMESTAMP`: Метка времени в формате UTC.
***
#### **2. Реализация подписи в Python**
**2.1 Функция для генерации подписи**
Ниже приведен пример функции для создания подписи:
```python
import hmac
import hashlib
import base64
def generate_signature(timestamp, method, request_path, secret_key):
"""
Генерация подписи для Mefree API.
:param timestamp: Метка времени (UTC в формате ISO 8601)
:param method: HTTP-метод (GET/POST)
:param request_path: Путь запроса (включая параметры)
:param secret_key: Секретный ключ API
:return: Подпись в формате Base64
"""
# Формируем строку для подписи
string_to_sign = f"{timestamp}{method}{request_path}"
# Используем HMAC-SHA256 для шифрования строки
hmac_obj = hmac.new(secret_key.encode('utf-8'), string_to_sign.encode('utf-8'), hashlib.sha256)
# Возвращаем подпись в формате Base64
return base64.b64encode(hmac_obj.digest()).decode('utf-8')
```
***
#### **3. Создание запросов к API**
**3.1 Конфигурация**
Задайте базовые параметры для подключения к API:
```python
# Конфигурация API
BASE_URL = "https://api.mefree.net" # Базовый URL Mefree API
API_KEY = "your_api_key" # Ваш API-ключ
SECRET_KEY = "your_secret_key" # Ваш секретный ключ
```
**3.2 Универсальная функция для отправки запросов**
Используйте следующую функцию для отправки запросов:
```python
import requests
from datetime import datetime, timezone
def send_request(method, request_path):
"""
Отправка запроса к Mefree API.
:param method: HTTP-метод (GET/POST)
:param request_path: Путь запроса (включая параметры)
:return: Ответ API в формате JSON
"""
# Генерируем метку времени (UTC)
timestamp = datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
# Генерируем подпись
signature = generate_signature(timestamp, method, request_path, SECRET_KEY)
# Заголовки запроса
headers = {
"Content-Type": "application/json",
"MF-ACCESS-KEY": API_KEY,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp
}
# Полный URL
url = BASE_URL + request_path
# Выполняем запрос
response = requests.request(method, url, headers=headers)
# Возвращаем JSON-ответ или текст ошибки
return {
"status_code": response.status_code,
"response": response.json() if response.headers.get('Content-Type') == 'application/json' else response.text
}
```
***
#### **4. Примеры вызовов API**
**4.1 Получение информации об аккаунте**
* **Endpoint**: `/api/config`
* **HTTP-метод**: `GET`
**Пример:**
```python
if __name__ == "__main__":
# Вызов API для получения информации об аккаунте
result = send_request("GET", "/api/config")
# Обработка ответа
if result['status_code'] == 200:
print("Информация об аккаунте:")
print(result['response'])
else:
print(f"Ошибка: {result['status_code']}")
print(result['response'])
```
***
**4.2 Создание заказа**
* **Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* **HTTP-метод**: `POST`
**Пример:**
```python
if __name__ == "__main__":
# Вызов API для создания заказа
result = send_request("POST", "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1")
# Обработка ответа
if result['status_code'] == 200:
print("Заказ успешно создан:")
print(result['response'])
else:
print(f"Ошибка: {result['status_code']}")
print(result['response'])
```
***
**4.3 Проверка статуса заказа**
* **Endpoint**: `/api/order/{pay_hash}`
* **HTTP-метод**: `GET`
**Пример:**
```python
if __name__ == "__main__":
# ID заказа для проверки
pay_hash = "abcd1234" # Замените на реальный pay_hash
# Вызов API для проверки статуса заказа
result = send_request("GET", f"/api/order/{pay_hash}")
# Обработка ответа
if result['status_code'] == 200:
print("Статус заказа:")
print(result['response'])
else:
print(f"Ошибка: {result['status_code']}")
print(result['response'])
```
***
#### **5. Часто встречающиеся ошибки**
**5.1 Неверная подпись (401 Unauthorized)**
* Убедитесь, что заголовок `MF-ACCESS-KEY` содержит правильный API-ключ.
* Проверьте, что строка для подписи сформирована в правильной последовательности: `timestamp + method + requestPath`.
* Используйте правильный **SECRET\_KEY**.
* Метка времени должна быть в формате UTC.
**5.2 Ошибки параметров (400 Bad Request)**
* Проверьте правильность пути и параметров в запросе.
* Убедитесь, что заголовок `Content-Type` установлен как `application/json`.
**5.3 Ограничение частоты запросов (429 Too Many Requests)**
* Mefree API имеет ограничения на частоту запросов. Избегайте частых вызовов в короткий промежуток времени.
* Рекомендуется не превышать 2 запроса в секунду.
***
#### **6. Заключение**
Это руководство поможет вам эффективно взаимодействовать с API Mefree.NET на Python. Вы можете создавать запросы, обрабатывать ответы и получать доступ к функционалу платформы. Для критически важных операций (например, создание заказа) рекомендуется реализовать повторные попытки для повышения надежности. При возникновении вопросов обратитесь в службу поддержки Mefree.
# Руководство по вызову Mefree.NET API на Node.js
Данное руководство описывает процесс взаимодействия с API платформы **Mefree.NET** с использованием Node.js. Оно включает создание подписи, отправку запросов и обработку ответов от API.
***
#### **1. Общая информация о правилах подписи**
Для аутентификации Mefree.NET API требует подпись, которая создаётся следующим образом:
**1.1 Формирование строки для подписи**
Строка для подписи формируется по следующему шаблону:
```plaintext
sign = timestamp + method + requestPath
```
* **timestamp**: Метка времени в формате UTC (ISO 8601), например: `2024-11-26T12:34:56.789Z`.
* **method**: HTTP-метод, например, `GET` или `POST`.
* **requestPath**: Путь запроса (включая параметры), например:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Процесс генерации подписи**
1. Объедините `timestamp`, `method` и `requestPath` в строку.
2. Используйте алгоритм **HMAC-SHA256**, чтобы зашифровать строку с использованием вашего **секретного ключа API (Secret Key)**.
3. Закодируйте результат с помощью **Base64**, чтобы получить финальную подпись.
**1.3 Заголовки HTTP-запроса**
Каждый запрос к API должен содержать следующие заголовки:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Ваш API-ключ.
* `MF-ACCESS-SIGN`: Сгенерированная подпись.
* `MF-ACCESS-TIMESTAMP`: Метка времени в формате UTC.
***
#### **2. Реализация подписи на Node.js**
**2.1 Установка необходимых библиотек**
Перед началом убедитесь, что у вас установлены следующие библиотеки:
```bash
npm install axios crypto
```
* **axios**: Для отправки HTTP-запросов.
* **crypto**: Встроенная библиотека Node.js для создания подписи.
***
**2.2 Функция для генерации подписи**
Ниже приведён пример функции для генерации подписи:
```javascript
const crypto = require('crypto');
/**
* Генерация подписи для Mefree API.
*
* @param {string} timestamp Метка времени (UTC в формате ISO 8601)
* @param {string} method HTTP-метод (GET/POST)
* @param {string} requestPath Путь запроса (включая параметры)
* @param {string} secretKey Секретный ключ API
* @returns {string} Подпись в формате Base64
*/
function generateSignature(timestamp, method, requestPath, secretKey) {
// Формируем строку для подписи
const stringToSign = `${timestamp}${method}${requestPath}`;
// Используем HMAC-SHA256 для шифрования строки
const hmac = crypto.createHmac('sha256', secretKey);
hmac.update(stringToSign);
// Возвращаем подпись в формате Base64
return hmac.digest('base64');
}
```
***
#### **3. Создание запросов к API**
**3.1 Конфигурация**
Задайте базовые параметры для подключения к API:
```javascript
const axios = require('axios');
// Конфигурация API
const BASE_URL = "https://api.mefree.net"; // Базовый URL Mefree API
const API_KEY = "your_api_key"; // Ваш API-ключ
const SECRET_KEY = "your_secret_key"; // Ваш секретный ключ
```
**3.2 Универсальная функция для отправки запросов**
Используйте следующую функцию для отправки запросов:
```javascript
/**
* Отправка запроса к Mefree API.
*
* @param {string} method HTTP-метод (GET/POST)
* @param {string} requestPath Путь запроса (включая параметры)
* @returns {Promise} Ответ API
*/
async function sendRequest(method, requestPath) {
// Генерируем метку времени (UTC)
const timestamp = new Date().toISOString();
// Генерируем подпись
const signature = generateSignature(timestamp, method, requestPath, SECRET_KEY);
// Заголовки запроса
const headers = {
'Content-Type': 'application/json',
'MF-ACCESS-KEY': API_KEY,
'MF-ACCESS-SIGN': signature,
'MF-ACCESS-TIMESTAMP': timestamp,
};
// Полный URL
const url = `${BASE_URL}${requestPath}`;
try {
// Выполняем запрос
const response = await axios({
method,
url,
headers,
});
// Возвращаем ответ API
return {
statusCode: response.status,
data: response.data,
};
} catch (error) {
// Обработка ошибок
return {
statusCode: error.response?.status || 500,
error: error.response?.data || error.message,
};
}
}
```
***
#### **4. Примеры вызовов API**
**4.1 Получение информации об аккаунте**
* **Endpoint**: `/api/config`
* **HTTP-метод**: `GET`
**Пример:**
```javascript
(async () => {
const response = await sendRequest('GET', '/api/config');
if (response.statusCode === 200) {
console.log("Информация об аккаунте:", response.data);
} else {
console.error("Ошибка:", response);
}
})();
```
***
**4.2 Создание заказа**
* **Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* **HTTP-метод**: `POST`
**Пример:**
```javascript
(async () => {
const requestPath = '/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1';
const response = await sendRequest('POST', requestPath);
if (response.statusCode === 200) {
console.log("Заказ успешно создан:", response.data);
} else {
console.error("Ошибка:", response);
}
})();
```
***
**4.3 Проверка статуса заказа**
* **Endpoint**: `/api/order/{pay_hash}`
* **HTTP-метод**: `GET`
**Пример:**
```javascript
(async () => {
const payHash = 'abcd1234'; // Замените на реальный pay_hash
const requestPath = `/api/order/${payHash}`;
const response = await sendRequest('GET', requestPath);
if (response.statusCode === 200) {
console.log("Статус заказа:", response.data);
} else {
console.error("Ошибка:", response);
}
})();
```
***
#### **5. Часто встречающиеся ошибки**
**5.1 Неверная подпись (401 Unauthorized)**
* Убедитесь, что заголовок `MF-ACCESS-KEY` содержит правильный API-ключ.
* Проверьте, что строка для подписи сформирована в правильной последовательности: `timestamp + method + requestPath`.
* Используйте правильный **SECRET\_KEY**.
* Метка времени должна быть в формате UTC.
**5.2 Ошибки параметров (400 Bad Request)**
* Проверьте правильность пути и параметров в запросе.
* Убедитесь, что заголовок `Content-Type` установлен как `application/json`.
**5.3 Ограничение частоты запросов (429 Too Many Requests)**
* Mefree API имеет ограничения на частоту запросов. Избегайте частых вызовов в короткий промежуток времени.
* Рекомендуется не превышать 2 запроса в секунду.
***
#### **6. Заключение**
С помощью этого руководства вы сможете успешно взаимодействовать с Mefree.NET API на Node.js. Вы научитесь создавать запросы, обрабатывать ответы и управлять действиями через API. Для важнейших операций (например, создание заказа) рекомендуется реализовать повторные попытки для повышения надежности. При возникновении вопросов обратитесь в службу поддержки Mefree.
# Руководство по вызову Mefree.NET API на PHP
Данное руководство подробно описывает, как взаимодействовать с API платформы **Mefree.NET** с использованием PHP. Включены инструкции по созданию подписи, построению запросов и обработке ответов.
***
#### **1. Общая информация о правилах подписи**
Для аутентификации API **Mefree.NET** используется механизм подписи. Подпись создаётся следующим образом:
**1.1 Формирование строки для подписи**
Строка подписи формируется по следующему шаблону:
```plaintext
sign = timestamp + method + requestPath
```
* **timestamp**: Метка времени в формате UTC (ISO 8601), например: `2024-11-26T12:34:56.789Z`.
* **method**: HTTP-метод, например, `GET` или `POST`.
* **requestPath**: Путь запроса, включая параметры, например:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Процесс генерации подписи**
1. Сформируйте строку из `timestamp`, `method` и `requestPath`.
2. Используйте алгоритм **HMAC-SHA256** для шифрования строки с использованием **секретного ключа API (Secret Key)**.
3. Закодируйте результат с помощью **Base64** — это и будет подпись.
**1.3 Заголовки запроса**
Каждый запрос к API должен содержать следующие заголовки:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Ваш API-ключ.
* `MF-ACCESS-SIGN`: Сгенерированная подпись.
* `MF-ACCESS-TIMESTAMP`: Метка времени в формате UTC.
***
#### **2. Реализация подписи на PHP**
**2.1 Функция для генерации подписи**
Пример функции для создания подписи:
```php
/**
* Генерация подписи для Mefree API.
*
* @param string $timestamp Метка времени (UTC в формате ISO 8601)
* @param string $method HTTP-метод (GET/POST)
* @param string $request_path Путь запроса (включая параметры)
* @param string $secret_key Секретный ключ API
* @return string Подпись в формате Base64
*/
function generate_signature($timestamp, $method, $request_path, $secret_key) {
// Формируем строку для подписи
$string_to_sign = $timestamp . $method . $request_path;
// Создаём HMAC-SHA256 подпись
$hash = hash_hmac('sha256', $string_to_sign, $secret_key, true);
// Кодируем подпись в Base64
return base64_encode($hash);
}
```
***
#### **3. Отправка запросов к API**
**3.1 Базовая конфигурация**
Задайте параметры подключения к API:
```php
// Конфигурация API
$base_url = "https://api.mefree.net"; // Базовый URL Mefree API
$api_key = "your_api_key"; // Ваш API-ключ
$secret_key = "your_secret_key"; // Ваш секретный ключ
```
**3.2 Функция отправки запросов**
Используйте следующую функцию для отправки запросов к API:
```php
/**
* Отправка запроса к Mefree API.
*
* @param string $method HTTP-метод (GET/POST)
* @param string $request_path Путь запроса (включая параметры)
* @param string $base_url Базовый URL API
* @param string $api_key API-ключ
* @param string $secret_key Секретный ключ API
* @return array Ответ API
*/
function send_request($method, $request_path, $base_url, $api_key, $secret_key) {
// Генерируем текущую метку времени в UTC
$timestamp = gmdate("Y-m-d\TH:i:s.v\Z");
// Создаём подпись
$signature = generate_signature($timestamp, $method, $request_path, $secret_key);
// Устанавливаем заголовки запроса
$headers = [
"Content-Type: application/json",
"MF-ACCESS-KEY: {$api_key}",
"MF-ACCESS-SIGN: {$signature}",
"MF-ACCESS-TIMESTAMP: {$timestamp}",
];
// Инициализация CURL
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $base_url . $request_path); // Устанавливаем URL
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method); // Устанавливаем HTTP-метод
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers); // Устанавливаем заголовки
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); // Возвращаем ответ
// Выполняем запрос
$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Получаем HTTP-код ответа
curl_close($ch);
// Возвращаем результат
return [
"status_code" => $http_code,
"response" => $response
];
}
```
***
#### **4. Примеры вызовов API**
**4.1 Получение информации об аккаунте**
* **Endpoint**: `/api/config`
* **HTTP-метод**: `GET`
**Пример кода:**
```php
// Получение информации об аккаунте
$request_path = "/api/config"; // Путь запроса
$response = send_request("GET", $request_path, $base_url, $api_key, $secret_key);
// Обработка ответа
if ($response['status_code'] == 200) {
echo "Информация об аккаунте:\n";
echo $response['response'];
} else {
echo "Ошибка: HTTP статус " . $response['status_code'] . "\n";
echo "Ответ API: " . $response['response'];
}
```
***
**4.2 Создание заказа**
* **Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* **HTTP-метод**: `POST`
**Пример кода:**
```php
// Создание заказа
$request_path = "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"; // Путь запроса
$response = send_request("POST", $request_path, $base_url, $api_key, $secret_key);
// Обработка ответа
if ($response['status_code'] == 200) {
echo "Заказ успешно создан:\n";
echo $response['response'];
} else {
echo "Ошибка: HTTP статус " . $response['status_code'] . "\n";
echo "Ответ API: " . $response['response'];
}
```
***
**4.3 Проверка статуса заказа**
* **Endpoint**: `/api/order/{pay_hash}`
* **HTTP-метод**: `GET`
**Пример кода:**
```php
// Проверка статуса заказа
$pay_hash = "abcd1234"; // Замените на реальный pay_hash
$request_path = "/api/order/" . $pay_hash; // Путь запроса
$response = send_request("GET", $request_path, $base_url, $api_key, $secret_key);
// Обработка ответа
if ($response['status_code'] == 200) {
echo "Статус заказа:\n";
echo $response['response'];
} else {
echo "Ошибка: HTTP статус " . $response['status_code'] . "\n";
echo "Ответ API: " . $response['response'];
}
```
***
#### **5. Частые ошибки**
**5.1 Неверная подпись (401 Unauthorized)**
* Проверьте правильность `MF-ACCESS-KEY`.
* Убедитесь, что строка для подписи создана по шаблону: `timestamp + method + requestPath`.
* Убедитесь, что используется правильный **SECRET\_KEY**.
* Метка времени должна быть в формате UTC.
**5.2 Ошибка параметров (400 Bad Request)**
* Проверьте корректность пути и параметров запроса.
* Убедитесь, что заголовок `Content-Type` установлен как `application/json`.
**5.3 Ограничение частоты запросов (429 Too Many Requests)**
* Mefree API ограничивает частоту запросов. Избегайте чрезмерного количества запросов за короткое время.
* Рекомендуемая частота: не более 2 запросов в секунду.
***
#### **6. Заключение**
С помощью данного руководства вы сможете эффективно взаимодействовать с Mefree.NET API, используя PHP. Включены примеры создания запросов, обработки ответов и управления операциями через API. Для критически важных действий (например, создание заказа) рекомендуется добавлять механизм повторных попыток. Если у вас возникнут вопросы, обратитесь в службу поддержки Mefree.
# Руководство по вызову Mefree.NET API на Go
В этом руководстве подробно описано, как работать с API платформы **Mefree.NET** на языке Go. Приведены инструкции по генерации подписи, отправке запросов и обработке ответов.
***
#### **1. Общая информация о правилах подписи**
Для аутентификации API **Mefree.NET** используется механизм подписи. Подпись формируется следующим образом:
**1.1 Формирование строки для подписи**
Строка подписи формируется по следующему шаблону:
```plaintext
sign = timestamp + method + requestPath
```
* **timestamp**: Метка времени в формате UTC (ISO 8601), например: `2024-11-26T12:34:56.789Z`.
* **method**: HTTP-метод, например, `GET` или `POST`.
* **requestPath**: Путь запроса, включая параметры, например:
* `/api/config`
* `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
**1.2 Процесс генерации подписи**
1. Создайте строку из `timestamp`, `method` и `requestPath`.
2. Используйте алгоритм **HMAC-SHA256** для шифрования строки с использованием **секретного ключа API (Secret Key)**.
3. Закодируйте результат с помощью **Base64** — это и будет подпись.
**1.3 Заголовки запроса**
Каждый запрос к API должен содержать следующие заголовки:
* `Content-Type`: `application/json`
* `MF-ACCESS-KEY`: Ваш API-ключ.
* `MF-ACCESS-SIGN`: Сгенерированная подпись.
* `MF-ACCESS-TIMESTAMP`: Метка времени в формате UTC.
***
#### **2. Реализация подписи на Go**
**2.1 Функция для генерации подписи**
Пример функции для создания подписи:
```go
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"fmt"
)
// GenerateSignature создаёт подпись для Mefree API
func GenerateSignature(timestamp, method, requestPath, secretKey string) (string, error) {
// Формируем строку для подписи
stringToSign := timestamp + method + requestPath
// Создаём HMAC-SHA256 хэш
h := hmac.New(sha256.New, []byte(secretKey))
_, err := h.Write([]byte(stringToSign))
if err != nil {
return "", err
}
// Кодируем хэш в Base64
signature := base64.StdEncoding.EncodeToString(h.Sum(nil))
return signature, nil
}
```
***
#### **3. Отправка запросов к API**
**3.1 Базовая конфигурация**
Настройте параметры подключения к API:
```go
const (
BaseURL = "https://api.mefree.net" // Базовый URL Mefree API
APIKey = "your_api_key" // Ваш API-ключ
SecretKey = "your_secret_key" // Ваш секретный ключ
)
```
**3.2 Функция отправки запросов**
Используйте следующую функцию для отправки запросов к API:
```go
package main
import (
"bytes"
"fmt"
"io/ioutil"
"net/http"
"time"
)
// SendRequest отправляет запрос к Mefree API
func SendRequest(method, requestPath string) (int, string, error) {
// Генерируем текущую метку времени в формате UTC
timestamp := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
// Создаём подпись
signature, err := GenerateSignature(timestamp, method, requestPath, SecretKey)
if err != nil {
return 0, "", fmt.Errorf("error generating signature: %v", err)
}
// Устанавливаем заголовки
headers := map[string]string{
"Content-Type": "application/json",
"MF-ACCESS-KEY": APIKey,
"MF-ACCESS-SIGN": signature,
"MF-ACCESS-TIMESTAMP": timestamp,
}
// Формируем запрос
url := BaseURL + requestPath
req, err := http.NewRequest(method, url, nil)
if err != nil {
return 0, "", fmt.Errorf("error creating request: %v", err)
}
// Добавляем заголовки к запросу
for key, value := range headers {
req.Header.Set(key, value)
}
// Отправляем запрос
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return 0, "", fmt.Errorf("error sending request: %v", err)
}
defer resp.Body.Close()
// Читаем тело ответа
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return resp.StatusCode, "", fmt.Errorf("error reading response: %v", err)
}
return resp.StatusCode, string(body), nil
}
```
***
#### **4. Примеры вызовов API**
**4.1 Получение информации об аккаунте**
* **Endpoint**: `/api/config`
* **HTTP-метод**: `GET`
**Пример кода:**
```go
func main() {
// Путь запроса
requestPath := "/api/config"
// Отправляем запрос
statusCode, response, err := SendRequest("GET", requestPath)
if err != nil {
fmt.Printf("Ошибка: %v\n", err)
return
}
// Обрабатываем ответ
if statusCode == 200 {
fmt.Println("Информация об аккаунте:")
fmt.Println(response)
} else {
fmt.Printf("Ошибка: HTTP статус %d\nОтвет: %s\n", statusCode, response)
}
}
```
***
**4.2 Создание заказа**
* **Endpoint**: `/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1`
* **HTTP-метод**: `POST`
**Пример кода:**
```go
func main() {
// Путь запроса
requestPath := "/api/order?quantity=65000&target_address=TRON_ADDRESS&period=1"
// Отправляем запрос
statusCode, response, err := SendRequest("POST", requestPath)
if err != nil {
fmt.Printf("Ошибка: %v\n", err)
return
}
// Обрабатываем ответ
if statusCode == 200 {
fmt.Println("Заказ успешно создан:")
fmt.Println(response)
} else {
fmt.Printf("Ошибка: HTTP статус %d\nОтвет: %s\n", statusCode, response)
}
}
```
***
**4.3 Проверка статуса заказа**
* **Endpoint**: `/api/order/{pay_hash}`
* **HTTP-метод**: `GET`
**Пример кода:**
```go
func main() {
// Путь запроса
payHash := "abcd1234" // Замените на реальный pay_hash
requestPath := "/api/order/" + payHash
// Отправляем запрос
statusCode, response, err := SendRequest("GET", requestPath)
if err != nil {
fmt.Printf("Ошибка: %v\n", err)
return
}
// Обрабатываем ответ
if statusCode == 200 {
fmt.Println("Статус заказа:")
fmt.Println(response)
} else {
fmt.Printf("Ошибка: HTTP статус %d\nОтвет: %s\n", statusCode, response)
}
}
```
***
#### **5. Частые ошибки**
**5.1 Неверная подпись (401 Unauthorized)**
* Проверьте правильность `MF-ACCESS-KEY`.
* Убедитесь, что строка для подписи составлена по шаблону: `timestamp + method + requestPath`.
* Используется правильный **SECRET\_KEY**.
* Метка времени должна быть в формате UTC.
**5.2 Ошибка параметров (400 Bad Request)**
* Проверьте корректность пути и параметров запроса.
* Убедитесь, что заголовок `Content-Type` установлен как `application/json`.
**5.3 Ограничение частоты запросов (429 Too Many Requests)**
* Mefree API ограничивает частоту запросов. Избегайте чрезмерного количества запросов за короткий период.
* Рекомендуемая частота: не более 2 запросов в секунду.
***
#### **6. Заключение**
С помощью данного руководства вы сможете эффективно взаимодействовать с API платформы **Mefree.NET** на языке Go. Включены примеры создания запросов, обработки ответов и управления операциями через API. Для критически важных операций (например, создание заказа) рекомендуется реализовать повторные попытки. Если у вас возникнут вопросы, обращайтесь в службу поддержки **Mefree.NET**.
# Часто задаваемые вопросы и решения (FAQ)
Ниже представлены распространенные проблемы при использовании API **Mefree.NET** и рекомендации по их решению, чтобы помочь вам быстро разобраться с возникшими трудностями.
***
#### **1. Проблемы с аккаунтом и правами доступа**
**1.1 Почему мой API-ключ не работает?**
**Причины:**
* API-ключ мог быть отключён или удалён.
**Решение:**
* Авторизуйтесь в **боте Telegram Mefree** ([@SuperXCoinBot](https://t.me/SuperXCoinBot)) и проверьте статус вашего API-ключа в личном кабинете.
***
**1.2 Как настроить доступ к API-ключу только с определённых IP-адресов?**
**Решение:**
* При создании или редактировании API-ключа укажите IP-адреса, с которых разрешены запросы.
* После настройки API-ключ будет принимать запросы только с указанных IP-адресов, что повышает безопасность.
***
#### **2. Проблемы с подписью и аутентификацией**
**2.1 Почему возвращается ошибка 401 Unauthorized?**
**Причины:**
* Неправильные **MF-ACCESS-KEY** или **MF-ACCESS-SIGN**.
* Ошибки при генерации подписи.
* Разница между вашим временем и временем сервера превышает 5 секунд.
**Решение:**
1. Проверьте, совпадает ли **MF-ACCESS-KEY** с вашим API-ключом.
2. Убедитесь, что подпись сгенерирована в соответствии с **правилами подписи**.
3. Используйте UTC-время и убедитесь, что разница с серверным временем не превышает 5 секунд.
***
**2.2 Как проверить корректность подписи?**
**Решение:**
1. Выведите строку для подписи (формат: `timestamp + method + requestPath`).
2. Сравните сгенерированную подпись с локально вычисленной.
3. Используйте инструменты (например, Postman или Curl) для ручного тестирования подписи.
***
#### **3. Проблемы с запросами и ответами**
**3.1 Почему возвращается ошибка 400 Bad Request?**
**Причины:**
* Ошибки в параметрах запроса (например, отсутствует обязательное поле или неверный формат данных).
* Неправильный путь к API.
**Решение:**
* Проверьте документацию API и убедитесь, что все параметры запроса указаны верно.
* Убедитесь, что заголовок `Content-Type` установлен как `application/json`.
* Проверьте, правильно ли отформатирован JSON в теле запроса.
***
**3.2 Почему возвращается ошибка 429 Too Many Requests?**
**Причины:**
* Частота запросов превышает лимит API.
**Решение:**
* Ознакомьтесь с документацией API, чтобы узнать лимиты запросов.
* Реализуйте в коде ограничение скорости (например, не превышать количество запросов в секунду).
* Если вы используете распределённую систему, убедитесь, что общая частота запросов не превышает допустимый лимит.
***
**3.3 Почему возвращается ошибка 500 Internal Server Error?**
**Причины:**
* На сервере API могут возникать временные проблемы.
**Решение:**
1. Проверьте соединение с сетью, чтобы убедиться, что запрос отправлен корректно.
2. Повторите запрос через несколько секунд.
3. Если проблема сохраняется, обратитесь в **техническую поддержку Mefree**.
***
#### **4. Проблемы с конкретными методами API**
**4.1 Почему невозможно создать заказ?**
**Причины:**
* Недостаточно средств на счёте.
* Ошибки в параметрах заказа (например, неверное количество или срок).
* Аккаунт не имеет права создавать заказы.
**Решение:**
1. Проверьте, хватает ли средств на вашем счёте.
2. Убедитесь, что параметры заказа соответствуют требованиям, указанным в документации.
3. Убедитесь, что у аккаунта есть права на размещение заказов.
***
#### **5. Проблемы с разработкой и отладкой**
**5.1 Как справиться с тайм-аутами?**
**Причины:**
* Слабое соединение с интернетом или нестабильная сеть.
**Решение:**
1. Установите более длительное время ожидания для запросов (например, `timeout=30`).
2. Для критически важных операций настройте повторные попытки (например, 2-3 раза).
3. Проверьте соединение между вашим сервером и API **Mefree**.
***
**5.2 Как обрабатывать ответы API?**
**Решение:**
* Ответы API **Mefree** обычно представлены в формате JSON с такой структурой:
```json
{
"code": "0",
"msg": "",
"data": {
"key": "value"
}
}
```
* **Описание полей:**
* `code`: Код ответа, `0` — успешный запрос, любое другое значение — ошибка.
* `msg`: Описание ошибки (только при ошибке).
* `data`: Основная информация (например, детали заказа или баланс).
***
#### **6. Прочие проблемы**
**6.1 Почему возникают ошибки с временной меткой?**
**Причины:**
* Локальное время отличается от серверного UTC.
**Решение:**
* Используйте метод `datetime.utcnow()` в Python для получения UTC-времени.
***
**6.2 Как справляться с обновлениями API?**
**Решение:**
1. Подпишитесь на **объявления для разработчиков Mefree**, чтобы быть в курсе изменений API.
2. Регулярно обновляйте ваш код, чтобы соответствовать новой версии API.
3. Используйте версионирование API (например, `/v1/`), чтобы избежать проблем с совместимостью при обновлениях.
***
#### **7. Техническая поддержка**
Если вы не можете самостоятельно решить проблему, воспользуйтесь одним из следующих способов для связи с **техподдержкой Mefree**:
* **Подать заявку**: через центр поддержки Mefree.
* **Документация для разработчиков**: [официальная документация API](https://mefree.net/api-docs).
* **Связь через Telegram**: напишите в чат [**@mefreenet**](https://t.me/mefreenet).
***
Надеемся, что этот FAQ поможет вам быстро разобраться с проблемами при использовании **API Mefree.NET**. Если у вас возникнут дополнительные вопросы, не стесняйтесь обращаться в поддержку или задавать их здесь!
# Информация об аккаунте
{% openapi src="/files/S7ogLk319Rvo6RmEBDSD" path="/api/config" method="get" %}
[api.json](https://1536932170-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0I1cbqzAWyr7X8OzPW5s%2Fuploads%2Fgit-blob-f76b25fb15a5926f526148c882342481e1f412cf%2Fapi.json?alt=media)
{% endopenapi %}
# Купить энергию
##
{% openapi src="/files/S7ogLk319Rvo6RmEBDSD" path="/api/order" method="post" %}
[api.json](https://1536932170-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0I1cbqzAWyr7X8OzPW5s%2Fuploads%2Fgit-blob-f76b25fb15a5926f526148c882342481e1f412cf%2Fapi.json?alt=media)
{% endopenapi %}
#### **Основной API: Создание заказа (POST /order)**
При создании заказа через API **Mefree.net**, важно обратить внимание на три ключевых параметра в ответе API:
1. **`pay_hash` (хэш платежа/ID заказа)**\
Уникальный идентификатор для каждого заказа.\
С его помощью можно запросить подробную информацию о заказе через интерфейс `GET /order/{pay_hash}`.
2. **`status` (статус заказа)**\
Показывает прогресс выполнения заказа.\
Если статус **`DELEGATE_SUCCESS`**, это значит, что сделка по энергии была успешно отправлена в блокчейн Tron.\
⚠️ Примечание: существует небольшая вероятность (примерно 0.1%), что транзакция не попадёт в блокчейн.
3. **`confirm_status` (статус подтверждения на блокчейне)**\
Отражает, была ли энергия успешно отправлена на целевой адрес.\
Если **`confirm_status`** = `DELEGATION_CONFIRMED`, это значит, что энергия была успешно подтверждена и отправлена в блокчейне.
***
#### **Как убедиться, что энергия отправлена на целевой адрес?**
Используйте два способа проверки:
1. **Запрос к API блокчейна Tron для проверки баланса энергии на целевом адресе.**\
Используйте Tron API или инструменты кошелька (например, TronLink) для проверки энергии на целевом адресе.
Пример запроса к официальному API Tron:
```bash
curl --request POST \
--url https://api.trongrid.io/wallet/getaccountresource \
--header 'accept: application/json' \
--header 'content-type: application/json' \
--data '
{
"address": "TZ4UXDV5ZhNW7fb2AMSbgfAEZ7hWsnYS2g",
"visible": true
}
'
```
В ответе проверьте такие поля, как `energy_limit` и `energy_used`.
2. **Запрос статуса заказа через `GET /order/{pay_hash}`.**\
Если **`confirm_status`** = `DELEGATION_CONFIRMED`, это значит, что энергия была успешно отправлена и подтверждена на блокчейне.
***
#### **Пример процесса работы**
**1. Создание заказа**
Пример запроса:
```http
POST /order?count=1&target_address=TRON_ADDRESS&period=1
Host: https://api.mefree.net
Headers:
Content-Type: application/json
MF-ACCESS-KEY: {api_key}
MF-ACCESS-SIGN: {signature}
MF-ACCESS-TIMESTAMP: {timestamp}
```
Пример ответа:
```json
{
"pay_hash": "abcd1234",
"status": "DELEGATE_SUCCESS",
"confirm_status": "UNCONFIRMED"
}
```
***
**2. Проверка статуса заказа**
Пример запроса:
```http
GET /order/abcd1234
Host: https://api.mefree.net
Headers:
Content-Type: application/json
MF-ACCESS-KEY: {api_key}
MF-ACCESS-SIGN: {signature}
MF-ACCESS-TIMESTAMP: {timestamp}
```
Пример ответа:
```json
{
"pay_hash": "abcd1234",
"status": "DELEGATE_SUCCESS",
"confirm_status": "DELEGATION_CONFIRMED"
}
```
***
**3. Подтверждение успешной отправки энергии**
* Если **`confirm_status` = `DELEGATION_CONFIRMED`**, энергия успешно отправлена.
* Для дополнительной проверки вы можете запросить баланс энергии на целевом адресе через Tron API.
***
#### **Часто задаваемые вопросы**
**Почему статус заказа `DELEGATE_SUCCESS`, но энергия не поступила?**
**Причина:**\
Транзакция могла не попасть в блокчейн (вероятность около 0.1%).
**Решение:**
* Подождите некоторое время и снова запросите статус заказа.
* Проверьте транзакцию в блокчейне Tron с помощью соответствующего API.
***
**Почему задерживается зачисление энергии?**
**Причина:**\
Сеть блокчейна может быть перегружена.
**Решение:**
* Убедитесь, что статус заказа **`DELEGATION_CONFIRMED`**, после чего энергия считается зачисленной.
***
#### **Советы для надежной работы**
* Обращайте внимание на поля **`pay_hash`** и **`confirm_status`**, чтобы отслеживать статус заказов.
* При необходимости проверяйте баланс целевого адреса через Tron API.
Если у вас возникают вопросы или сложности, свяжитесь с технической поддержкой **Mefree** через Telegram: [@mefreenet](https://t.me/mefreenet).
# Детали заказа
{% openapi src="/files/S7ogLk319Rvo6RmEBDSD" path="/api/order/{pay\_hash}" method="get" %}
[api.json](https://1536932170-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0I1cbqzAWyr7X8OzPW5s%2Fuploads%2Fgit-blob-f76b25fb15a5926f526148c882342481e1f412cf%2Fapi.json?alt=media)
{% endopenapi %}
Данные возврата заказа требуют внимания к данным `status` и `confirm_status`, [см. здесь](/ru/api/create-order).
# доступная энергия
{% openapi src="/files/S7ogLk319Rvo6RmEBDSD" path="/api/available" method="get" %}
[api.json](https://1536932170-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0I1cbqzAWyr7X8OzPW5s%2Fuploads%2Fgit-blob-f76b25fb15a5926f526148c882342481e1f412cf%2Fapi.json?alt=media)
{% endopenapi %}
# Энергия, необходимая для перевода USDT
{% openapi src="/files/S7ogLk319Rvo6RmEBDSD" path="/api/usdt/energy\_used" method="get" %}
[api.json](https://1536932170-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0I1cbqzAWyr7X8OzPW5s%2Fuploads%2Fgit-blob-f76b25fb15a5926f526148c882342481e1f412cf%2Fapi.json?alt=media)
{% endopenapi %}