Resolving gate-cli (binary path)

Resolve gate-cli in order: (1) command -v gate-cli and gate-cli --version succeeds; (2) ${HOME}/.local/bin/gate-cli if executable; (3) ${HOME}/.openclaw/skills/bin/gate-cli if executable. Canonical rules: exchange-runtime-rules.md §4 (or gate-runtime-rules.md §4).

Gate Exchange Small Balance (Dust to GT)

General Rules

Read and follow the shared runtime rules before proceeding: → exchange-runtime-rules.md (in parent directory skills/)

Skill Dependencies

Authentication

• Interactive file setup: when GATE_API_KEY and GATE_API_SECRET are not both set on the host, run gate-cli config init to complete the wizard for API key, secret, profiles, and defaults (see gate-cli).
• Env / flags: gate-cli config init is not required when credentials are already supplied — e.g. both GATE_API_KEY and GATE_API_SECRET set on the host, or --api-key / --api-secret where supported — never ask the user to paste secrets into chat.
• Permissions: Wallet read and small-balance convert as required for dust-to-GT flows (least privilege).
• Portal: create or rotate keys outside the chat: https://www.gate.com/myaccount/profile/api-key/manage

Installation Check

• Required: gate-cli (install from gate-cli releases or via your environment’s Gate MCP / skills installer).
• Add the directory containing gate-cli to PATH when invoking by name.
• Credentials: When GATE_API_KEY and GATE_API_SECRET are both set (non-empty) for the host, do not require gate-cli config init. When both are unset or empty, remind the operator to run gate-cli config init or to configure GATE_API_KEY / GATE_API_SECRET in the matching skill from the skill library (never ask the user to paste secrets into chat).
• Sanity check: Before convert operations, confirm the CLI works (e.g. gate-cli cex wallet balance small or gate-cli --version).

---

This Skill covers small balance conversion: listing spot holdings that qualify under the platform dust threshold, executing conversion to GT, and querying conversion history. Under the hood this maps to wallet routes GET/POST /wallet/small_balance and GET /wallet/small_balance_history; agents should drive the flow via MCP tools cex_wallet_* below, not by hand-crafting HTTP.

Domain Knowledge

Small balance conversion batches spot (or unified account spot-side) holdings whose value is below the platform small-balance threshold (typically up to 100 USDT equivalent per policy; exact limits follow API responses).

Characteristics:

• Consolidates low-value assets into GT
• Suited for wallet cleanup; not a substitute for normal spot sells of large positions

Account scope: Primarily spot or unified account spot balances (per product scope).

Payload note: gate-cli cex wallet balance small and gate-cli cex wallet balance small-history responses may wrap rows in an outer array whose first element is the list of objects to render; if so, use that inner list. Typical row fields: list — currency, available_balance, estimated_as_btc, convertible_to_gt; history — id, create_time, currency, amount, gt_amount (create_time often Unix seconds).

MCP Tool Inventory:

Workflow

Step 1: Classify User Intent

Determine whether the user wants to list eligible assets, convert to GT, review history, or should be excluded from this Skill.

Intent routing:

Exclusion rules:

• User wants to sell high-value spot assets at a limit/market price → guide to spot trading, not this Skill
• User explicitly keeps certain coins → do not include those in currencies and do not set is_all: true without clear consent

Call no tool in this step.

Key data to extract:

• intent: list | convert_selected | convert_all | convert_unspecified | history | exclude
• currencies: optional list of symbols (e.g. FLOKI, MBLK) for selected convert
• is_all: boolean when user asks to convert everything eligible
• history_filters: optional currency, page, limit for history

Step 2: Query Eligible Small Balances

When to call: Always call this step when:

1. Intent is list
2. Intent is convert_selected, convert_all, or convert_unspecified (before any conversion)

Call gate-cli cex wallet balance small with:

• No required parameters (empty call is valid)

Key data to extract:

• Row list: if the tool returns a nested array, use the inner array of objects (Payload note above)
• Each item: currency, available_balance, estimated_as_btc, convertible_to_gt
• Whether the list is empty

Presentation:

• If non-empty: summarize count, show a table with currency, available_balance, convertible_to_gt
• If empty: inform the user there are no eligible small-balance assets at this time

For convert intents: Store the eligible list in context for use in Step 3 validation.

Step 3: Interactive Conversion Flow (if intent = convert_selected / convert_all / convert_unspecified)

This step enforces an interactive flow to ensure users make informed decisions.

3.1: Validate User-Specified Currencies (if user specified tickers)

If the user specified currencies (e.g., "Convert FLOKI and MBLK to GT"):

1. Check each currency against the eligible list from Step 2:

   • If a currency exists in the eligible list → mark as available
   • If a currency does NOT exist in the eligible list → mark as not_eligible

2. Inform the user of the validation result:

   • For available currencies: "✅ {CURRENCY} is eligible for conversion (available: {available_balance}, estimated GT: {convertible_to_gt})"
   • For non-eligible currencies: "❌ {CURRENCY} is not in the eligible small-balance list. It may be above the threshold or not supported."

3. If some currencies are not eligible, ask the user:

   • "The following currencies are not eligible: {list}. Would you like to proceed with converting only the eligible ones ({eligible_list}), or would you like to review the full eligible list first?"

3.2: Guide User Selection (if intent = convert_unspecified or user wants to review)

If the user has not specified which currencies to convert, or wants to review options:

1. Show the full eligible list with the following columns:

   • currency | available_balance | convertible_to_gt

2. Ask the user to choose:

   • "Which currencies would you like to convert? You can:"
   • "A) Select specific currencies from the list above"
   • "B) Convert all eligible currencies"
   • "Please tell me your choice (e.g., 'FLOKI and MBLK' or 'all')"

3. Wait for user response and extract:

   • If user specifies currencies → update currencies list, set is_all: false
   • If user says "all" → set is_all: true

3.3: Final Confirmation

Before calling the convert API:

1. Summarize what will be converted:

   • For selected currencies: "You are about to convert: {currencies}. Estimated total GT: {sum of convertible_to_gt}"
   • For all eligible: "You are about to convert all {n} eligible currencies. Estimated total GT: {sum}"

2. Warn about irreversibility:

   • "⚠️ This operation is irreversible. Once converted, these assets will become GT at the current exchange rate."

3. Ask for explicit confirmation:

   • "Do you want to proceed? Please confirm with 'yes' or 'confirm'."

4. Only proceed if the user explicitly confirms.

3.4: Execute Conversion

After user confirmation, call gate-cli cex wallet balance convert-small with:

• currencies (array of strings): e.g. ["FLOKI","MBLK"] when converting selected tickers — use with is_all: false
• is_all (boolean): true to convert all eligible small balances

Key data to extract:

• success, message, and any error_code / error fields from the response
• On failure: exact message (e.g. balance, rate limit)

After success: Confirm conversion outcome in plain language; do not fabricate amounts not returned by the API.

Step 4: Query Small Balance History (if intent = history)

Call gate-cli cex wallet balance small-history with:

• currency (optional, string): filter by converted currency
• page (optional, number): page index
• limit (optional, number): page size (default/max per API, often up to 100)

Key data to extract:

• Row list: same nested unwrap rule as list tool if applicable (Payload note)
• Each record: id, create_time, currency, amount, gt_amount — present create_time readably if it is Unix seconds

Presentation:

• Show a table with id, create_time (readable), currency, amount, gt_amount
• If empty, inform the user: "No conversion history found."

Step 5: Format and Present Results

Use the Report Template section. For any API error, report the real code/message — never invent success.

Error Handling

Safety Rules

• NEVER fabricate conversion results, GT amounts, or IDs — only report API truth
• ALWAYS confirm before gate-cli cex wallet balance convert-small: explicit currency list or confirmed convert all, plus irreversibility and rate disclaimer (final rate at execution time)
• Always query eligible list first when user wants to convert — never skip to convert without showing what's available
• Validate user-specified currencies against the eligible list and inform user of any discrepancies
• Do not convert coins the user asked to keep
• Do not expose API secrets or keys
• Display amounts as returned by the API without arbitrary rounding
• Risk note: Conversion is not reversible; GT value fluctuates with market conditions

Judgment Logic Summary

Report Template

Timestamp: ISO 8601 YYYY-MM-DD HH:mm:ss UTC where applicable.

Eligible Small Balances Report

## Small Balances Eligible for GT Conversion

**Query Time**: {timestamp}

| Currency | Available | Est. BTC value | Est. GT |
|----------|-----------|----------------|---------|
| {currency} | {available_balance} | {estimated_as_btc} | {convertible_to_gt} |

**Summary**: {n} currencies eligible. (If empty: no eligible small-balance assets.)

Conversion Result Report

## Small Balance Conversion

**Time**: {timestamp}
**Mode**: {Selected currencies: ... | All eligible}

**Result**: {success / failed}
**Message**: {message}

If failed: **Code**: {error_code_if_any}

History Report

## Small Balance Conversion History

**Query Time**: {timestamp}
**Filters**: currency={currency or Any}, page={page}, limit={limit}

| ID | Time (UTC) | Currency | Amount | GT Received |
|----|--------------|----------|--------|-------------|
| {id} | {create_time — convert Unix seconds to readable time} | {currency} | {amount} | {gt_amount} |

Currency Validation Report (for interactive flow)

## Currency Validation

| Currency | Status | Available | Est. GT |
|----------|--------|-----------|---------|
| {currency} | ✅ Eligible | {available_balance} | {convertible_to_gt} |
| {currency} | ❌ Not eligible | — | — |

**Summary**: {n} of {m} specified currencies are eligible for conversion.