# Send Hummingbot Developer to your agent
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
## Fast path
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
## Suggested prompts
### New install

```text
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Tell me what you changed and call out any manual steps you could not complete.
```
### Upgrade existing

```text
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Summarize what changed and any follow-up checks I should run.
```
## Machine-readable fields
```json
{
  "schemaVersion": "1.0",
  "item": {
    "slug": "hummingbot-developer",
    "name": "Hummingbot Developer",
    "source": "tencent",
    "type": "skill",
    "category": "开发工具",
    "sourceUrl": "https://clawhub.ai/fengtality/hummingbot-developer",
    "canonicalUrl": "https://clawhub.ai/fengtality/hummingbot-developer",
    "targetPlatform": "OpenClaw"
  },
  "install": {
    "downloadUrl": "/downloads/hummingbot-developer",
    "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=hummingbot-developer",
    "sourcePlatform": "tencent",
    "targetPlatform": "OpenClaw",
    "packageFormat": "ZIP package",
    "primaryDoc": "SKILL.md",
    "includedAssets": [
      "SKILL.md",
      "scripts/build_all.sh",
      "scripts/check_api.sh",
      "scripts/check_env.sh",
      "scripts/check_gateway.sh",
      "scripts/check_repos.sh"
    ],
    "downloadMode": "redirect",
    "sourceHealth": {
      "source": "tencent",
      "slug": "hummingbot-developer",
      "status": "healthy",
      "reason": "direct_download_ok",
      "recommendedAction": "download",
      "checkedAt": "2026-05-04T05:24:31.115Z",
      "expiresAt": "2026-05-11T05:24:31.115Z",
      "httpStatus": 200,
      "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=hummingbot-developer",
      "contentType": "application/zip",
      "probeMethod": "head",
      "details": {
        "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=hummingbot-developer",
        "contentDisposition": "attachment; filename=\"hummingbot-developer-1.0.0.zip\"",
        "redirectLocation": null,
        "bodySnippet": null,
        "slug": "hummingbot-developer"
      },
      "scope": "item",
      "summary": "Item download looks usable.",
      "detail": "Yavira can redirect you to the upstream package for this item.",
      "primaryActionLabel": "Download for OpenClaw",
      "primaryActionHref": "/downloads/hummingbot-developer"
    },
    "validation": {
      "installChecklist": [
        "Use the Yavira download entry.",
        "Review SKILL.md after the package is downloaded.",
        "Confirm the extracted package contains the expected setup assets."
      ],
      "postInstallChecks": [
        "Confirm the extracted package includes the expected docs or setup files.",
        "Validate the skill or prompts are available in your target agent workspace.",
        "Capture any manual follow-up steps the agent could not complete."
      ]
    }
  },
  "links": {
    "detailUrl": "https://openagent3.xyz/skills/hummingbot-developer",
    "downloadUrl": "https://openagent3.xyz/downloads/hummingbot-developer",
    "agentUrl": "https://openagent3.xyz/skills/hummingbot-developer/agent",
    "manifestUrl": "https://openagent3.xyz/skills/hummingbot-developer/agent.json",
    "briefUrl": "https://openagent3.xyz/skills/hummingbot-developer/agent.md"
  }
}
```
## Documentation

### hummingbot-developer

Developer workflow skill for building and running the full Hummingbot stack from source.

Commands (run as /hummingbot-developer <command>):

CommandDescriptionstartCheck dev environment statusselect-branchesPick branches for all 3 reposinstall-allInstall all 3 repos in orderbuild-allBuild wheel + all Docker imagesverify-buildVerify builds are correct + in syncrun-dev-stackStart full stack from sourcesetup-hummingbotInstall Hummingbot from sourcerun-hummingbotRun Hummingbot CLI from sourcebuild-hummingbotBuild wheel + Docker imagesetup-gatewayInstall Gateway from sourcerun-gatewayRun Gateway in dev modebuild-gatewayBuild Gateway Docker imagesetup-api-devWire API to local Hummingbot sourcerun-api-devRun API from source with hot-reloadtest-integrationSmoke test the full stack

Typical dev workflow:

install-deps → select-branches → install-all → build-all → verify-build → run-dev-stack → test-integration

Repo locations (all in workspace):

RepoPathhummingbot~/.openclaw/workspace/hummingbotgateway~/.openclaw/workspace/hummingbot-gatewayhummingbot-api~/.openclaw/workspace/hummingbot-api

Override with env vars: HUMMINGBOT_DIR, GATEWAY_DIR, HUMMINGBOT_API_DIR, or WORKSPACE.

### Command: install-deps

Auto-install all missing dev dependencies. Safe to re-run — skips anything already installed.

bash scripts/install_deps.sh

Installs (only if missing):

Homebrew (macOS)
Xcode Command Line Tools (macOS — needed for Cython build_ext)
Miniconda (conda)
Node.js v22 (via nvm, Homebrew, or installs nvm)
pnpm (via npm or Homebrew)
Git
Docker Desktop (macOS — via Homebrew cask or opens download page)

Options:

--check         # check only, don't install anything
--conda         # only install conda
--node          # only install node + nvm
--pnpm          # only install pnpm

After installing, restart your terminal (or source ~/.zshrc) to apply PATH changes, then run check_env.sh to confirm.

### Command: select-branches

Interactively pick a branch for each repo, checkout, and save to .dev-branches.

bash scripts/select_branches.sh

Non-interactive options:

# Use development for all
bash scripts/select_branches.sh --defaults

# Specify each branch
bash scripts/select_branches.sh \\
  --hummingbot development \\
  --gateway core-2.7 \\
  --api development

Branch selections are saved to $WORKSPACE/.dev-branches and automatically loaded by install_all.sh, build_all.sh, and verify_build.sh.

### Command: install-all

Install all three repos in the correct order. Requires select-branches first (or pass --defaults).

bash scripts/install_all.sh

What it does (in order):

Removes solders from environment.yml (pip-only)
make install in hummingbot → conda env hummingbot
pip install solders>=0.19.0 into hummingbot env
pnpm install && pnpm build && pnpm run setup:with-defaults for gateway
conda env create for hummingbot-api
pip install -e <hummingbot_dir> --no-deps → wires local source into API env

Options:

--skip-hbot      # skip hummingbot conda install
--skip-gateway   # skip gateway pnpm install
--skip-api       # skip hummingbot-api install
--no-local-hbot  # use PyPI hummingbot in API env instead of local source

### Command: build-all

Build hummingbot wheel and all Docker images in the correct order.

bash scripts/build_all.sh

Build order:

hummingbot wheel (dist/*.whl) via python setup.py bdist_wheel
hummingbot/hummingbot:dev Docker image
hummingbot/gateway:dev Docker image (also rebuilds dist/)
hummingbot/hummingbot-api:dev Docker image

Each image is also tagged with the branch name (e.g., hummingbot/gateway:core-2.7).

Options:

--wheel-only     # only build hummingbot wheel, no Docker
--no-docker      # skip all Docker builds
--no-hbot        # skip hummingbot builds
--no-gateway     # skip gateway builds
--no-api         # skip hummingbot-api builds
--tag <name>     # Docker tag (default: dev)

### Command: verify-build

Verify that all builds are correct and in sync.

bash scripts/verify_build.sh

Checks:

Each repo is on the expected branch (from .dev-branches)
Hummingbot wheel exists in dist/
Gateway dist/ is built and not stale vs source
Local hummingbot source is active in hummingbot-api env
Docker images exist with correct branch labels
Running services (API + Gateway) are reachable
API → Gateway connectivity

bash scripts/verify_build.sh --no-docker   # skip Docker checks
bash scripts/verify_build.sh --no-running  # skip service checks
bash scripts/verify_build.sh --json        # JSON output

### Command: run-dev-stack

Start the full dev stack from source.

bash scripts/run_dev_stack.sh

Start order:

Docker infra (postgres + EMQX) via docker compose up emqx postgres -d
Gateway from source in background (node dist/index.js --passphrase=hummingbot --dev)
Hummingbot API from source in foreground (uvicorn main:app --reload)

Options:

--no-gateway           # skip gateway start
--passphrase <pass>    # gateway passphrase (default: hummingbot)
--stop                 # stop everything
--status               # show running status

Logs:

Gateway logs: tail -f ~/.openclaw/workspace/.gateway.log
API logs: printed to terminal (foreground)

### Command: start

Check the full dev environment and show a status summary.

### Step 1: Run environment check

bash scripts/check_env.sh --json

### Step 2: Check repo branches

bash scripts/check_repos.sh --json

### Step 3: Check running services

bash scripts/check_api.sh --json
bash scripts/check_gateway.sh --json

### Step 4: Show status checklist

Present a checklist like:

Dev Environment Status
======================
  [x] Prerequisites     — conda, node, pnpm, docker, git OK
  [x] Hummingbot repo   — branch: development, env: hummingbot (installed)
  [x] Gateway repo      — branch: development, built: yes
  [x] Hummingbot API    — running at http://localhost:8000
  [x] Gateway           — running at http://localhost:15888
  [ ] Local hummingbot  — hummingbot-api NOT using local source

Next: run /hummingbot-developer setup-api-dev to wire API to local source

Adapt to actual state. If all good, show the test command.

### Command: setup-hummingbot

Install Hummingbot from source on the development branch.

### Step 1: Check prereqs

bash scripts/check_env.sh

### Step 2: Checkout development branch

cd <HUMMINGBOT_DIR>
git fetch origin
git checkout development
git pull origin development

### Step 3: Remove solders from environment.yml (pip-only package)

sed -i '' '/solders/d' setup/environment.yml 2>/dev/null || sed -i '/solders/d' setup/environment.yml

### Step 4: Install conda environment

make install

This creates the hummingbot conda env. Takes 3-10 minutes on first run.

### Step 5: Install solders via pip (not on conda)

conda run -n hummingbot pip install "solders>=0.19.0"

### Interpreting output

OutputMeaningNext stepconda develop . succeedsDev install registeredProceedPackagesNotFoundError: soldersForgot step 3Run sed + reinstallError: Conda is not foundconda not in PATHsource ~/.zshrc or install Anacondabuild_ext errorsMissing build toolsInstall Xcode CLT: xcode-select --install

### After setup

[x] conda env "hummingbot" created
  [x] solders installed via pip
  Run hummingbot: /hummingbot-developer run-hummingbot
  Build image:    /hummingbot-developer build-hummingbot

### Command: run-hummingbot

Run the Hummingbot CLI from source.

cd <HUMMINGBOT_DIR>
conda activate hummingbot
./bin/hummingbot_quickstart.py

Or via make:

cd <HUMMINGBOT_DIR>
make run

Note: This opens the interactive Hummingbot CLI. Use exit to quit.

To run with a specific config:

make run ARGS="--config-file-name conf_pure_mm_1.yml"

### Command: build-hummingbot

Build a Hummingbot wheel and/or Docker image from source.

### Build wheel (for local pip installs)

cd <HUMMINGBOT_DIR>
conda activate hummingbot
pip install build wheel  # if not already installed
python -m build --wheel --no-isolation

Wheel is output to dist/hummingbot-*.whl.

Important: The wheel must be built with Python 3.12 to match hummingbot-api's environment.

Use this wheel to install into other envs:

pip install dist/hummingbot-*.whl --force-reinstall --no-deps

### Build Linux wheel for Docker

When building hummingbot-api Docker images, you need a Linux wheel (not macOS/Windows). Build inside Docker to ensure compatibility:

cd <HUMMINGBOT_DIR>

# Build Linux wheel using Docker (Python 3.12 to match hummingbot-api)
docker run --rm -v $(pwd):/hummingbot -w /hummingbot continuumio/miniconda3 bash -c "
  apt-get update -qq && apt-get install -y -qq gcc g++ build-essential > /dev/null 2>&1 &&
  conda create -n build python=3.12 cython numpy -y -q &&
  conda run -n build pip install -q build wheel &&
  conda run -n build python -m build --wheel
"

# Verify the Linux wheel was created
ls dist/*linux*.whl
# Example: hummingbot-20260126-cp312-cp312-linux_aarch64.whl

Platform wheel suffixes:

linux_x86_64 — Linux AMD/Intel 64-bit
linux_aarch64 — Linux ARM64 (Apple Silicon Docker, AWS Graviton)
macosx_11_0_arm64 — macOS Apple Silicon (native only, NOT for Docker)
macosx_10_9_x86_64 — macOS Intel (native only, NOT for Docker)

### Build Docker image

cd <HUMMINGBOT_DIR>
docker build -t hummingbot/hummingbot:dev -f Dockerfile .

Or with make (also cleans first):

make build TAG=:dev

Tag for use with hummingbot-api:

docker build -t hummingbot/hummingbot:development -f Dockerfile .

### Interpreting output

OutputMeaningSuccessfully built + wheel pathWheel ready in dist/Successfully tagged hummingbot/hummingbot:devDocker image readybuild_ext errorCython compile issue — check conda env is activeOOM during Docker buildAdd --memory 4g flag

### Command: setup-gateway

Install and configure Gateway from source.

### Step 1: Check prereqs

Requires Node.js 20+, pnpm, and git.

bash scripts/check_env.sh

### Step 2: Checkout development branch

cd <GATEWAY_DIR>
git fetch origin
git checkout development
git pull origin development

### Step 3: Install dependencies

cd <GATEWAY_DIR>
pnpm install

If you see USB HID errors on macOS:

pnpm install --force

### Step 4: Build TypeScript

pnpm build

### Step 5: Run setup

# Non-interactive with defaults (recommended for dev)
pnpm run setup:with-defaults

# Interactive (choose which configs to update)
pnpm run setup

Setup creates:

conf/ — chain, connector, token, and RPC configs
certs/ — TLS certificates (self-signed for dev)

### Interpreting output

OutputMeaningNext stepGateway setup completeReady to startrun-gatewaytsc errorsTypeScript compile errorCheck Node version (node --version ≥ 20)pnpm: command not foundpnpm not installednpm install -g pnpmENOSPCDisk spaceFree up space

### Command: run-gateway

Run Gateway from source in dev mode (HTTP, no TLS).

cd <GATEWAY_DIR>
pnpm start --passphrase=<PASSPHRASE> --dev

Default passphrase matches hummingbot-api setup: hummingbot

pnpm start --passphrase=hummingbot --dev

What --dev does:

Runs in HTTP mode (no TLS) on port 15888
Enables verbose logging
Hummingbot API auto-connects at http://localhost:15888

Verify it's running:

curl http://localhost:15888/

Watch logs for startup sequence:

Gateway listening on port 15888
Solana mainnet-beta initialized
...

Configure custom RPC (recommended to avoid rate limits):

# After gateway is running, update RPC via API
curl -X POST http://localhost:15888/network/config \\
  -H "Content-Type: application/json" \\
  -d '{"chain": "solana", "network": "mainnet-beta", "nodeURL": "https://your-rpc.com"}'

### Command: build-gateway

Build a Gateway Docker image from source.

cd <GATEWAY_DIR>
docker build \\
  --build-arg BRANCH=$(git rev-parse --abbrev-ref HEAD) \\
  --build-arg COMMIT=$(git rev-parse HEAD) \\
  --build-arg BUILD_DATE=$(date -u +%Y-%m-%dT%H:%M:%SZ) \\
  -t hummingbot/gateway:dev \\
  -f Dockerfile .

Tag as development for use with hummingbot-api:

docker tag hummingbot/gateway:dev hummingbot/gateway:development

Verify image:

docker run --rm hummingbot/gateway:dev node -e "console.log('OK')"

### Command: setup-api-dev

Configure Hummingbot API to use a local Hummingbot source build instead of the PyPI package.

This lets you make changes to Hummingbot and immediately test them via the API without rebuilding Docker images.

### Step 1: Install hummingbot-api conda environment

cd <HUMMINGBOT_API_DIR>
make install

This creates the hummingbot-api conda env with the PyPI version of hummingbot.

### Step 2: Install local Hummingbot into hummingbot-api env

Option A — Editable install (recommended for active development):

conda run -n hummingbot-api pip install -e <HUMMINGBOT_DIR> --no-deps

Changes to hummingbot source are reflected immediately (no reinstall needed).

Option B — Wheel install (for testing a specific build):

# First build the wheel
cd <HUMMINGBOT_DIR> && conda run -n hummingbot python setup.py bdist_wheel

# Install into hummingbot-api env
conda run -n hummingbot-api pip install <HUMMINGBOT_DIR>/dist/hummingbot-*.whl --force-reinstall --no-deps

### Step 3: Verify local version is active

conda run -n hummingbot-api python -c "import hummingbot; print(hummingbot.__file__)"

Should print a path inside <HUMMINGBOT_DIR>, not site-packages.

### Step 4: Install solders

conda run -n hummingbot-api pip install "solders>=0.19.0"

### Interpreting output

OutputMeaningPath inside your hummingbot dir✅ Local source activePath inside anaconda3/.../site-packages❌ Still using PyPI versionImportError: No module named hummingbotpip install failed — retry

### Command: run-api-dev

Run Hummingbot API from source with hot-reload, using local Hummingbot.

### Step 1: Start infrastructure (postgres + EMQX via Docker)

cd <HUMMINGBOT_API_DIR>
docker compose up emqx postgres -d

Verify they're healthy:

docker compose ps

### Step 2: Run the API with uvicorn hot-reload

cd <HUMMINGBOT_API_DIR>
conda run --no-capture-output -n hummingbot-api uvicorn main:app --reload

Or via make:

make run

API is available at http://localhost:8000
Swagger UI at http://localhost:8000/docs

What hot-reload means: Changes to *.py files in hummingbot-api are applied immediately. Changes to hummingbot source (editable install) are also picked up on reload.

### Step 3: Confirm local hummingbot is in use

curl -s http://localhost:8000/health | python3 -m json.tool

Check API logs for hummingbot version on startup.

### Useful dev commands

# Watch logs
conda run -n hummingbot-api uvicorn main:app --reload --log-level debug

# Run on different port
conda run -n hummingbot-api uvicorn main:app --reload --port 8001

# Check what's running
docker compose ps
curl http://localhost:8000/health

### Command: test-integration

Smoke test the full dev stack — API, Gateway, and Hummingbot connectivity.

bash scripts/check_api.sh
bash scripts/check_gateway.sh
python scripts/test_integration.py

### What gets tested

TestChecksAPI healthGET /health returns 200API versionConfirms hummingbot source path (not PyPI)Gateway healthGET / on port 15888 returns 200API→GatewayAPI can reach Gateway (/gateway/status)ConnectorsAt least one connector visible via APIWalletsGateway wallet list accessible

### Interpreting results

OutputMeaningFix✓ API runningAPI up—✓ Gateway runningGateway up—✓ API→Gateway connectedFull stack wired—✗ API not runningStart with run-api-dev—✗ Gateway not runningStart with run-gateway—✗ API→Gateway: connection refusedGateway URL mismatchCheck .env GATEWAY_URL=http://localhost:15888✗ Local hummingbot not activeUsing PyPI versionRun setup-api-dev

### Docker-Based API Development

For testing with Docker containers (instead of source), build a custom hummingbot-api image with your hummingbot wheel.

### Step 1: Build Linux wheel for Docker

cd <HUMMINGBOT_DIR>

# Build Linux wheel using Docker (Python 3.12)
docker run --rm -v $(pwd):/hummingbot -w /hummingbot continuumio/miniconda3 bash -c "
  apt-get update -qq && apt-get install -y -qq gcc g++ build-essential > /dev/null 2>&1 &&
  conda create -n build python=3.12 cython numpy -y -q &&
  conda run -n build pip install -q build wheel &&
  conda run -n build python -m build --wheel
"

ls dist/*linux*.whl

### Step 2: Build hummingbot-api Docker image

cd <HUMMINGBOT_API_DIR>

# Copy wheel to API directory
cp <HUMMINGBOT_DIR>/dist/hummingbot-*-cp312-*-linux_*.whl .

# Update environment.docker.yml with wheel filename
# Then build using Dockerfile.dev
docker build -f Dockerfile.dev -t hummingbot/hummingbot-api:dev .

### Step 3: Deploy with docker-compose.dev.yml

cd <HUMMINGBOT_API_DIR>
docker compose -f docker-compose.dev.yml up -d

### Step 4: Verify development features

# Check lp_executor is available (only in development hummingbot)
curl -s -u admin:admin http://localhost:8000/executors/types/available | grep lp_executor

### Deploying Bots with Custom Images

When deploying bots via the API, specify which hummingbot Docker image to use.

### Deploy with development image

curl -X POST http://localhost:8000/bot-orchestration/deploy-v2-controllers \\
  -u admin:admin \\
  -H "Content-Type: application/json" \\
  -d '{
    "instance_name": "my-bot",
    "credentials_profile": "master_account",
    "controllers_config": ["my_controller.yml"],
    "image": "hummingbot/hummingbot:development"
  }'

### Available hummingbot images

ImageDescriptionhummingbot/hummingbot:latestStable PyPI release (default)hummingbot/hummingbot:developmentDevelopment branch from Docker Hubhummingbot/hummingbot:devLocally built image

### DEX connectors require Gateway

For connectors like meteora/clmm, Gateway must be running:

docker run -d --name gateway -p 15888:15888 \\
  -e GATEWAY_PASSPHRASE=admin \\
  hummingbot/gateway:development

### Full Dev Setup (first time)

# 1. Setup repos
cd ~/Documents/hummingbot && git checkout development && git pull
cd ~/.openclaw/workspace/hummingbot-gateway && git checkout development && git pull

# 2. Install hummingbot
cd ~/Documents/hummingbot
sed -i '' '/solders/d' setup/environment.yml
make install
conda run -n hummingbot pip install "solders>=0.19.0"

# 3. Install gateway
cd ~/.openclaw/workspace/hummingbot-gateway
pnpm install && pnpm build && pnpm run setup:with-defaults

# 4. Wire hummingbot-api to local source
cd ~/.openclaw/workspace/hummingbot-api
make install
conda run -n hummingbot-api pip install -e ~/Documents/hummingbot --no-deps
conda run -n hummingbot-api pip install "solders>=0.19.0"

# 5. Start everything
cd ~/.openclaw/workspace/hummingbot-gateway
pnpm start --passphrase=hummingbot --dev &

cd ~/.openclaw/workspace/hummingbot-api
docker compose up emqx postgres -d
make run

### Testing a Hummingbot Change

# 1. Make changes in hummingbot source
# 2. If editable install: just save the file (hot-reload picks it up)
# 3. If wheel install: rebuild and reinstall
cd ~/Documents/hummingbot
conda run -n hummingbot python setup.py bdist_wheel
conda run -n hummingbot-api pip install dist/hummingbot-*.whl --force-reinstall --no-deps
# 4. Restart API
# 5. Run tests
python scripts/test_integration.py

### Repo Paths (defaults)

ComponentDefault pathHummingbot~/Documents/hummingbotGateway~/.openclaw/workspace/hummingbot-gatewayHummingbot API~/.openclaw/workspace/hummingbot-api

Override by setting env vars:

export HUMMINGBOT_DIR=~/code/hummingbot
export GATEWAY_DIR=~/code/gateway
export HUMMINGBOT_API_DIR=~/code/hummingbot-api

### Scripts Reference

ScriptPurposecheck_env.shVerify prereqs (conda, node, pnpm, docker, git)check_repos.shShow branch + build status for each repocheck_api.shCheck if Hummingbot API is runningcheck_gateway.shCheck if Gateway is runningtest_integration.pyEnd-to-end smoke tests
## Trust
- Source: tencent
- Verification: Indexed source record
- Publisher: fengtality
- Version: 1.0.0
## Source health
- Status: healthy
- Item download looks usable.
- Yavira can redirect you to the upstream package for this item.
- Health scope: item
- Reason: direct_download_ok
- Checked at: 2026-05-04T05:24:31.115Z
- Expires at: 2026-05-11T05:24:31.115Z
- Recommended action: Download for OpenClaw
## Links
- [Detail page](https://openagent3.xyz/skills/hummingbot-developer)
- [Send to Agent page](https://openagent3.xyz/skills/hummingbot-developer/agent)
- [JSON manifest](https://openagent3.xyz/skills/hummingbot-developer/agent.json)
- [Markdown brief](https://openagent3.xyz/skills/hummingbot-developer/agent.md)
- [Download page](https://openagent3.xyz/downloads/hummingbot-developer)