Getting started

branch=testnet
revision=$(git ls-remote https://github.com/Fabric-Labs/polyester-proto.git "refs/heads/$branch" | cut -f1)
python3 - "$revision" <<'PYTHON'
import hashlib
import json
import sys
import urllib.request
import xml.etree.ElementTree as ET
from pathlib import Path

revision = sys.argv[1]
if not revision:
    raise SystemExit("Branch not found")
base = f"https://raw.githubusercontent.com/Fabric-Labs/polyester-proto/{revision}"
with urllib.request.urlopen(f"{base}/manifest.json") as response:
    manifest = json.load(response)
schema_url = f"{base}/{manifest['paths']['sbe']}"
with urllib.request.urlopen(schema_url) as response:
    schema = response.read()
metadata = manifest["tradeWebSocketSbe"]
root = ET.fromstring(schema)
if (hashlib.sha256(schema).hexdigest() != metadata["sha256"]
        or int(root.attrib["id"]) != metadata["schemaId"]
        or int(root.attrib["version"]) != metadata["schemaVersion"]):
    raise SystemExit("Schema and manifest do not match")
Path("tradews.xml").write_bytes(schema)
print(f"Schema ID: {root.attrib['id']}; accepted version: {root.attrib['version']}")
print(f"Schema file: {schema_url}")
PYTHON

import asyncio
import os
import struct
import time
import xml.etree.ElementTree as ET

import websockets
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey

HOST = os.environ.get("POLYESTER_TRADE_HOST", "trade.api.testnet.polyester.com")
PATH = "/ws/trade.sbe"
EMPTY_BODY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"

# Read the schema ID and version from the XML downloaded for this environment.
SCHEMA = ET.parse("tradews.xml").getroot()
SCHEMA_ID, SCHEMA_VERSION = int(SCHEMA.get("id")), int(SCHEMA.get("version"))

HEADER = struct.Struct("<HHHH")  # blockLength, templateId, schemaId, version
INT64_NULL = -(2**63)
PING, CREATE_ORDER, CANCEL_ORDER, SUBSCRIBE = 1, 2, 3, 6
COMMAND_ACK, COMMAND_REJECT, PONG, SUBSCRIPTION_ACK, ORDER_EVENT = 20, 21, 22, 23, 25
# CreateOrder fixed block, 82 bytes: seq, correlationId, symbolId, side, orderType,
# timeInForce, baseQtyScaled, priceTicks, flags, feeAsset, stpMode,
# marketClientRefPriceTicks, marketMaxSlippageTicks, marketMaxSlippageBps,
# sizingKind, maxQuoteDebitScaled, expireAtTsNs
CREATE_BLOCK = struct.Struct("<QQIBBBqqIBBqqiBqq")


def frame(template_id: int, block: bytes, *var_data: bytes) -> bytes:
    out = HEADER.pack(len(block), template_id, SCHEMA_ID, SCHEMA_VERSION) + block
    for data in var_data:
        out += struct.pack("<I", len(data)) + data
    return out


def ping(seq: int, correlation_id: int, payload: bytes) -> bytes:
    return frame(PING, struct.pack("<QQ", seq, correlation_id), payload)


def subscribe(seq: int, correlation_id: int, channels: int) -> bytes:
    return frame(SUBSCRIBE, struct.pack("<QQI", seq, correlation_id, channels))


def post_only_limit_sell(seq, correlation_id, symbol_id, qty_scaled, price_ticks, client_order_id):
    block = CREATE_BLOCK.pack(
        seq, correlation_id, symbol_id,
        2,  # side SELL
        1,  # orderType LIMIT
        1,  # timeInForce GTC
        qty_scaled, price_ticks,
        1,  # flags: postOnly
        1,  # feeAsset QUOTE
        1,  # stpMode EXPIRE_MAKER
        INT64_NULL, INT64_NULL, -(2**31),  # no market price protection overrides
        1,  # sizingKind BASE_QUANTITY
        INT64_NULL,  # maxQuoteDebitScaled is null
        INT64_NULL,  # expireAtTsNs is null for GTC
    )
    return frame(CREATE_ORDER, block, client_order_id.encode("ascii"))


def cancel_by_client_order_id(seq, correlation_id, symbol_id, client_order_id):
    block = struct.pack("<QQQI", seq, correlation_id, 0, symbol_id)  # orderId 0: use clientOrderId
    return frame(CANCEL_ORDER, block, client_order_id.encode("ascii"))


def describe(msg: bytes) -> str:
    block_length, template_id, _, _ = HEADER.unpack_from(msg)
    body = msg[HEADER.size:]
    if template_id == COMMAND_ACK:
        seq, corr, command, order_id, symbol_id = struct.unpack_from("<QQBQI", body)
        return f"CommandAck seq={seq} correlationId={corr} commandType={command} orderId={order_id}"
    if template_id == COMMAND_REJECT:
        seq, corr, code = struct.unpack_from("<QQH", body)
        (length,) = struct.unpack_from("<I", body, block_length)
        detail = body[block_length + 4:block_length + 4 + length].decode()
        return f"CommandReject seq={seq} correlationId={corr} code={code} detail={detail!r}"
    if template_id == PONG:
        seq, corr = struct.unpack_from("<QQ", body)
        return f"Pong seq={seq} correlationId={corr}"
    if template_id == SUBSCRIPTION_ACK:
        seq, corr, channels = struct.unpack_from("<QQI", body)
        return f"SubscriptionAck seq={seq} channels={channels:#x}"
    if template_id == ORDER_EVENT:
        symbol_id, order_id, version, status = struct.unpack_from("<IQIB", body)
        return f"OrderEvent orderId={order_id} version={version} status={status}"
    return f"template {template_id}, {len(msg)} bytes"


def upgrade_headers(key_id: str, private_key: Ed25519PrivateKey) -> dict:
    timestamp = str(int(time.time() * 1000))
    canonical = f"{timestamp}\nGET\n{PATH}\n\n{EMPTY_BODY_SHA256}"
    signature = private_key.sign(canonical.encode()).hex()
    return {"X-API-KEY-ID": key_id, "X-API-TIMESTAMP": timestamp, "X-API-SIGNATURE": signature}


async def main() -> None:
    private_key = Ed25519PrivateKey.from_private_bytes(bytes.fromhex(os.environ["POLYESTER_API_PRIVATE_KEY_HEX"]))
    headers = upgrade_headers(os.environ["POLYESTER_API_KEY_ID"], private_key)
    symbol_id = int(os.environ["SYMBOL_ID"])
    qty_scaled, price_ticks = int(os.environ["QTY_SCALED"]), int(os.environ["PRICE_TICKS"])
    client_order_id = f"quickstart-{int(time.time())}"

    async with websockets.connect(f"wss://{HOST}{PATH}", additional_headers=headers, compression=None) as ws:
        await ws.send(ping(1, 100, b"hello"))
        print(describe(await ws.recv()))
        await ws.send(subscribe(2, 101, 0b011))  # executions and orders
        print(describe(await ws.recv()))
        await ws.send(post_only_limit_sell(3, 102, symbol_id, qty_scaled, price_ticks, client_order_id))
        print(describe(await ws.recv()))
        await ws.send(cancel_by_client_order_id(4, 103, symbol_id, client_order_id))
        try:  # the cancel acknowledgement, then the order's events
            while True:
                print(describe(await asyncio.wait_for(ws.recv(), timeout=5)))
        except TimeoutError:
            pass


if __name__ == "__main__":
    asyncio.run(main())