开发者快速开始

本指南介绍如何在 Gonka 中创建开发者账户并使用 Gonka API 提交推理请求。

重要提示：针对现有 Leap Wallet 用户

如果你此前通过 Leap Wallet 创建了 Gonka 账户，请注意，Leap 将于 2026 年 5 月 28 日关闭其所有产品，包括浏览器扩展、移动应用以及 Dashboard。

由于 Leap 是非托管钱包（non-custodial wallet），你的资产和账户仍然保存在链上。但为了继续访问你的钱包，建议你在 Leap 服务下线前，将现有助记词导入到其他受支持的钱包（如 Keplr）中。

Gonka 与传统 AI API 的区别

Gonka 不仅仅是另一个 AI API — 它是一个用于可证明推理的加密协议。通过消除中心化身份，Gonka 移除了困扰基于 SaaS 的 AI 服务的传统单点故障。以下对比表帮助你理解传统 AI API 与 Gonka API 之间的差异。

方面	传统 AI API (OpenAI、Anthropic 等)	Gonka API
模型来源与可验证输出	模型由提供商托管和版本控制，但无法加密验证哪个模型实际产生了给定输出。无法证明模型未被切换、在后台微调或对你进行 A/B 测试。	每个推理请求和响应都可以加密链接到特定的模型哈希和执行环境。这实现了可验证的来源 — 任何人都可以证明特定模型版本生成了特定输出。
抗审查性	所有访问都集中控制 — 提供商可以随时限制或终止账户。这包括地理、政治或商业政策的执行。	推理请求通过去中心化网络签名和广播。只要你持有私钥并连接到节点，就可以运行推理。系统设计为不可审查，除非通过透明、协议级共识应用限制。
可审计性与透明度	日志记录、计费和使用跟踪完全由 API 提供商控制。用户无法独立验证自己的使用情况或检查定价、延迟或错误的处理方式。	每次交互都经过签名和时间戳，实现独立的审计跟踪。你可以证明推理何时以及如何发生、使用了哪个模型、结果是否被更改，并确保争议可以公开解决。
透明的代币经济学	计费费率对计算定价、模型成本或系统负载的洞察有限。	代币经济学在链上或协议定义，意味着定价机制透明且可检查。用户将 GNK 转换为 AI 代币，具有可预测、可追踪的交换逻辑，实现推理成本的清晰预测和供需驱动的经济学。

---

1. 定义变量

在创建账户之前，设置所需的环境变量：

export ACCOUNT_NAME=<your-desired-account-name>
export NODE_URL=<http://random-node-url>

• 将 <your-desired-account-name> 替换为你选择的账户名称。
  • 该名称不会记录在链上 —— 它仅存在于你的本地密钥存储中。
  • 唯一性仅在本地生效：如果创建两个相同名称的密钥，将会覆盖已有密钥（CLI 会给出警告）。如果你继续操作，原有密钥将被永久丢失。强烈建议在执行此操作前备份你的公钥和私钥。
• 将 <http://random-node-url> 替换为任意一个节点 URL。你可以随机选择任意节点 —— 无需考虑其运行的模型。在此阶段，该节点仅作为网关，用于获取网络状态并广播交易。所有节点都提供相同的公共 API。你可以选择：
  • 使用以下列表中的任意一个创世节点（genesis nodes）。
  • 获取当前活跃参与者列表并随机选择一个节点。为避免过度依赖创世节点并促进去中心化，Gonka 建议从当前 epoch 的活跃节点中随机选择一个节点。这有助于提升网络负载分布，并增强对节点故障的抗性。

创世节点当前活跃参与者列表

将 NODE_URL 设置为以下创世节点之一：

创世节点列表

http://36.189.234.237:17241
http://node1.gonka.ai:8000
http://node2.gonka.ai:8000
http://47.236.26.199:8000
http://47.236.19.22:18000
http://gonka.spv.re:8000

或者，你可以从当前 epoch 中选择随机活跃参与者。打开链接或运行以下命令获取活跃参与者列表以及用于验证的加密证明：

链接命令

http://node1.gonka.ai:8000/v1/epochs/current/participants

curl http://node1.gonka.ai:8000/v1/epochs/current/participants

请不要忘记将其记录下来，你将在下一步中需要使用。

2. 创建账户

选项 1：通过 inferenced CLI 工具选项 2：通过 Keplr（外部钱包）选项 3：通过 Cosmostation（外部钱包）

下载 inferenced CLI 工具（最新 inferenced 二进制文件在此）。

什么是 inferenced CLI 工具？

inferenced CLI 工具是用于与 Gonka 网络交互的命令行界面实用程序。它是一个独立的可执行二进制文件，允许用户创建和管理 Gonka 账户、执行推理任务、上传模型，并通过脚本命令自动化各种操作。

在 Mac OS 上启用执行

在 Mac OS 上，下载 inferenced 二进制文件后，你可能需要手动启用执行权限。请按照以下步骤操作：

1. 打开终端并导航到二进制文件所在的目录。

2. 运行以下命令授予执行权限：

   chmod +x inferenced
   

3. 尝试运行 ./inferenced --help 以确保它正常工作。

4. 如果在尝试运行 inferenced 时看到安全警告，请转到系统设置 → 隐私与安全。

5. 向下滚动到关于 inferenced 的警告并点击"仍要允许"。

你可以使用以下命令创建账户：

./inferenced create-client $ACCOUNT_NAME \
  --node-address $NODE_URL

确保安全保存你的密码短语 — 将来访问时需要。

此命令将：

• 生成密钥对
• 保存到 ~/.inference
• 返回你的账户地址、公钥和助记词（也请安全地以硬拷贝形式存储！）

- address: <your-account-address>
  name: ACCOUNT_NAME
  pubkey: @type:...
  type: local

账户存储你的余额，将其添加到环境变量 GONKA_ADDRESS 或 .env 文件中。

export GONKA_ADDRESS=<your-account-address>

你将使用此账户购买 Gonka（GNK）代币并支付推理请求。

将私钥添加到环境变量。

如果你想执行请求，请导出你的私钥。

./inferenced keys export $ACCOUNT_NAME --unarmored-hex --unsafe

此命令输出纯文本私钥。

访问Keplr 官方网站并点击"获取 Keplr 钱包"。

为你的浏览器选择扩展程序。

将选定的扩展程序添加到你的浏览器。

FirefoxGoogle Chrome

点击"创建新钱包"。

通过 Google 连接创建新恢复短语

点击"通过 Google 连接"。

设置你的钱包。

安全备份你的私钥。任何拥有你私钥的人都可以访问你的资产。如果你失去对 Gmail 账户的访问权限，恢复钱包的唯一方法是使用你的私钥。请将其保存在安全的地方。

重要通知：功能有限

此选项使用助记词创建账户，不支持通过桥进行交易。如果你想通过桥执行交易，请使用选项 1：通过 inferenced CLI 工具或选项 2：通过 Keplr（外部钱包，"通过 Google 连接"）。

点击"创建新恢复短语"

不要与任何人分享你的恢复短语。任何拥有你恢复短语的人都可以完全控制你的资产。请时刻警惕网络钓鱼攻击。安全备份短语。没有恢复短语，你将永远无法恢复账户。

验证你的恢复短语，创建钱包名称和密码。

在搜索栏中输入 “Gonka”，并选择 Gonka 链，将其添加到你的钱包中。

你的 Keplr 钱包已创建。

打开 Gonka 的去中心化仪表盘

从创世节点的 inference_url 列表中选择随机节点。

• http://185.216.21.98:8000
• http://69.19.136.233:8000
• http://36.189.234.197:18026
• http://36.189.234.237:17241
• http://node1.gonka.ai:8000
• http://node2.gonka.ai:8000
• http://node3.gonka.ai:8000
• http://47.236.26.199:8000
• http://47.236.19.22:18000
• http://gonka.spv.re:8000

选择随机节点的另一种完全去中心化方法

打开主机列表：http://node2.gonka.ai:8000/v1/epochs/current/participants

从列表中选择任何活跃主机。

复制他们的 inference_url 值。

将 inference_url 粘贴到浏览器中以加载仪表盘。

打开后，你将看到从主机节点直接流式传输的实时数据 — 包括网络统计、活跃工作负载和推理指标。

在右上角，点击"连接钱包"开始。

选择 Keplr 并点击连接。

批准与 Gonka 网络的连接请求。

完成！你的 Gonka 开发者账户已成功创建。

打开扩展程序并点击扩展程序窗口右上角的账户图标。

导航到三个点并点击"查看私钥"（如果你"通过 Google 连接"）或"查看恢复短语"（如果你使用"恢复短语"创建账户）。

通过 Google 连接创建新恢复短语

输入你的密码。

复制你的私钥或恢复短语并安全存储（建议硬拷贝）。

可选：如何在 Keplr 钱包中添加额外的 Gonka 账户 — 点击查看步骤

打开扩展程序并点击扩展程序窗口右上角的账户图标。

点击"添加钱包"按钮。

点击"导入现有钱包"。

点击"使用恢复短语或私钥"

粘贴你的私钥。你可以导入使用恢复（助记词/种子）短语创建的账户。但是，桥功能将受到限制，因为桥需要直接访问原始私钥来签名交易并确保与以太坊的完全互操作性。

为你的钱包起一个名称以便参考。

选择 Cosmos Hub 和 Ethereum。

完成 — 你的 Gonka 账户已成功导入 Keplr！

重要提示：功能受限

该方式通过助记词创建账户，不支持通过桥进行交易。如果你希望通过桥进行交易，请改用选项 1：通过 inferenced CLI 工具，或选项 2：通过 Keplr（外部钱包，“Connect with Google”）创建账户。

获取 Cosmostation 钱包浏览器扩展.

将扩展添加到你的浏览器。

选择 “Create new wallet”（创建新钱包）。

记录你的助记词。切勿与任何人分享助记词。任何获取你助记词的人都可以完全控制你的资产。请始终警惕钓鱼攻击，并妥善备份助记词。

按照顺序完成验证测试。检查备份的助记词，并按顺序选择正确的单词。

设置账户名称。你可以为账户命名，且可随时修改。

在右上角点击 “All Networks”（所有网络），选择 Gonka 链并将其添加到钱包中。

完成！你的 Gonka Developer 账户已成功创建。

点击顶部的钱包名称，在右上角点击 “Manage”（管理），然后再次点击钱包名称。

点击 “View private key”（查看私钥）。

验证你的密码。

从列表中选择 “Gonka”。

点击 “Gonka” 查看私钥。复制你的私钥或助记词，并妥善保存（建议保留纸质备份）。

将私钥添加到环境变量 GONKA_PRIVATE_KEY, 或 .env 文件中：

export GONKA_PRIVATE_KEY=<your-private-key>

如需查看本地存储的所有账户列表，请执行以下命令：

./inferenced keys list [--keyring-backend test]

3. 使用定制化的 OpenAI SDK 进行推理

受限的 Transfer Agent 节点

目前，可用于推理（inference）请求的节点列表是受限的。要查看完整的可用 Transfer Agent 列表，请使用以下命令:

curl "http://node2.gonka.ai:8000/chain-api/productscience/inference/inference/params" | jq '.params.transfer_agent_access_params.allowed_transfer_addresses'

当前可用的 Transfer Agent URL：

• http://node1.gonka.ai:8000
• http://node2.gonka.ai:8000
• https://node3.gonka.ai

PythonTypeScriptGo

要在 Python 中使用 Gonka API，你可以使用Gonka OpenAI SDK for Python。通过使用 pip 安装 SDK 开始：

pip install gonka-openai

如果遇到构建错误，你可能需要安装系统级库

brew install pkg-config secp256k1

安装 SDK 后，创建一个名为 example.py 的文件并将示例代码复制到其中：

import os
from gonka_openai import GonkaOpenAI

client = GonkaOpenAI(
    gonka_private_key=os.environ.get(GONKA_PRIVATE_KEY),
    source_url=os.environ.get('NODE_URL')
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    messages=[
        { "role": "user", "content": "写一个关于独角兽的一句话睡前故事" }
    ]
)

print(response.choices[0].message.content)

使用 python example.py 执行代码。片刻后，终端将显示 API 请求的响应结果。

要在 Node.js、Deno 或 Bun 等服务器端 JavaScript 环境中使用 Gonka API，你可以使用Gonka OpenAI SDK for TypeScript and JavaScript。通过使用 npm 或你首选的包管理器安装 SDK 开始：

npm install gonka-openai

安装 SDK 后，创建一个名为 example.mjs 的文件并将示例代码复制到其中：

import { GonkaOpenAI, resolveEndpoints } from 'gonka-openai';

const endpoints = await resolveEndpoints({ sourceUrl: process.env.NODE_URL });
const client = new GonkaOpenAI({
    gonkaPrivateKey: process.env.GONKA_PRIVATE_KEY,
    endpoints
});

const response = await client.chat.completions.create({
    model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    messages: [
        { role: "user", content: "你好！给我讲个短笑话。" }
    ]
});

console.log(response.choices[0].message.content);

使用 node example.mjs 执行代码。片刻后，你应该看到 API 请求的输出。

要在 Go 中使用 Gonka API，你可以使用Gonka OpenAI SDK for Go。通过使用 go get 安装 SDK 开始：

go get github.com/gonka-ai/gonka-openai/go

安装 SDK 后，创建一个名为 example.go 的文件并将示例代码复制到其中：

package main

import (
    "context"
    "log"
    "os"

    gonka "github.com/gonka-ai/gonka-openai/go"
)

func main() {
    client, err := gonka.NewGonkaOpenAI(gonka.Options{
        GonkaPrivateKey: os.Getenv("GONKA_PRIVATE_KEY"),
        SourceUrl:       os.Getenv("NODE_URL"),
    })
    if err != nil {
        log.Fatal(err)
    }

    resp, err := client.ChatCompletion(context.Background(),
        "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
        gonka.UserMessage("Write a haiku about programming"),
    )
    if err != nil {
        log.Fatal(err)
    }

    log.Println(resp.Choices[0].Message.Content)
}

使用 go run example.go 执行代码。片刻后，你应该看到 API 请求的输出。

要从另一种语言执行推理，请参阅Gonka OpenAI 客户端库仓库，并相应调整示例。

4. 工具调用

仅支持 type: "function" — vLLM 实现的是 OpenAI 聊天补全规范，而非 Assistants API（code_interpreter、file_search 不可用）。

定义函数后，当用户的请求匹配时，模型将返回结构化的调用参数 — 你来决定如何处理它们。

PythonTypeScriptGo

import os, json
from gonka_openai import GonkaOpenAI

client = GonkaOpenAI(
    gonka_private_key=os.environ.get('GONKA_PRIVATE_KEY'),
    source_url=os.environ.get('NODE_URL')
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
    tools=tools,
    tool_choice="auto",
)

message = response.choices[0].message
if message.tool_calls:
    call = message.tool_calls[0]
    args = json.loads(call.function.arguments)
    # model chose get_weather with {"city": "Paris"} — call your function now
    print(call.function.name, args)

import { GonkaOpenAI, resolveEndpoints } from 'gonka-openai';

const endpoints = await resolveEndpoints({ sourceUrl: process.env.NODE_URL });
const client = new GonkaOpenAI({
    gonkaPrivateKey: process.env.GONKA_PRIVATE_KEY,
    endpoints
});

const tools = [
    {
        type: 'function',
        function: {
            name: 'get_weather',
            description: 'Get the current weather for a city',
            parameters: {
                type: 'object',
                properties: { city: { type: 'string', description: 'City name' } },
                required: ['city'],
            },
        },
    },
];

const response = await client.chat.completions.create({
    model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    messages: [{ role: "user", content: "What's the weather in Paris?" }],
    tools,
    tool_choice: "auto",
});

const message = response.choices[0].message;
if (message.tool_calls) {
    const call = message.tool_calls[0];
    const args = JSON.parse(call.function.arguments);
    // model chose get_weather with { city: "Paris" } — call your function now
    console.log(call.function.name, args);
}

package main

import (
    "context"
    "encoding/json"
    "log"
    "os"

    gonka "github.com/gonka-ai/gonka-openai/go"
    "github.com/openai/openai-go"
)

func main() {
    client, err := gonka.NewGonkaOpenAI(gonka.Options{
        GonkaPrivateKey: os.Getenv("GONKA_PRIVATE_KEY"),
        SourceUrl:       os.Getenv("NODE_URL"),
    })
    if err != nil {
        log.Fatal(err)
    }

    resp, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
        Model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
        Messages: []openai.ChatCompletionMessageParamUnion{
            openai.UserMessage("What's the weather in Paris?"),
        },
        Tools: []openai.ChatCompletionToolParam{
            {
                Type: "function",
                Function: openai.FunctionDefinitionParam{
                    Name:        "get_weather",
                    Description: openai.String("Get the current weather for a city"),
                    Parameters: openai.FunctionParameters{
                        "type": "object",
                        "properties": map[string]any{
                            "city": map[string]string{"type": "string", "description": "City name"},
                        },
                        "required": []string{"city"},
                    },
                },
            },
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    if len(resp.Choices[0].Message.ToolCalls) > 0 {
        call := resp.Choices[0].Message.ToolCalls[0]
        var args struct{ City string }
        json.Unmarshal([]byte(call.Function.Arguments), &args)
        // model chose get_weather with {City: "Paris"} — call your function now
        log.Printf("Tool: %s, City: %s\n", call.Function.Name, args.City)
    }
}

---

需要帮助？ 请先查看我们的常见问题页面，加入我们的 Discord 服务器 服务器，以获取关于一般咨询、技术问题或安全相关事项的协助。