Trading API

$env:OGUARD_API_KEY = "ogk_..."
$env:OGUARD_API_SECRET = "ogs_..."
python oguard_client.py doctor

export OGUARD_API_KEY="ogk_..."
export OGUARD_API_SECRET="ogs_..."
python3 oguard_client.py doctor

import os
from decimal import Decimal
from oguard_client import OGuardClient, OGuardAPIError

og = OGuardClient(os.environ["OGUARD_API_KEY"], os.environ["OGUARD_API_SECRET"])

print(og.balances())
print(og.perps.tickers(["BTCUSDT.P"]))

# Prices and quantities are str, int or Decimal, never float.
# Each order gets a clientOrderId; pass client_order_id="..." to use your own
# (unique per account: resending one returns the order already placed under it).
ack = og.perps.place_order("BTCUSDT.P", "buy", "limit", Decimal("0.001"), price="50000")
print(ack)                      # {'ok': True, 'orderId': 'OG-...', 'clientOrderId': 'py-...'}

order = og.perps.order(ack["orderId"])["order"]   # waits briefly while the new order is recorded
og.perps.amend_order(ack["orderId"], price="49900")
og.perps.cancel_order(ack["orderId"])

try:
    og.perps.cancel_order(ack["orderId"])   # already cancelled above
except OGuardAPIError as err:
    print(err.status, err.code)             # every refusal carries an HTTP status and an error code

pip install cryptography
python oguard_client.py keygen      # prints a private key (keep it) and a public key (paste it on the API keys page)

og = OGuardClient("ogk_...", private_key=open("oguard_ed25519.pem").read())

import hashlib, hmac, json, time, urllib.request

API = "https://api.oguard.io"
KEY, SECRET = "ogk_...", "ogs_..."

def signed(method, path, body=None, query=""):
    payload = json.dumps(body, separators=(",", ":")) if body is not None else query
    ts, window = str(int(time.time() * 1000)), "5000"
    sig = hmac.new(SECRET.encode(), (ts + KEY + window + payload).encode(), hashlib.sha256).hexdigest()
    req = urllib.request.Request(API + path + ("?" + query if query else ""), method=method,
                                 data=payload.encode() if body is not None else None)
    for name, value in {"X-OG-API-KEY": KEY, "X-OG-TIMESTAMP": ts, "X-OG-RECV-WINDOW": window,
                        "X-OG-SIGN-TYPE": "hmac", "X-OG-SIGN": sig,
                        "Content-Type": "application/json"}.items():
        req.add_header(name, value)
    with urllib.request.urlopen(req, timeout=10) as r:
        return json.loads(r.read())

print(signed("GET", "/api/v1/account/balances"))
print(signed("POST", "/api/v1/perps/orders", {"symbol": "BTCUSDT.P", "side": "buy", "type": "limit",
                                               "qty": "0.001", "price": "50000",
                                               "clientOrderId": f"hand-{int(time.time() * 1000)}"}))

TS=$(($(date +%s%N)/1000000)); BODY='{"symbol":"BTCUSDT.P","side":"buy","type":"limit","qty":"0.001","price":"50000"}'
SIG=$(printf '%s' "${TS}${KEY}5000${BODY}" | openssl dgst -sha256 -hmac "$SECRET" | sed 's/^.* //')
curl -sS -X POST "https://api.oguard.io/api/v1/perps/orders" -H "Content-Type: application/json" \
  -H "X-OG-API-KEY: $KEY" -H "X-OG-TIMESTAMP: $TS" -H "X-OG-RECV-WINDOW: 5000" \
  -H "X-OG-SIGN-TYPE: hmac" -H "X-OG-SIGN: $SIG" --data-raw "$BODY"

# Hedge mode: position_idx 1 is the long side, 2 the short side.
og.perps.set_leverage("BTCUSDT.P", 5)
og.perps.place_order("BTCUSDT.P", "buy", "market", "0.01", position_idx=1)

pos = og.perps.position("BTCUSDT.P", "buy", wait=5)   # the fill takes a moment to be recorded
og.perps.set_tpsl(pos["id"], "entire", take_profit_pct="2.5", stop_loss_pct="1")

# Close the long: a reduce-only sell on the long side.
og.perps.place_order("BTCUSDT.P", "sell", "market", "0.01", reduce_only=True, position_idx=1)

import time
from oguard_client import OGuardNetworkError

cid = f"grid-{int(time.time() * 1000)}"     # your id: 1-30 of A-Z a-z 0-9 _ -, unique per account
try:
    ack = og.perps.place_order("BTCUSDT.P", "buy", "limit", "0.001", price="50000", client_order_id=cid)
except OGuardNetworkError as err:
    # No answer came back. The order may still have been placed: ask by your id.
    # This waits up to 2 s for it to be recorded; OGuardAPIError 404 then means it was not placed.
    order = og.perps.order_by_client_id(err.client_order_id)

print([s["symbol"] for s in og.stocks.markets()["symbols"]])   # NVDAXUSDT, AAPLXUSDT, ...

# Buy 25 USDT of Nvidia at market: market_unit="quoteCoin" sizes a market buy in USDT.
og.stocks.place_order("NVDAXUSDT", "buy", "market", "25", market_unit="quoteCoin")

# A limit order's qty is always in the stock token.
ack = og.stocks.place_order("NVDAXUSDT", "buy", "limit", "0.5", price="100")
og.stocks.cancel_order(ack["orderId"])

print(og.stocks.holdings())       # what you own
print(og.stocks.order_history(days=7))

import time
from decimal import Decimal

symbols = [i["symbol"] for i in og.cfd.instruments()["instruments"]]
eurusd = next(s for s in symbols if s.startswith("EURUSD"))

print(og.cfd.account())           # the CFD wallet: balance, equity, free margin, margin level
print(og.cfd.preview(eurusd, "buy", "0.10"))   # margin the order would take

quote = og.cfd.quotes([eurusd])["quotes"][0]   # prices are strings at the instrument's digits
bid, ask = Decimal(quote["bid"]), Decimal(quote["ask"])

# Open 0.10 lots at market with a stop 200 pips away. Idempotent, like every placement.
ack = og.cfd.place_order(eurusd, "buy", "market", "0.10", stop_loss=bid - Decimal("0.02"))
order_id = ack["order"]["id"]

og.cfd.set_protection(order_id, take_profit=ask + Decimal("0.02"))   # the stop-loss is kept
og.cfd.close(order_id, volume="0.05")                               # close half
og.cfd.close(order_id)                                              # and the rest

# A pending order: a buy limit below the market, good for a day.
pending = og.cfd.place_order(eurusd, "buy", "limit", "0.10", entry_price=bid - Decimal("0.03"),
                             expires_at=int(time.time() * 1000) + 86_400_000)
og.cfd.modify_order(pending["order"]["id"], entry_price=bid - Decimal("0.025"))
og.cfd.cancel_order(pending["order"]["id"])

from oguard_client import CancelAllAfterHeartbeat

# While the block runs, a background thread re-arms the switch every 5 s. If the
# process dies or hangs, every open order is cancelled within 15 s. A clean exit
# disarms it.
with CancelAllAfterHeartbeat(og, timeout_ms=15_000, every_s=5):
    book = og.perps.orderbook("BTCUSDT.P", limit=5)
    best_bid = book["bids"][0]["price"]
    og.perps.place_order("BTCUSDT.P", "buy", "limit", "0.001", price=best_bid, client_order_id="mm-bid-1")
    og.perps.cancel_order_by_client_id("mm-bid-1")

print(og.cancel_all_after_state())   # {'enabled': False, ...} after the block

import asyncio
from oguard_client import OGuardClient, MarketStream, HistoryStream, CfdStream

og = OGuardClient("ogk_...", "ogs_...")

async def account():
    async with HistoryStream(og) as stream:        # perpetuals and tokenized stocks
        async for event in stream:
            if event["kind"] == "resync":
                # Frames were missed: re-read positions, open orders and balances.
                print("resync:", event["reason"], og.perps.positions())
            elif event["kind"] in ("order", "trade", "position", "balance"):
                print(event["kind"], event["seq"], event["data"])

async def cfds():
    async with CfdStream(og) as stream:
        await stream.subscribe_quotes(["EURUSD"])
        async for event in stream:
            print("cfd", event["kind"], event.get("data"))

async def market():
    async with MarketStream() as m:
        await m.subscribe("BTCUSDT.P")                 # ticker
        await m.subscribe("BTCUSDT.P", "kline", "1")   # 1-minute candles
        async for msg in m:
            print(msg["ch"], msg.get("data"))

async def main():
    await asyncio.gather(account(), cfds(), market())

asyncio.run(main())