Cross-exchange market making

import asyncio
from decimal import Decimal

from sory import SoryClient

QUOTE_ON = ["bullish", "coinbaseexchange", "kraken"]   # where the bid rests
HEDGE_ON = ["binance", "bybit", "okx"]                 # where the hedge crosses

config = {
    "licence_key": "...",
    "symbol": "BTC/USDT",
    "exchanges": QUOTE_ON + HEDGE_ON,
    "fees_bps": "fees.toml",
    # The hedge crosses the spread, so compare hedge venues on what you actually pay.
    "fee_offset": {venue: "taker" for venue in HEDGE_ON},
}

SIZE = Decimal("0.05")
EDGE_BPS = Decimal("8")


async def main():
    async with SoryClient(config) as sory:
        await asyncio.sleep(1)                     # let the books fill

        # Price the quote off the hedge it would actually get: the size you would have to
        # sell, on the venues you would sell it on — not the mid, and not the whole book.
        book = sory.book()
        hedge = book.vwap(SIZE, "sell", exclude=QUOTE_ON)
        price = hedge.price * (1 - EDGE_BPS / 10000)

        # One resting bid per venue. Limits go to one venue each — they are never split.
        quotes = {}
        for venue in QUOTE_ON:
            order = await sory.place(
                side="buy",
                qty=SIZE,
                exchanges=[venue],
                order_type="limit",
                price=price,
            )
            quotes[order.children[0].client_order_id] = order

        # When one is hit, sell what was filled across the deep venues.
        hedged: dict[str, Decimal] = {}
        async for update in sory.order_updates():
            order = quotes.get(update.client_order_id)
            if order is None:
                continue                           # someone else's order on the same key

            new_fill = order.filled - hedged.get(order.id, Decimal(0))
            if new_fill <= 0:
                continue

            hedged[order.id] = order.filled
            laid_off = await sory.place(
                side="sell",
                qty=new_fill,
                order_type="market",
                exchanges=HEDGE_ON,
            )
            await sory.confirm(laid_off)           # the venues' view, not the stream's
            print(f"hit {new_fill} on {update.venue}, hedged at {laid_off.achieved_price}")


asyncio.run(main())

async with SoryClient(config) as sory:
    for resting in await sory.open_orders():
        print(resting.venue, resting.id, resting.price, resting.remaining)

await sory.cancel_all()      # everything resting for this symbol, every venue