您现在的位置是：首页 > 介绍介绍

Gemini API实战：7步玩转加密货币交易 (2024速成)

时间：2025-03-07 71人已围观

欧易 Gemini API 接口使用教程

简介

Gemini 是一家总部位于美国的受监管加密货币交易所和托管机构，由 Winklevoss 兄弟创立。它以安全、合规和用户友好界面而闻名，提供包括比特币 (BTC)、以太坊 (ETH) 等多种加密货币的交易服务。 Gemini 致力于为个人和机构投资者提供一个安全可靠的数字资产交易平台。通过其 API（应用程序编程接口），开发者可以构建各种应用程序，例如实现算法交易策略、进行高级数据分析、自动化投资组合管理、以及集成 Gemini 的交易功能到第三方平台。 Gemini API 提供了全面的数据访问和交易执行能力，允许开发者根据自身需求定制解决方案。本文档将详细介绍如何使用 Gemini API 接口，包括认证方式、数据请求格式、常见 API 端点，以及如何处理 API 返回结果，帮助开发者快速上手并实现所需功能。本指南将涵盖从API密钥的获取到实际交易的示例代码，确保开发者能够高效地利用Gemini API。注意：虽然标题包含“欧易”，这是一个笔误。以下内容讲述的是 Gemini 的 API 使用方法。请区分交易所，并以 Gemini API 为准。

准备工作

在使用 Gemini API 之前，为了确保顺利对接和安全使用，需要完成以下准备工作，这些准备工作是后续开发和应用的基础：

注册 Gemini 账号: 前往 Gemini 官方网站 (https://www.gemini.com/)，按照注册流程创建一个账户。该账户将作为您访问和管理 Gemini API 资源的凭证。请务必使用安全强度高的密码，并启用双因素认证，以提高账户的安全性。
启用 API 访问: 成功登录 Gemini 账户后，导航至账户设置或安全中心的 API 密钥管理页面。在此页面，您可以创建新的 API 密钥。Gemini 可能要求进行额外的身份验证以确保安全性。创建时，请根据您的应用场景选择合适的 API 密钥权限，遵循最小权限原则，避免赋予不必要的权限。例如，如果您的应用只需要读取市场数据，则不要授予交易权限。
保存 API 密钥: 创建 API 密钥后，系统会生成一个 API 密钥 (API Key) 和一个 API 密钥 Secret (API Secret)。API Key 用于标识您的应用程序，而 API Secret 用于验证您的身份。请务必将这些密钥存储在安全的地方，例如使用密钥管理服务或加密的文件存储。切勿将 API 密钥直接嵌入到客户端代码中，或提交到公共代码仓库。泄露 API 密钥可能会导致您的账户被盗用，并承担不必要的损失。强烈建议定期轮换 API 密钥，以提高安全性。

安全提示：强烈建议启用 API 访问限制，例如限制 IP 地址和交易权限，以确保账户安全。

API 认证

Gemini API 通过 API 密钥 (API Key) 和密钥 Secret (API Secret) 进行身份验证，确保请求的安全性。每个向 Gemini API 发出的请求，都必须在 HTTP 请求头中包含以下三个关键字段，以便服务器验证请求的身份和完整性：

X-GEMINI-APIKEY : 这是你的唯一 API 密钥，用于标识你的账户。请务必妥善保管，避免泄露。
X-GEMINI-SIGNATURE : 这是请求体的 HMAC-SHA384 签名，用于验证请求的完整性，防止篡改。该签名使用 API Secret 作为密钥，对请求体内容进行加密生成。
X-GEMINI-PAYLOAD : 这是请求体内容的 Base64 编码版本。Gemini API 要求请求体必须先进行 Base64 编码，再进行签名。

以下是一个使用 Python 语言计算 X-GEMINI-SIGNATURE 的示例代码，它演示了如何使用 API Secret 对请求体进行签名：

import hashlib
import hmac
import base64
import time

def generate_signature(api_secret, payload):
    """
    生成 Gemini API 请求签名.

    Args:
        api_secret (str): 你的 Gemini API Secret.
        payload (str): 请求体内容（字符串）.

    Returns:
        str: 生成的签名.
    """
    encoded_payload = base64.b64encode(payload.encode('utf-8'))
    hmac_digest = hmac.new(api_secret.encode('utf-8'), encoded_payload, hashlib.sha384).hexdigest()
    return hmac_digest

代码解释：

`import hashlib, hmac, base64, time` : 导入必要的 Python 库。`hashlib` 用于哈希算法，`hmac` 用于 HMAC 签名，`base64` 用于 Base64 编码。
`encoded_payload = base64.b64encode(payload.encode('utf-8'))` : 首先将请求体 `payload` 编码为 UTF-8 格式，然后对其进行 Base64 编码。 `utf-8` 确保能正确处理各种字符。
`hmac_digest = hmac.new(api_secret.encode('utf-8'), encoded_payload, hashlib.sha384).hexdigest()` : 使用 API Secret 作为密钥，对 Base64 编码后的请求体进行 HMAC-SHA384 签名。`api_secret.encode('utf-8')` 将 API Secret 转换为字节串, `hmac.new()` 创建一个新的 HMAC 对象, `hashlib.sha384` 指定哈希算法, `hexdigest()` 方法将签名结果转换为十六进制字符串。
`return hmac_digest` : 返回生成的签名。

注意事项：

请确保你的 API Secret 始终安全，不要在客户端代码中硬编码，更不要泄露给他人。
`payload` 应该是经过 JSON 序列化后的字符串，并且顺序要与 API 文档中的定义完全一致。不一致的顺序会导致签名验证失败。
时间戳也是常见的一部分，需要和服务器时间同步。
在实际使用中，请使用安全的存储方式来保存你的 API 密钥和 Secret，例如使用环境变量或密钥管理工具。

示例用法

api_secret = "YOUR_API_SECRET" # 务必将此字符串替换为你实际的 Gemini API Secret，API Secret是进行签名认证的关键凭据。

构建包含订单信息的JSON Payload。payload是发送到Gemini交易所的关键数据载体，务必保证其准确性和完整性。

payload = .dumps({
    "request": "/v1/order/new",  # 指定API endpoint为新建订单
    "nonce": int(time.time() * 1000), # 生成一个毫秒级别的时间戳作为nonce，防止重放攻击。Nonce必须是单调递增的。
    "client_order_id": "your-client-order-id", # 可选参数，由客户端生成的唯一订单ID，方便跟踪和管理。强烈建议设置此参数。
    "symbol": "btcusd", # 交易对，例如：btcusd (Bitcoin / 美元)。注意大小写敏感。
    "amount": "0.01", # 订单数量。对于BTCUSD，单位为BTC。
    "price": "30000", # 订单价格。对于BTCUSD，单位为美元。
    "side": "buy", # 订单方向：buy（买入）或 sell（卖出）。
    "type": "exchange limit" # 订单类型：exchange limit (限价单)。 Gemini还支持其他订单类型，如：market (市价单)。
})

使用你的 API Secret 对 Payload 进行签名。签名过程是使用HMAC-SHA384算法，并对Base64编码的Payload进行加密，以确保数据的完整性和身份验证。

signature = generate_signature(api_secret, payload)
print(f"X-GEMINI-SIGNATURE: {signature}") # 打印生成的签名，该签名将作为HTTP Header的一部分发送。
print(f"X-GEMINI-PAYLOAD: {base64.b64encode(payload.encode()).decode()}") # 打印 Base64 编码后的 Payload，也作为HTTP Header的一部分发送。

重要提示： 在实际应用中，请使用安全的密钥管理方法来存储你的 API Secret，避免泄露。同时，请仔细阅读 Gemini API 文档，了解所有参数的含义和要求，并根据你的需求进行调整。

常用 Gemini API 接口

以下介绍几个常用的 Gemini API 接口及其使用方法，帮助开发者更高效地集成 Gemini 模型到各种应用中：

1. 生成内容 (Generate Content)

generateContent 接口是 Gemini 模型的核心功能，用于根据给定的提示词生成文本、图像、音频或视频等内容。该接口支持多种参数，用于控制生成内容的风格、长度、创造性以及安全性等。开发者可以通过调整这些参数，来定制生成的内容以满足特定需求。

使用场景：

文本生成： 撰写文章、创作故事、编写代码、翻译文本等。
图像生成： 创建图像、修改图像、生成图像描述等。
代码生成： 根据自然语言描述生成代码。

主要参数：

prompt : 提供给模型的提示词，用于指导内容生成。
model : 指定使用的 Gemini 模型版本。
temperature : 控制生成内容的随机性，数值越高，内容越随机。
top_p : 控制生成内容的概率分布，数值越高，内容越多样。
maxOutputTokens : 限制生成内容的最大长度。
safetySettings : 设置内容的安全过滤级别，防止生成有害或不当内容。

2. 嵌入 (Embeddings)

embedContent 接口用于将文本、图像等数据转换为向量形式的嵌入 (embeddings)。嵌入是一种将数据表示为高维向量的技术，它可以捕捉数据的语义信息和特征。通过比较不同数据的嵌入向量，可以计算它们之间的相似度。

使用场景：

语义搜索： 根据用户的查询词，搜索与查询词语义相关的文档或内容。
推荐系统： 根据用户的历史行为和偏好，推荐用户可能感兴趣的商品或内容。
文本分类： 将文本数据分类到不同的类别。
知识图谱构建： 构建知识图谱，将实体和关系表示为向量。

主要参数：

content : 要生成嵌入的内容。
model : 指定使用的 Gemini 模型版本。

3. 聊天 (Chat)

startChat 接口用于创建与 Gemini 模型的对话会话，允许用户进行多轮对话。该接口会维护对话历史，从而使模型能够理解上下文并生成更连贯的回复。开发者可以利用此接口构建智能聊天机器人、虚拟助手等应用。

使用场景：

智能客服： 为用户提供自动化的客户服务。
虚拟助手： 帮助用户完成各种任务，例如设置提醒、查询信息、预订机票等。
语言学习： 提供语言学习的互动式练习和反馈。

主要参数：

history : 存储对话历史记录。
prompt : 用户发送给模型的提示词。
model : 指定使用的 Gemini 模型版本。
temperature : 控制回复的随机性。
top_p : 控制回复的多样性。
maxOutputTokens : 限制回复的最大长度。
safetySettings : 设置安全过滤级别。

4. 流式生成内容 (Stream Generate Content)

streamGenerateContent 接口与 generateContent 接口类似，但它以流式方式返回生成的内容。这意味着模型会逐步生成内容，并将其分批发送给客户端，而不是一次性返回全部内容。这对于需要实时显示生成内容的应用程序非常有用，例如实时翻译、实时字幕生成等。

使用场景：

实时翻译： 实时将一种语言翻译成另一种语言。
实时字幕生成： 为视频或音频生成实时字幕。
代码实时生成： 逐步生成代码并实时显示。

主要参数：

prompt : 提供给模型的提示词。
model : 指定使用的 Gemini 模型版本。
temperature : 控制随机性。
top_p : 控制多样性。
maxOutputTokens : 限制最大长度。
safetySettings : 设置安全过滤级别。

1. 获取市场行情 (Ticker)

接口地址: /v1/ticker/:symbol
方法: GET
描述: 获取指定交易对的实时行情数据。此接口提供最新的成交价格、最高价、最低价、成交量等关键信息，是了解市场动态的重要入口。
参数:
- symbol : 交易对，表示要查询的币种组合，例如 btcusd (比特币/美元), ethbtc (以太坊/比特币) 等。请务必使用小写字母。
示例 (Python):

示例代码展示如何使用 Python 的 requests 库调用 Gemini API 获取指定交易对的 Ticker 数据。

import requests
import 

def get_ticker(symbol):
    """
    获取 Gemini 市场行情.

    Args:
        symbol (str): 交易对，例如 'btcusd'.

    Returns:
        dict: 市场行情数据，包含交易对的最新成交价、最高价、最低价等信息.
        如果请求失败，则返回 None.
    """
    url = f"https://api.gemini.com/v1/ticker/{symbol}"
    try:
        response = requests.get(url)
        response.raise_for_status()  # 检查请求是否成功
        return .loads(response.text)
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

# 示例用法
if __name__ == '__main__':
    symbol = 'btcusd'
    ticker_data = get_ticker(symbol)
    if ticker_data:
        print(f"行情数据 for {symbol}:")
        print(.dumps(ticker_data, indent=4))
    else:
        print(f"Failed to retrieve ticker data for {symbol}")

示例用法

这段代码展示了如何使用 get_ticker 函数来获取比特币（BTC）与美元（USD）交易对的实时行情数据。具体来说， ticker_data = get_ticker("btcusd") 这行代码调用了名为 get_ticker 的函数，并将 "btcusd" 作为参数传递给它。 "btcusd" 字符串代表了交易所中比特币兑美元的交易对标识符。这个函数应该会返回一个包含当前行情信息的字典或类似的数据结构。

接下来，代码通过 if ticker_data: 检查 get_ticker 函数是否成功返回了数据。如果 ticker_data 变量不为空（例如，不是 None 或空字典），则条件成立，执行 if 语句块中的代码。这一步非常重要，因为它可以防止在没有有效行情数据的情况下尝试访问或处理数据，从而避免程序出错。

print(.dumps(ticker_data, indent=4)) 这行代码用于将获取到的行情数据以美观的格式打印到控制台。 .dumps() 函数是 Python 标准库模块中的一个函数，它将 Python 对象（在这里是 ticker_data 字典）转换为 JSON 格式的字符串。 indent=4 参数告诉 .dumps() 函数使用 4 个空格进行缩进，使得输出的 JSON 字符串更易于阅读。如果 ticker_data 包含了诸如最新成交价、最高价、最低价、交易量等信息，那么这些信息将会以JSON格式清晰地显示出来。

2. 获取交易历史 (Trades)

接口地址: /v1/trades/:symbol
方法: GET
描述: 获取指定交易对的交易历史记录，该接口允许查询特定交易对发生的实际交易数据，包括成交价格、成交数量和时间戳等关键信息。
参数:
- symbol : 交易对，例如 btcusd (比特币/美元)。必须提供此参数以指定要查询的交易对。Gemini交易所支持多种交易对，例如ethusd, btcgbp等。
- limit_trades : (可选) 返回交易数量的上限。默认为API提供方设定的某个值（通常为50或100），可以通过此参数调整每次请求返回的交易记录数量，便于分页显示或限制数据量。请注意，服务器可能存在对该参数的最大值限制。
- since : (可选) 只返回指定时间戳之后的交易 (Unix 时间戳)。使用Unix时间戳（自1970年1月1日00:00:00 UTC起的秒数）来筛选特定时间点之后的交易记录。若不提供此参数，将返回所有可用的交易历史或API提供方默认返回的一段时间范围内的交易历史。
示例 (Python):

以下示例展示如何使用 Python 的 requests 库调用 Gemini API 获取交易历史数据。

import requests import

def get_trades(symbol, limit_trades=100, since=None): """ 获取 Gemini 交易历史。

    Args:
        symbol (str): 交易对，例如 'btcusd'.
        limit_trades (int, optional): 返回交易数量的上限. Defaults to 100. 调整返回交易记录的数量，默认值为100。
        since (int, optional): 只返回指定时间戳之后的交易 (Unix 时间戳). Defaults to None. 使用Unix时间戳过滤交易记录，只返回指定时间戳之后的交易。

    Returns:
        list: 交易历史数据列表，列表中的每个元素都是一个包含交易信息的字典。如果请求失败，则返回 None.
    """
    url = f"https://api.gemini.com/v1/trades/{symbol}"
    params = {}
    if limit_trades:
        params['limit_trades'] = limit_trades
    if since:
        params['since'] = since
    response = requests.get(url, params=params)
    if response.status_code == 200:
        return .loads(response.text)
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None

注意事项：

速率限制： Gemini API 具有速率限制。请务必查阅 Gemini API 的官方文档，了解具体的速率限制策略，并合理控制请求频率，避免被限制访问。
错误处理： 代码示例中包含了简单的错误处理，当 API 返回非 200 状态码时，会打印错误信息。在实际应用中，建议进行更完善的错误处理，例如重试机制、异常捕获等。
数据格式： API 返回的交易历史数据为 JSON 格式，包含了成交价格、成交数量、时间戳等字段。开发者需要根据具体的业务需求，解析 JSON 数据并进行相应的处理。
时间戳精度： 确保传入的 since 参数是有效的 Unix 时间戳，并且精度符合 API 的要求（通常为秒级或毫秒级）。

示例用法：获取BTC/USD交易数据

以下代码展示了如何使用 get_trades 函数获取最近50笔BTC/USD交易数据，并将结果以JSON格式打印出来。该函数允许用户指定交易对（例如 "btcusd"）以及限制返回的交易数量（使用 limit_trades 参数）。

trades_data = get_trades("btcusd", limit_trades=50)

这段代码调用了名为 get_trades 的函数，传递了两个参数：

"btcusd" ：指定要获取交易数据的交易对，这里是比特币（BTC）与美元（USD）的交易对。
limit_trades=50 ：设置返回的最大交易记录数量为50。这是一个可选参数，如果不设置，函数可能会返回默认数量的交易记录，具体的数量取决于函数自身的实现。

接下来，代码检查是否成功获取了交易数据：

if trades_data:

这行代码判断 trades_data 变量是否包含有效的数据。如果 get_trades 函数成功获取了交易数据， trades_data 将会包含一个包含交易信息的列表或字典。如果获取失败（例如，网络错误、API调用失败等）， trades_data 可能为 None 、 False 或者一个空列表。

如果成功获取数据，则以格式化的JSON格式打印出来：

print(.dumps(trades_data, indent=4))

这里使用了Python的 .dumps() 函数将 trades_data 转换为JSON格式的字符串，并使用 indent=4 参数指定缩进为4个空格，使得输出的JSON数据更易于阅读和理解。这有助于开发者检查返回的数据结构和内容，方便调试和分析交易数据。

3. 下单 (New Order)

接口地址: /v1/order/new
方法: POST
描述: 创建一个新的订单。此接口需要进行 API 身份验证，确保请求的安全性。通过提交必要的参数，您可以执行买入或卖出操作。
参数:
- request : /v1/order/new - 标识 API 请求的路径。
- nonce : 一个递增的整数，用于防止重放攻击。强烈建议使用当前时间戳乘以 1000，确保每次请求的唯一性。例如，可以使用 int(time.time() * 1000) 生成。
- client_order_id : 客户端自定义订单 ID，方便您在本地系统追踪和管理订单。该 ID 必须是唯一的，并且易于识别。
- symbol : 交易对，例如 btcusd (比特币/美元)。指定您想要交易的资产对。支持多种交易对，请参考交易所的 API 文档获取完整列表。
- amount : 订单数量。指定您想要买入或卖出的资产数量。数量应该是一个字符串，并且需要符合交易所规定的最小交易单位。
- price : 订单价格。对于限价单，这是您愿意买入或卖出的价格。对于市价单，则忽略此参数。价格应该是一个字符串。
- side : 交易方向， buy (买入) 或 sell (卖出)。明确指定您是想买入还是卖出指定的交易对。
- type : 订单类型，例如 exchange limit (限价单)。其他常见的订单类型可能包括市价单 exchange market ，以及各种止损单。
示例 (Python):

以下代码演示了如何使用 Python 创建 Gemini 交易所的新订单。它包括生成 API 签名所需的函数，以及构建和发送 HTTP 请求的函数。请确保已安装 requests 库。

import requests
import
import time
import hashlib
import hmac
import base64

def generate_signature(api_secret, payload):
"""生成 Gemini API 请求签名."""
encoded_payload = base64.b64encode(payload.encode())
hmac_digest = hmac.new(api_secret.encode(), encoded_payload, hashlib.sha384).hexdigest()
return hmac_digest

def new_order(api_key, api_secret, symbol, amount, price, side, order_type="exchange limit", client_order_id="your-client-order-id"):
"""
创建 Gemini 新订单.

    Args:
        api_key (str): 你的 Gemini API Key.
        api_secret (str): 你的 Gemini API Secret.
        symbol (str): 交易对，例如 'btcusd'.
        amount (str): 订单数量.
        price (str): 订单价格.
        side (str): 交易方向, 'buy' 或 'sell'.
        order_type (str, optional): 订单类型. Defaults to "exchange limit".
        client_order_id (str, optional): 客户端自定义订单 ID. Defaults to "your-client-order-id".

    Returns:
        dict: API 响应数据.
    """
    url = "https://api.gemini.com/v1/order/new"
    nonce = int(time.time() * 1000)
    payload_dict = {
        "request": "/v1/order/new",
        "nonce": nonce,
        "client_order_id": client_order_id,
        "symbol": symbol,
        "amount": str(amount),
        "price": str(price),
        "side": side,
        "type": order_type
    }
    payload = .dumps(payload_dict)
    signature = generate_signature(api_secret, payload)
    encoded_payload = base64.b64encode(payload.encode())
    headers = {
        "Content-Type": "application/",
        "X-GEMINI-APIKEY": api_key,
        "X-GEMINI-PAYLOAD": encoded_payload.decode(),
        "X-GEMINI-SIGNATURE": signature
    }

    response = requests.post(url, headers=headers, data=payload)
    if response.status_code == 200:
        return .loads(response.text)
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None

示例用法 (需要替换为你的 API 密钥)

api_key = "YOUR_API_KEY" # 替换为你的 API Key。这是访问交易平台API的凭证，确保安全保管。建议使用环境变量或密钥管理服务存储，避免硬编码在代码中。

api_secret = "YOUR_API_SECRET" # 替换为你的 API Secret。这是与API Key配对的密钥，用于签名请求。切勿泄露此密钥，否则可能导致资金损失。强烈建议启用双因素认证(2FA)以增强账户安全。

order_result = new_order(api_key, api_secret, "btcusd", "0.001", "30000", "buy")

上述代码示例调用 new_order 函数，使用提供的API Key和Secret进行身份验证，并创建一个新的交易订单。 "btcusd" 指定了交易对，表示比特币兑美元。 "0.001" 是交易数量，单位是比特币。 "30000" 是价格，单位是美元。 "buy" 指定了交易方向，表示买入。

在实际应用中，这些参数应根据用户的交易策略和市场情况动态调整。例如，可以根据技术指标或市场情绪调整交易价格和数量。

if order_result:

print(.dumps(order_result, indent=4))

这段代码检查 order_result 是否成功返回订单信息。如果订单创建成功，则使用 .dumps 函数将订单信息格式化为JSON字符串，并使用 indent=4 参数进行缩进，以便于阅读。

order_result 对象可能包含诸如订单ID、交易状态、成交价格等信息。这些信息可用于跟踪订单执行情况和分析交易结果。

务必妥善处理API Key和Secret，定期更换密钥，并限制API访问权限，防止未经授权的访问和潜在的安全风险。建议阅读交易所的API文档，了解更多关于安全措施和最佳实践的信息。

4. 取消订单 (Cancel Order)

本章节详细介绍了如何通过 Gemini API 取消现有订单。取消订单操作需要有效的 API 密钥和签名，以确保请求的安全性。请务必妥善保管您的 API 密钥。

接口地址: /v1/order/cancel
方法: POST
描述: 取消指定的订单。此操作需要 API 身份验证，并确保提供的订单 ID 存在且属于该 API 密钥对应的账户。如果订单已经成交或正在撮合中，取消请求可能会失败。
参数:
- request : /v1/order/cancel - API 请求路径，固定值为 /v1/order/cancel 。
- nonce : 一个递增的整数，用于防止重放攻击。建议使用 Unix 时间戳乘以 1000 获取毫秒级时间戳，确保每次请求的 nonce 值不同。
- order_id : 要取消的订单 ID。这是一个字符串类型的唯一标识符，用于指定要取消的订单。需要从创建订单的响应中获取。
请求头 (Headers):

Content-Type : application/ - 指定请求体的格式为 JSON。
X-GEMINI-APIKEY : 您的 Gemini API 密钥。
X-GEMINI-PAYLOAD : 经过 Base64 编码的请求体 (payload)。
X-GEMINI-SIGNATURE : 使用您的 API Secret 生成的请求签名。

示例 (Python):

以下 Python 示例演示了如何生成签名并取消 Gemini 订单。该示例使用了 requests 库发送 HTTP 请求，并使用 hmac 和 hashlib 库生成签名。为了清晰起见，示例代码未包含错误处理，请在实际应用中添加必要的错误处理机制。

import requests import import time import hashlib import hmac import base64

def generate_signature(api_secret, payload): """生成 Gemini API 请求签名.""" encoded_payload = base64.b64encode(payload.encode('utf-8')) # 确保 payload 以 UTF-8 编码 hmac_digest = hmac.new(api_secret.encode('utf-8'), encoded_payload, hashlib.sha384).hexdigest() # 确保 api_secret 以 UTF-8 编码 return hmac_digest

def cancel_order(api_key, api_secret, order_id): """取消 Gemini 订单.

Args:
    api_key (str): 你的 Gemini API Key.
    api_secret (str): 你的 Gemini API Secret.
    order_id (str): 要取消的订单 ID.

Returns:
    dict: API 响应数据.
"""
    url = "https://api.gemini.com/v1/order/cancel"
    nonce = int(time.time() * 1000)
    payload_dict = {
        "request": "/v1/order/cancel",
        "nonce": nonce,
        "order_id": order_id
    }
    payload = .dumps(payload_dict)
    signature = generate_signature(api_secret, payload)
    encoded_payload = base64.b64encode(payload.encode('utf-8')).decode('utf-8') # 确保 payload 以 UTF-8 编码并进行解码，使其成为字符串

    headers = {
        "Content-Type": "application/",
        "X-GEMINI-APIKEY": api_key,
        "X-GEMINI-PAYLOAD": encoded_payload,
        "X-GEMINI-SIGNATURE": signature
    }

    response = requests.post(url, headers=headers, data=payload)
    if response.status_code == 200:
        return .loads(response.text)
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None

注意:

请务必替换示例代码中的 api_key , api_secret 和 order_id 为您自己的有效凭证和订单 ID。
示例代码中使用了 .dumps 方法将 Python 字典转换为 JSON 字符串。请确保正确安装了库。
在生产环境中，请务必添加适当的错误处理机制，例如捕获网络异常和 API 错误。
确保你的 API 密钥具有取消订单的权限。
仔细检查您要取消的订单 ID，确保正确无误。

示例用法 (需要替换为你的 API 密钥和订单 ID)

api_key = "YOUR_API_KEY" # 替换为你的 API Key，用于身份验证和授权。确保妥善保管你的 API Key，避免泄露。 API Key 通常是平台分配给你的唯一标识符，用于追踪你的 API 使用情况并防止滥用。

api_secret = "YOUR_API_SECRET" # 替换为你的 API Secret。API Secret 必须与 API Key 配对使用，提供更高级别的安全保障。 API Secret 应该像密码一样保密，切勿在客户端代码或公共存储库中暴露。

order_id_to_cancel = "YOUR_ORDER_ID" # 替换为要取消的订单 ID。Order ID 是交易所分配给每个订单的唯一标识符。通过 Order ID 可以精确定位需要取消的订单。请确保 Order ID 的准确性，避免错误取消其他订单。

cancel_result = cancel_order(api_key, api_secret, order_id_to_cancel)

if cancel_result:
print(.dumps(cancel_result, indent=4))
如果 cancel_order 函数成功取消订单，则 cancel_result 将包含取消订单的详细信息，例如订单状态、取消时间等。使用 .dumps 函数可以格式化输出结果，使其更易于阅读。 indent=4 参数表示使用 4 个空格进行缩进。

5. 获取活跃订单 (Get Active Orders)

接口地址: /v1/orders
方法: POST
描述: 获取当前账户的活跃订单列表。该接口用于检索所有尚未完全成交或取消的订单。使用此端点需要进行 API 身份验证，以确保只有授权用户才能访问其订单信息。
安全说明： 由于涉及账户敏感数据，务必保证API Key和Secret的安全存储，避免泄露。
请求频率限制： 需要注意 Gemini API 的请求频率限制，避免因频繁请求而被限制访问。合理规划请求频率，并实施重试机制以应对可能的错误。
参数:

request : /v1/orders - 这是 API 请求的路径，必须准确填写。
nonce : 一个递增的整数，用于防止重放攻击。Nonce 应该是一个单调递增的数字，每次请求都比上次请求的 nonce 大。推荐使用时间戳（毫秒级）作为 Nonce 的生成基础。

示例 (Python):

以下 Python 代码演示了如何使用 Gemini API 获取活跃订单。请确保安装了 requests 库。

import requests
import 
import time
import hashlib
import hmac
import base64

def generate_signature(api_secret, payload):
    """生成 Gemini API 请求签名。

    签名过程如下：
    1. 将 payload (包含请求参数的 JSON 字符串) 进行 Base64 编码。
    2. 使用 API Secret 作为密钥，使用 HMAC-SHA384 算法对编码后的 payload 进行哈希。
    3. 将哈希结果转换为十六进制字符串，即为签名。
    """
    encoded_payload = base64.b64encode(payload.encode('utf-8'))
    hmac_digest = hmac.new(api_secret.encode('utf-8'), encoded_payload, hashlib.sha384).hexdigest()
    return hmac_digest

def get_active_orders(api_key, api_secret):
    """
    获取 Gemini 活跃订单。

    Args:
        api_key (str): 你的 Gemini API Key.
        api_secret (str): 你的 Gemini API Secret.

    Returns:
        list: 活跃订单列表。如果请求失败，则返回 None。
    """
    url = "https://api.gemini.com/v1/orders"
    nonce = int(time.time() * 1000) # 使用毫秒级时间戳作为 Nonce
    payload_dict = {
        "request": "/v1/orders",
        "nonce": nonce
    }
    payload = .dumps(payload_dict) # 将字典转换为 JSON 字符串
    signature = generate_signature(api_secret, payload)
    encoded_payload = base64.b64encode(payload.encode('utf-8')).decode('utf-8') # Base64 编码 payload

    headers = {
        "Content-Type": "application/", # 明确指定 Content-Type 为 JSON
        "X-GEMINI-APIKEY": api_key,
        "X-GEMINI-PAYLOAD": encoded_payload, # 传递 Base64 编码后的 payload
        "X-GEMINI-SIGNATURE": signature
    }

    response = requests.post(url, headers=headers, data=payload)
    if response.status_code == 200:
        return .loads(response.text) # 将 JSON 响应转换为 Python 列表
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None

代码说明:

generate_signature 函数：生成 API 请求签名。
get_active_orders 函数：
- 设置 API URL。
- 生成唯一的 nonce 值。
- 构建包含请求路径和 nonce 的 payload 字典。
- 将 payload 字典转换为 JSON 字符串。
- 使用 generate_signature 函数生成签名。
- 创建包含 API 密钥、payload 和签名的 HTTP 头部。
- 使用 requests.post 发送 POST 请求到 API 端点。
- 处理响应：如果状态码为 200，则将 JSON 响应解析为 Python 列表并返回；否则，打印错误信息并返回 None。
错误处理： 代码中包含了基本的错误处理，当API请求失败时，会打印错误状态码和响应内容。在实际应用中，建议加入更完善的错误处理机制，例如重试、日志记录等。
JSON 序列化： 使用 .dumps() 将 Python 字典转换为 JSON 字符串。确保 payload 的格式正确。

示例用法 (需要替换为你的 API 密钥)

api_key = "YOUR_API_KEY" # 替换为你的 API Key

api_secret = "YOUR_API_SECRET" # 替换为你的 API Secret

active_orders = get_active_orders(api_key, api_secret)

if active_orders:
print(.dumps(active_orders, indent=4))

代码解释：

api_key = "YOUR_API_KEY" 和 api_secret = "YOUR_API_SECRET" 行是关键。你必须将 "YOUR_API_KEY" 和 "YOUR_API_SECRET" 替换为你从交易所或服务提供商处获得的真实 API 密钥和密钥对。 API 密钥用于验证你的身份并授权你访问受保护的资源，务必妥善保管你的密钥，避免泄露。

active_orders = get_active_orders(api_key, api_secret) 这行代码调用了一个名为 get_active_orders 的函数，该函数使用你的 API 密钥和密钥来获取当前活跃的订单信息。这个函数的具体实现会根据你使用的 API 库而有所不同，但通常它会向交易所的 API 发送一个请求，然后解析返回的 JSON 数据。

if active_orders: 语句检查 get_active_orders 函数是否成功返回了活跃订单信息。如果 active_orders 不为空，则表示存在活跃订单。

print(.dumps(active_orders, indent=4)) 这行代码使用 .dumps 函数将 active_orders 变量中的数据格式化为 JSON 字符串，并使用 indent=4 参数进行美化，使其更易于阅读。 print 函数将格式化后的 JSON 字符串输出到控制台。如果 active_orders 是一个复杂的嵌套结构，使用 .dumps 可以更清晰地查看数据内容。

错误处理

Gemini API 的设计允许开发者通过其返回的 JSON 格式响应来诊断和处理错误。这些响应的核心组成部分是 result 字段（指示错误的具体类型）和 message 字段（提供关于错误的详细描述）。开发者应充分利用这些信息，构建健壮的错误处理机制，从而提升应用程序的稳定性和用户体验。

更具体地说，在处理 API 响应时，应该针对不同的 result 类型采取相应的措施。例如，如果 result 显示 InvalidNonce ，则应用程序需要重新生成一个有效的 nonce 值，并确保其大于先前使用的值。如果 result 表明 InvalidSignature ，则需要仔细检查 API 密钥的有效性以及签名算法的实现，以确保签名过程的正确性。

InvalidNonce : 该错误表明提供的 nonce 值无效。这通常发生在 nonce 值过小（小于服务器期望的最小值）或者在短时间内重复使用相同 nonce 的情况下。Nonce 的设计目的是防止重放攻击，因此确保其唯一性和递增性至关重要。开发者应采取措施生成唯一的、随时间递增的 nonce 值，并将其存储在客户端，以便在后续请求中使用。
InvalidSignature : 此错误表示 API 请求的签名与服务器端计算出的签名不匹配。这通常是由于 API 密钥不正确、签名算法实现错误或在签名过程中使用了错误的参数导致的。开发者需要仔细检查 API 密钥是否正确配置，并验证签名算法的实现是否符合 Gemini API 的规范。同时，确保参与签名的所有参数（包括请求体、时间戳、nonce 等）都正确无误。
InsufficientFunds : 该错误指示账户余额不足以完成请求的操作，例如下单或提现。开发者应在执行任何交易操作之前，先检查账户余额是否足够。如果余额不足，可以向用户发出提示，或者取消操作。还应考虑交易手续费对可用余额的影响。
OrderNotFound : 当尝试查询、取消或修改一个不存在的订单时，会返回此错误。这可能是由于订单已经被取消或完成，或者订单 ID 错误。开发者应确保使用的订单 ID 正确，并且订单仍然处于活动状态。在尝试修改或取消订单之前，应先验证订单是否存在。

其他注意事项

API 速率限制: Gemini API 实行速率限制，旨在保护系统稳定性并防止滥用。开发者务必仔细阅读官方文档中关于速率限制的具体规定，例如每分钟、每秒或每日允许的请求次数上限。速率限制的实施方式可能根据不同的 API 端点而有所不同。超出限制会导致 API 请求被拒绝，通常会返回HTTP 429 Too Many Requests错误。为了避免触发速率限制，建议开发者采取以下策略：
- 批量处理: 尽可能将多个请求合并为一个请求，以减少总请求次数。
- 使用缓存: 对于不经常变化的数据，使用本地缓存或分布式缓存来减少对 API 的重复请求。
- 指数退避重试: 当收到速率限制错误时，不要立即重试请求，而是采用指数退避算法，逐步增加重试间隔时间，例如1秒、2秒、4秒等。
- 监控 API 使用情况: 密切监控 API 的使用情况，以便及时发现并解决速率限制问题。
API 版本更新: Gemini API 可能会进行版本更新，以改进功能、修复漏洞或引入新的特性。版本更新可能会影响现有代码的兼容性。开发者应定期关注 Gemini 官方文档、博客或社区论坛，及时了解 API 版本更新的信息。当有新的版本发布时，建议尽早评估其影响，并根据需要调整代码，以确保应用程序能够正常运行。通常，Gemini 会提供一段时间的过渡期，允许开发者逐步迁移到新的 API 版本。
安全性: API 密钥是访问 Gemini API 的凭证，务必妥善保管，防止泄露。密钥泄露会导致未授权的访问和潜在的安全风险。开发者应采取以下安全措施：
- 不要将 API 密钥硬编码到代码中: 将 API 密钥存储在环境变量、配置文件或安全的密钥管理系统中。
- 限制 API 密钥的权限: 根据应用程序的需求，限制 API 密钥的权限，例如只允许访问特定的 API 端点或执行特定的操作。
- 定期轮换 API 密钥: 定期更换 API 密钥，以降低密钥泄露的风险。
- 使用 HTTPS 协议: 所有 API 请求都应通过 HTTPS 协议发送，以确保数据传输的安全性。
- 监控 API 密钥的使用情况: 监控 API 密钥的使用情况，以便及时发现并处理异常活动。如果发现密钥泄露，应立即撤销该密钥并生成新的密钥。