Quantumexecute

QuantumExecute (QE) unified skill for AI-driven cryptocurrency algorithmic trading across Binance, OKX, LTP, Deribit, Hyperliquid, and other supported exchan...

Security Scan

The skill's code, required credentials, and runtime instructions are consistent with its stated purpose (algorithmic crypto execution); nothing in the bundle indicates hidden or unrelated behavior, but the QE API credentials are high‑privilege and should be used with strong operational controls.

Purpose & Capability

Name/description (multi-exchange trading, order lifecycle, TCA/export) matches the included scripts and references. Requested binaries (python3) and required env vars (QE_API_KEY, QE_API_SECRET) are expected for a Python-based trading client. The set of scripts map directly to claimed features (balances, orders, TCA, exports).

Instruction Scope

SKILL.md directs running the provided scripts and keeping secrets in env vars only; scripts source QE_API_KEY/SECRET via shared _client.get_client, and the skill's hard rules require explicit confirmation before write operations. Scripts write reports to ~/workspace by default and produce JSON outputs. Minor inconsistencies: SKILL.md mentions optional QE_WORKSPACE and QE_BASE_URL, but most scripts do not read QE_WORKSPACE (they default to Path.home()/"workspace"); QE_BASE_URL is read by _client if set. Overall instructions do not attempt to read unrelated system files or exfiltrate secrets.

Install Mechanism

No install spec provided (instruction-only install), but a requirements.txt is included listing 'qe-connector', 'requests', 'pandas', 'openpyxl'. Because there is no automatic install step, operator must install dependencies manually; this is lower risk than an arbitrary download, but operators should verify package sources (especially 'qe-connector') and pin versions before installing.

Credentials

Only QE_API_KEY and QE_API_SECRET are required (declared primaryEnv QE_API_KEY). Those are exactly the high‑privilege credentials needed for the described trading capabilities. SKILL.md also documents QE_BASE_URL and QE_WORKSPACE as optional; QE_BASE_URL is supported by code, QE_WORKSPACE is documented but not consistently used by scripts (they default to ~/workspace). No unrelated credentials or system config paths are requested.

Persistence & Privilege

always:false (no forced inclusion). The skill does not request system-wide changes, does not modify other skills, and does not require persistent elevated privileges. Autonomous invocation is allowed (platform default); the skill's hard rules require explicit confirmations for write operations which mitigates autonomous write risk if enforced by the agent.

Assessment

This skill appears coherent for its stated purpose, but it controls high‑privilege trading actions. Before installing or running it: 1) Treat QE_API_KEY/QE_API_SECRET as powerful credentials — create and use restricted keys (minimal permissions) and enable IP whitelisting and audit logs on the QuantumExecute platform. 2) Review and install dependencies in an isolated environment (virtualenv/container) and verify the 'qe-connector' package source & version before installing. 3) Confirm the agent enforces the skill's P0 hard rules (explicit confirmation required for create/update/cancel operations). 4) Test read-only scripts first (list_exchange_apis, get_market_data, balance/positions) using non-production accounts or read-only keys. 5) Note small inconsistencies: SKILL.md references QE_WORKSPACE (not read by scripts) and QE_BASE_URL (supported), and there is no automatic install step — ensure you know where reports will be written (default ~/workspace) and supply QE_BASE_URL only to trusted endpoints. If you need higher assurance, request the upstream package repository (qe-connector) and compare its API usage to the code here, or run the skill in an isolated sandbox before granting production credentials.

QuantumExecute (QE) Unified Skill

QuantumExecute is abbreviated as QE. This is a single install skill for QuantumExecute cryptocurrency execution workflows across Binance, OKX, LTP, Deribit, Hyperliquid, and other supported exchanges.

QuantumExecute provides AI-driven execution algorithms for quantitative institutions and large-order trading. It focuses on reducing execution cost through smart order splitting, plug-and-play exchange connectivity, customizable strategies, order lifecycle management, balance/position visibility, and TCA/reporting.

Use script outputs as the only source of truth.

Features

• Multi-exchange crypto execution workflows for Binance, OKX, LTP, Deribit, Hyperliquid, and other supported exchanges.
• AI-driven execution support for quantitative institutions and large-order trading.
• Smart order splitting and algorithmic execution workflows for TWAP/VWAP/POV-style orders.
• Plug-and-play account discovery, market data checks, order lifecycle management, and fill queries.
• Balance, margin, and position visibility across spot, margin, perpetual, futures, and options where supported by scripts.
• TCA analysis, Excel exports, and execution-cost review workflows.
• Strategy customization through script parameters and exchange-account specific routing rules.

Official Links

• Website: https://www.quantumexecute.com/
• API Docs: https://api.quantumexecute.com/trading-api
• Golang SDK: https://github.com/Quantum-Execute/qe-connector-go
• Python SDK: https://github.com/Quantum-Execute/qe-connector-python

New User Onboarding

1. Register an account on the QuantumExecute website.
2. In QuantumExecute trading account management, bind your exchange API key.
3. Add QE page IP addresses to your exchange API whitelist.
4. Create a QuantumExecute platform API key.
5. Use QE_API_KEY and QE_API_SECRET for authenticated scripts.

API Key Setup

Create a local env file:

cat > ~/.qe.env << 'EOF'
export QE_API_KEY="your_qe_api_key"
export QE_API_SECRET="your_qe_api_secret"
EOF
chmod 600 ~/.qe.env

Load credentials before running authenticated scripts:

source ~/.qe.env

Validate without printing secret values:

[[ -n "$QE_API_KEY" ]] && echo "QE_API_KEY loaded" || echo "QE_API_KEY missing"
[[ -n "$QE_API_SECRET" ]] && echo "QE_API_SECRET loaded" || echo "QE_API_SECRET missing"

Usage Examples

# Discover bound exchange accounts
List my QuantumExecute exchange API bindings.

# Check market data before trading
Get the latest BTCUSDT market quote.

# Query balances and positions
Check my Binance account spot balance, margin balance, and futures positions.
Check my OKX account spot balance and derivatives positions.
Check my LTP account spot assets, margin debt, and derivatives positions.
Check my Deribit account balances and futures/options positions.
Check my Hyperliquid spot balance and perp positions.

# Order lifecycle
Create a Binance DOGEUSDT TWAP order after running the required pre-checks.
Show details and fills for master order <masterOrderId>.
Cancel master order <masterOrderId>.

# TCA and reporting
Generate TCA analysis for master order <masterOrderId>.
Export order fills to Excel.
Generate TCA analysis for recent completed orders.

Configuration Requirements

• Python 3.9+.
• Python dependencies from requirements.txt:
  • qe-connector
  • requests
  • pandas
  • openpyxl
• QuantumExecute platform credentials:
  • QE_API_KEY
  • QE_API_SECRET
• Optional local output folder:
  • QE_WORKSPACE for generated reports.
• New users must register at QuantumExecute, bind exchange API keys, whitelist the IPs shown in the QuantumExecute UI, then create a QuantumExecute platform API key.

Capability and Credential Declaration

• This is a crypto execution/trading integration with authenticated read and write access through QuantumExecute APIs.
• Authenticated scripts can read exchange bindings, balances, positions, orders, fills, and TCA data.
• Order scripts can create, update, and cancel orders on exchange accounts bound to the QuantumExecute account.
• QE_API_KEY and QE_API_SECRET are required high-privilege credentials. Use restricted QuantumExecute keys, exchange API IP whitelisting, minimal exchange permissions, and audit logs where available.
• QE_BASE_URL is optional and should only point to trusted QuantumExecute endpoints. QE_WORKSPACE is optional and controls local report output.

Capability Routing

• Trading/order lifecycle: references/trading.md
• Balance/position/margin visibility: references/balance.md
• TCA and exports: references/tools.md
• Safety controls: references/safety.md
• Error handling and anti-fabrication: references/errors.md
• Fixed response templates: references/output-formats.md

Hard Rules (P0)

1. Execute scripts first; no fabricated values.
2. For create/update/cancel operations, require explicit user confirmation.
3. Keep numeric precision and pagination fields (total/page/pageSize) from script outputs.
4. Report stderr/error when scripts fail; do not hide failures.
5. Keep credentials in env vars only (QE_API_KEY, QE_API_SECRET).
6. Apply trading risk checks and parameter validation from references/trading.md before order writes.
7. Use fixed response templates from references/output-formats.md for order completion and TCA summaries.

Notes

• Always run account discovery with list_exchange_apis.py before choosing an account-specific script.
• Always run market-data and account pre-checks before create/update/cancel order operations.
• Treat notify_order_complete.py as optional and OpenClaw-oriented; generic hosted agents should prefer direct status queries.
• Do not expose full exchange API keys, QuantumExecute credentials, or local env files.
• Generated reports should be written to QE_WORKSPACE or the default local workspace.

Run

python3 scripts/<script>.py --help