Introduction
Revenant is a lightweight, open-source DCA (Dollar-Cost-Averaging) spot trading bot for Hyperliquid decentralized exchange, written entirely in Python.
It automates recurring spot market buys at configurable intervals, with built-in position sizing, take-profit logic, and real-time status monitoring using the official Hyperliquid Python SDK.
The bot was designed from the ground up for simplicity, reliability, and zero-maintenance operation.
This documentation walks through the full development and deployment journey, from initial setup and core trading logic to packaging it as a clean Flask app and launching it as a managed web service on DigitalOcean App Platform in minutes.
By following this documentation, anyone can run the bot as-is, customize it for their own strategy, or learn how to build and deploy similar trading tools.
Initial Skeletal Setup
Before any trading logic, we start with the smallest possible Flask application. This confirms that the project structure, build process, and DigitalOcean App Platform configuration are working correctly.
Project Structure (Root Folder)
revenant/
├── app.py
├── requirements.txt
Files
app.py
import os
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "Hello World!"
# Optional: only used when running locally with `python app.py`
if __name__ == "__main__":
port = int(os.getenv("PORT", 8080))
app.run(host="0.0.0.0", port=port)
requirements.txt
Flask
gunicorn
Next, deploy the app on DigitalOcean App Platform.
First, create a new GitHub repository (eg. revenant) and push the two files above to the main branch.
Head over to the DigitalOcean Control Panel, navigate to App Platform, then click on Create app.
Connect your GitHub account, select the relevant repository, and the main branch. App Platform will automatically detect the Python app.
In the Web Service component settings, set the run command as gunicorn --worker-tmp-dir /dev/shm app:app, and leave the build command empty.
Click Create App
Once the build finishes, your app will be live at a URL similar to https://revenant-xxxxx.ondigitalocean.app. You should see a plain white page with the text Hello World! exactly as shown below:
This confirms the deployment pipeline is working. From here, we can safely start building the actual DCA trading logic for Revenant without worrying about infrastructure issues.
Core Hyperliquid Utilities
Now, let's add the trading helper functions that interact with the Hyperliquid DEX. These utilities handle authentication, balance checks, price fetching, and executing market buy/sell orders for the relevant spot pair.
All sensitive data (especially the private key) is loaded from environment variables. Keys are never to be committed to Git.
Create a new Python file in the root directory (utility.py):
revenant/
├── app.py
├── requirements.txt
├── utility.py ← new file
In the new utility.py file, add the following code:
import os
import eth_account
from hyperliquid.info import Info
from hyperliquid.exchange import Exchange
from hyperliquid.utils import constants
# Load private key from environment variable (required for DigitalOcean)
HL_PRIVATE_KEY = os.getenv("HL_PRIVATE_KEY")
if not HL_PRIVATE_KEY:
raise ValueError("HL_PRIVATE_KEY environment variable is not set!")
# Authentication
wallet = eth_account.Account.from_key(HL_PRIVATE_KEY)
address = wallet.address
# Initialize exchange for placing orders
exchange = Exchange(
wallet,
base_url=constants.MAINNET_API_URL,
account_address=address
)
# Initialize info client for reading data (REST only)
info = Info(constants.MAINNET_API_URL, skip_ws=True)
# Get USDC and HYPE balances (available balance = total - hold)
def get_balances(BASE_ASSET, QUOTE_ASSET):
state = info.spot_user_state(wallet.address)
balances = state.get("balances", [])
quote_balance = 0.0
base_balance = 0.0
for balance in balances:
if balance["coin"] == QUOTE_ASSET:
quote_balance = float(balance["total"]) - float(balance["hold"])
if balance["coin"] == BASE_ASSET:
base_balance = float(balance["total"]) - float(balance["hold"])
return quote_balance, base_balance
# Get current HYPE price from mid price
def get_price(BASE_ASSET):
all_mids = info.all_mids()
price = all_mids.get(BASE_ASSET)
return float(price) if price else None
# Execute market sell of HYPE
def execute_sell(BASE_ASSET, QUOTE_ASSET, base_balance: float):
sell = exchange.market_open(
name=f"{BASE_ASSET}/{QUOTE_ASSET}",
is_buy=False,
sz=round(base_balance, 2),
slippage=0.002
)
return sell
# Execute market buy of HYPE with USDC amount
def execute_buy(BASE_ASSET, QUOTE_ASSET,buy_size_usdc: float):
if get_price(BASE_ASSET) is None:
raise ValueError(f"Could not fetch {BASE_ASSET} price")
size = buy_size_usdc / get_price(BASE_ASSET)
buy = exchange.market_open(
name=f"{BASE_ASSET}/{QUOTE_ASSET}",
is_buy=True,
sz=round(size, 2),
slippage=0.002
)
return buy
# Get the most recent fill (useful for logging/tracking)
def get_most_recent_fill():
fills = info.user_fills(address)
if not fills:
return None
return fills[0]
Then update the requirements.txt file to reflect the newly added libraries, hyperliquid-python-sdk, eth-account, and protobuf:
Flask
gunicorn
hyperliquid-python-sdk
eth-account
protobuf
Following the introduction of a new environment variable, let's update DigitalOcean's Environment Variables.
Go to your app in the DigitalOcean control panel and click "Edit" on the Web Service component. Scroll to Environmental Variables and add a new variable:
- Key: HL_PRIVATE_KEY
- Value: 0x...
Click Save → Deploy (or let it auto-deploy on push).
Core DCA Trading Logic
We now replace the minimal "Hello World" Flask app with a complete trading engine for Revenant.
The bot implements a simple but effective DCA strategy on the HYPE/USDC spot pair:
- Buys $10 worth of HYPE on every run (unless USDC balance is too low).
- Continuously averages the buy price.
- When the current price reaches +3% the average buy price, it sells the entire HYPE position, records the PnL, and starts a new session.
- All states are tracked in a global counter dictionary (in-memory for now).
Full app.py:
import os, time
from flask import Flask, jsonify
import utility
import datetime
# Add background scheduler imports
from apscheduler.schedulers.background import BackgroundScheduler
import atexit
app = Flask(__name__)
# Define global variables
counter = {
"avg_buy_price": float(0.0),
"total_sessions": 0,
"buy_size_usdc": float(10.0),
"buy_count": 0,
"total_buy_trades": 0,
"total_volume_usdc": float(0.0)
}
BASE_ASSET = "HYPE"
QUOTE_ASSET = "USDC"
@app.route('/')
def home():
return jsonify(counter)
@app.route("/execute")
def execute():
# Initialize status
status = ""
# Fetch current market data, update AUM
quote_balance, base_balance = utility.get_balances(BASE_ASSET, QUOTE_ASSET)
price = utility.get_price(BASE_ASSET)
AUM = float(quote_balance) + (float(base_balance) * float(price))
# Save balances
counter["base_balance"] = base_balance
counter["quote_balance"] = quote_balance
counter["price"] = price
counter["AUM"] = AUM
# Start/continue trading
# Check if sell condition is met.
sell_condition_is_met = False
if float(price) >= float(counter["avg_buy_price"]) * 0.03 and float(counter["avg_buy_price"]) != float(0):
sell_condition_is_met = True
# if sell condition is met, liquidate hype position, end session, and start a new session. else keep buying.
if sell_condition_is_met:
# liquidate hype position (sell all of hype balance)
sell = utility.execute_sell(BASE_ASSET, QUOTE_ASSET, base_balance)
# get fill price and calculate pnl in usdc
time.sleep(5)
most_recent_fill = utility.get_most_recent_fill()
avg_fill_price = most_recent_fill["px"]
pnl_usdc = (float(avg_fill_price) - float(counter["avg_buy_price"])) * float(counter["base_balance"]) # (avg fill price - avg buy price) * total hype bought
# update counter
counter["pnl_usdc"] = pnl_usdc
counter["total_sessions"] += 1
counter["total_volume_usdc"] += (float(base_balance) * float(avg_fill_price))
counter["last_trade"] = datetime.datetime.now(datetime.UTC)
status = "Sell condition met, HYPE holdings sold."
else:
# keep buying with a constant size of $10
buy_size_usdc = counter["buy_size_usdc"]
# Execute buy if buy size is less than or equal to the available balance
if buy_size_usdc <= quote_balance:
# execute buy
buy = utility.execute_buy(BASE_ASSET, QUOTE_ASSET, float(buy_size_usdc))
# wait 5 seconds, get most recent fill details
time.sleep(5)
most_recent_fill = utility.get_most_recent_fill()
avg_fill_price = most_recent_fill["px"]
if float(counter["avg_buy_price"]) == float(0):
counter["avg_buy_price"] = float(avg_fill_price)
else:
counter["avg_buy_price"] = (float(counter["avg_buy_price"]) + float(avg_fill_price))/2
# Update counter
counter["buy_count"] += 1
counter["total_buy_trades"] += 1
counter["total_volume_usdc"] += float(buy_size_usdc)
counter["last_trade"] = datetime.datetime.now(datetime.UTC)
status = "Sell condition not met, buy executed."
else:
status = "Sell condition not met, balance low." # buy nothing when balance low, wait for next 15 minutes
return jsonify(status)
# ── Background Scheduler (runs automatically every hour) ──
scheduler = BackgroundScheduler()
def scheduled_execute():
"""Wrapper that runs the trading cycle from the background job."""
with app.app_context():
execute()
scheduler.add_job(
scheduled_execute,
trigger='interval',
hours=1,
id='revenant_dca_cycle',
replace_existing=True
)
scheduler.start()
# Gracefully shut down scheduler when the app exits
atexit.register(lambda: scheduler.shutdown(wait=False))
# Optional: only used when running locally with `python app.py`
if __name__ == "__main__":
port = int(os.getenv("PORT", 8080))
app.run(host="0.0.0.0", port=port)
How the Strategy Works (Summary)
| Action | Condition | What Happens |
|---|---|---|
| Buy | Price < 3% avg_buy_price | Buy $10 USDC of HYPE |
| Sell (Take profit) | Price ≥ 3% avg_buy_price | Sell all HYPE, record PnL, reset session |
| No-op | Insufficient USDC balance | Wait for next cycle |
Next, let's add a background scheduler (APScheduler) so the bot automatically runs the /execute endpoint every 1 hour.
Automatic Trading Every Hour
Add a background scheduler using APScheduler so Revenant automatically runs the full DCA trading cycle (/execute logic) every 1 hour. No manual calls or external cron jobs required.
Add APScheduler to the requirements.txt:
Flask
gunicorn
hyperliquid
eth-account
APScheduler
Next, add background scheduler imports:
from apscheduler.schedulers.background import BackgroundScheduler
import atexit
Then add the scheduler code beneath the trade logic execution:
# ── Background Scheduler (runs automatically every hour) ──
scheduler = BackgroundScheduler()
def scheduled_execute():
"""Wrapper that runs the trading cycle from the background job."""
with app.app_context():
execute()
scheduler.add_job(
scheduled_execute,
trigger='interval',
hours=1,
id='revenant_dca_cycle',
replace_existing=True
)
scheduler.start()
# Gracefully shut down scheduler when the app exits
atexit.register(lambda: scheduler.shutdown(wait=False))
Update Run command on DigitalOcean
To prevent the scheduler from starting multiple times (Gunicorn forks workers by default):
- Go to your app in DigitalOcean Control Panel → Components → your Web Service → Edit.
- Change the Run command to:
gunicorn --worker-tmp-dir /dev/shm --preload --workers=1 app:app - Save and Redeploy.
The --preload flag ensures the scheduler is created only once before workers are forked.
Current Limitations
- State is stored only in memory → resets when the app restarts.
- No error handling or retry logic around API calls yet.
Conclusion
Revenant is now a fully functional, automated DCA spot-trading bot running live on the DigitalOcean App Platform.
It connects securely to Hyperliquid, executes $10 USDC buys every hour, tracks average entry price, and automatically takes profit by selling the entire position when the price doubles.
The entire project uses a minimal, clean Flask + APScheduler setup that deploys in minutes and requires zero server management.
This is a solid foundation to extend: add persistent storage, configurable parameters via environment variables, a web dashboard, error alerts, or even multi-pair support.
