231 lines
9.5 KiB
Python
231 lines
9.5 KiB
Python
# This is an end to end example of a very basic adding strategy.
|
||
import json
|
||
import logging
|
||
import threading
|
||
import time
|
||
|
||
import example_utils
|
||
|
||
from hyperliquid.exchange import Exchange
|
||
from hyperliquid.info import Info
|
||
from hyperliquid.utils import constants
|
||
from hyperliquid.utils.signing import get_timestamp_ms
|
||
from hyperliquid.utils.types import (
|
||
SIDES,
|
||
Dict,
|
||
L2BookData,
|
||
L2BookMsg,
|
||
L2BookSubscription,
|
||
Literal,
|
||
Optional,
|
||
Side,
|
||
TypedDict,
|
||
Union,
|
||
UserEventsMsg,
|
||
UserEventsSubscription,
|
||
)
|
||
|
||
# --------------------------- CONFIGURATION ---------------------------
|
||
|
||
# How far from the best bid and offer this strategy ideally places orders. Currently set to 0.3%.
|
||
# i.e., if the best bid is $1000, this strategy will place a resting bid at $997 (1000 - 0.3% of 1000).
|
||
DEPTH = 0.003
|
||
|
||
# How far from the target price a resting order can deviate before the strategy will cancel and replace it.
|
||
# i.e., using the same example as above of a best bid of $1000 and targeted depth of 0.3% (a $3 difference).
|
||
# Bids within $3 * 0.5 = $1.5 of the ideal price will not be cancelled. Therefore, any bids > $998.5 or < $995.5
|
||
# will be cancelled and replaced.
|
||
ALLOWABLE_DEVIATION = 0.5
|
||
|
||
# The maximum absolute position value the strategy can accumulate in units of the coin.
|
||
# i.e., the strategy will place orders such that it can long up to 1 ETH or short up to 1 ETH.
|
||
MAX_POSITION = 1.0
|
||
|
||
# The coin to add liquidity on.
|
||
COIN = "ETH"
|
||
|
||
# The interval (in seconds) at which the polling function runs.
|
||
POLL_INTERVAL = 10
|
||
|
||
# The maximum time (in milliseconds) to wait for an in-flight order before treating it as cancelled.
|
||
ORDER_TIMEOUT = 10000
|
||
|
||
# The time (in milliseconds) to keep recently cancelled orders before cleaning them up.
|
||
CANCEL_CLEANUP_TIME = 30000
|
||
|
||
# --------------------------- TYPE DEFINITIONS ---------------------------
|
||
|
||
InFlightOrder = TypedDict("InFlightOrder", {"type": Literal["in_flight_order"], "time": int})
|
||
Resting = TypedDict("Resting", {"type": Literal["resting"], "px": float, "oid": int})
|
||
Cancelled = TypedDict("Cancelled", {"type": Literal["cancelled"]})
|
||
ProvideState = Union[InFlightOrder, Resting, Cancelled]
|
||
|
||
|
||
def side_to_int(side: Side) -> int:
|
||
"""Convert side ('A' for Ask, 'B' for Bid) to an integer multiplier."""
|
||
return 1 if side == "A" else -1
|
||
|
||
|
||
def side_to_uint(side: Side) -> int:
|
||
"""Convert side ('A' for Ask, 'B' for Bid) to an unsigned integer (0 or 1)."""
|
||
return 1 if side == "A" else 0
|
||
|
||
|
||
class BasicAdder:
|
||
def __init__(self, address: str, info: Info, exchange: Exchange):
|
||
self.info = info
|
||
self.exchange = exchange
|
||
self.address = address
|
||
self.position: Optional[float] = None
|
||
self.provide_state: Dict[Side, ProvideState] = {
|
||
"A": {"type": "cancelled"},
|
||
"B": {"type": "cancelled"},
|
||
}
|
||
self.recently_cancelled_oid_to_time: Dict[int, int] = {}
|
||
|
||
# Subscribe to updates
|
||
self.subscribe_to_updates()
|
||
|
||
# Start the polling thread
|
||
self.start_poller()
|
||
|
||
def subscribe_to_updates(self) -> None:
|
||
"""Subscribe to order book and user event updates."""
|
||
l2_book_subscription: L2BookSubscription = {"type": "l2Book", "coin": COIN}
|
||
self.info.subscribe(l2_book_subscription, self.on_book_update)
|
||
|
||
user_events_subscription: UserEventsSubscription = {"type": "userEvents", "user": self.address}
|
||
self.info.subscribe(user_events_subscription, self.on_user_events)
|
||
|
||
def start_poller(self) -> None:
|
||
"""Start the polling thread for checking open orders and positions."""
|
||
self.poller = threading.Thread(target=self.poll, daemon=True)
|
||
self.poller.start()
|
||
|
||
def on_book_update(self, book_msg: L2BookMsg) -> None:
|
||
"""Callback for order book updates."""
|
||
logging.debug(f"Received book message: {book_msg}")
|
||
book_data = book_msg["data"]
|
||
|
||
if book_data["coin"] != COIN:
|
||
logging.warning("Unexpected book message, skipping.")
|
||
return
|
||
|
||
for side in SIDES:
|
||
self.handle_order_placement(side, book_data)
|
||
|
||
def handle_order_placement(self, side: Side, book_data: L2BookData) -> None:
|
||
"""Handle the placement and cancellation of orders based on the order book update."""
|
||
book_price = float(book_data["levels"][side_to_uint(side)][0]["px"])
|
||
ideal_distance = book_price * DEPTH
|
||
ideal_price = book_price + (ideal_distance * side_to_int(side))
|
||
|
||
provide_state = self.provide_state[side]
|
||
|
||
if provide_state["type"] == "resting":
|
||
self.maybe_cancel_order(side, provide_state, ideal_price, ideal_distance)
|
||
elif provide_state["type"] == "in_flight_order":
|
||
self.check_in_flight_order(side, provide_state)
|
||
|
||
if provide_state["type"] == "cancelled":
|
||
self.place_new_order(side, ideal_price)
|
||
|
||
def maybe_cancel_order(self, side: Side, provide_state: Resting, ideal_price: float, ideal_distance: float) -> None:
|
||
"""Cancel the order if it deviates beyond the allowable limit."""
|
||
distance = abs(ideal_price - provide_state["px"])
|
||
if distance > ALLOWABLE_DEVIATION * ideal_distance:
|
||
oid = provide_state["oid"]
|
||
print(f"Cancelling order due to deviation: oid:{oid}, side:{side}, ideal_price:{ideal_price}")
|
||
response = self.exchange.cancel(COIN, oid)
|
||
if response["status"] == "ok":
|
||
self.recently_cancelled_oid_to_time[oid] = get_timestamp_ms()
|
||
self.provide_state[side] = {"type": "cancelled"}
|
||
else:
|
||
logging.error(f"Failed to cancel order {oid} for side {side}: {response}")
|
||
|
||
def check_in_flight_order(self, side: Side, provide_state: InFlightOrder) -> None:
|
||
"""Check if the in-flight order has timed out."""
|
||
if get_timestamp_ms() - provide_state["time"] > ORDER_TIMEOUT:
|
||
print("Order is still in flight after timeout, treating as cancelled.")
|
||
self.provide_state[side] = {"type": "cancelled"}
|
||
|
||
def place_new_order(self, side: Side, ideal_price: float) -> None:
|
||
"""Place a new order if conditions are met."""
|
||
if self.position is None:
|
||
logging.debug("Waiting for position refresh before placing order.")
|
||
return
|
||
|
||
size = MAX_POSITION + self.position * side_to_int(side)
|
||
if size * ideal_price < 10:
|
||
logging.debug("Order size too small, not placing order.")
|
||
return
|
||
|
||
px = float(f"{ideal_price:.5g}")
|
||
print(f"Placing order: size:{size}, price:{px}, side:{side}")
|
||
response = self.exchange.order(COIN, side == "B", size, px, {"limit": {"tif": "Alo"}})
|
||
if response["status"] == "ok":
|
||
status = response["response"]["data"]["statuses"][0]
|
||
if "resting" in status:
|
||
self.provide_state[side] = {"type": "resting", "px": px, "oid": status["resting"]["oid"]}
|
||
|
||
def on_user_events(self, user_events: UserEventsMsg) -> None:
|
||
"""Callback for user events (e.g., fills)."""
|
||
print(user_events)
|
||
if "fills" in user_events["data"]:
|
||
with open("fills", "a+") as f:
|
||
f.write(json.dumps(user_events["data"]["fills"]) + "\n")
|
||
# Set the position to None so that we don't place more orders without knowing our position
|
||
# You might want to also update provide_state to account for the fill. This could help avoid sending an
|
||
# unneeded cancel or failing to send a new order to replace the filled order, but we skipped this logic
|
||
# to make the example simpler
|
||
self.position = None
|
||
|
||
def poll(self) -> None:
|
||
"""Poll open orders and user positions periodically."""
|
||
while True:
|
||
# Fetch open orders
|
||
open_orders = self.info.open_orders(self.exchange.wallet.address)
|
||
print("open_orders", open_orders)
|
||
|
||
# Collect valid order IDs (from recently cancelled orders and resting orders)
|
||
ok_oids = set(self.recently_cancelled_oid_to_time.keys())
|
||
for provide_state in self.provide_state.values():
|
||
if provide_state["type"] == "resting":
|
||
ok_oids.add(provide_state["oid"])
|
||
|
||
# Cancel any unknown orders
|
||
for open_order in open_orders:
|
||
if open_order["coin"] == COIN and open_order["oid"] not in ok_oids:
|
||
print("Cancelling unknown oid", open_order["oid"])
|
||
self.exchange.cancel(open_order["coin"], open_order["oid"])
|
||
|
||
# Clean up recently cancelled orders after a timeout
|
||
current_time = get_timestamp_ms()
|
||
self.recently_cancelled_oid_to_time = {
|
||
oid: timestamp
|
||
for oid, timestamp in self.recently_cancelled_oid_to_time.items()
|
||
if current_time - timestamp <= CANCEL_CLEANUP_TIME
|
||
}
|
||
self.refresh_position()
|
||
time.sleep(POLL_INTERVAL)
|
||
|
||
def refresh_position(self) -> None:
|
||
"""Refresh the user’s current position."""
|
||
user_state = self.info.user_state(self.address)
|
||
for position in user_state.get("assetPositions", []):
|
||
if position["position"]["coin"] == COIN:
|
||
self.position = float(position["position"]["szi"])
|
||
return
|
||
self.position = 0.0
|
||
|
||
|
||
def main():
|
||
# Setting this to logging.DEBUG can be helpful for debugging websocket callback issues
|
||
logging.basicConfig(level=logging.INFO)
|
||
address, info, exchange = example_utils.setup(constants.TESTNET_API_URL)
|
||
BasicAdder(address, info, exchange)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|