Taking liquidity

import { Wallet, TypedDataEncoder, getAddress, zeroPadValue, randomBytes, hexlify } from "ethers";

const API = "https://api.sx.bet"; // Mainnet — use https://api.toronto.sx.bet for testnet
const MARKET = process.env.SX_MARKET_HASH;
const wallet = new Wallet(process.env.SX_PRIVATE_KEY);
const authed = (init = {}) => ({
  ...init,
  headers: { "Content-Type": "application/json", "x-sx-api-key": process.env.SX_API_KEY, ...init.headers },
});

const { data: meta } = await fetch(`${API}/metadata/obv3`).then((r) => r.json());

// 1. Read the book in YOUR frame. showTakerPerspective=true shows each side as
//    the price someone wanting that outcome would pay.
const { data: book } = await fetch(
  `${API}/orderbook-v3/snapshot?marketHash=${MARKET}&showTakerPerspective=true`
).then((r) => r.json());

// 2. Best available price for outcome TWO is index 0 of outcomeTwo.
const best = book.outcomeTwo[0];
if (!best) throw new Error("no liquidity on outcome two");

// 3. Submit an IOC at that price. Anything at this price or better fills.
const order = {
  marketHash: MARKET,
  maker: wallet.address,
  totalBetSize: "1000000",
  percentageOdds: best.percentageOdds,
  salt: hexlify(randomBytes(32)),
  expiry: 0,
  baseToken: meta.activeAsset.baseToken,
  isMakerBettingOutcomeOne: false,       // betting outcome TWO
  timeInForce: "IOC",
};
const TYPES = { Order: [
  { name: "marketHash", type: "bytes32" }, { name: "baseToken", type: "address" },
  { name: "totalBetSize", type: "uint256" }, { name: "percentageOdds", type: "uint256" },
  { name: "salt", type: "uint256" }, { name: "expiry", type: "uint256" },
  { name: "maker", type: "address" }, { name: "isMakerBettingOutcomeOne", type: "bool" },
] };
const domain = meta.domain; // complete EIP-712 domain
const message = {
  marketHash: zeroPadValue(order.marketHash, 32), baseToken: getAddress(order.baseToken),
  totalBetSize: BigInt(order.totalBetSize), percentageOdds: BigInt(order.percentageOdds),
  salt: BigInt(order.salt), expiry: BigInt(order.expiry), maker: getAddress(order.maker),
  isMakerBettingOutcomeOne: order.isMakerBettingOutcomeOne,
};
const orderSignature = await wallet.signTypedData(domain, TYPES, message);
const orderId = TypedDataEncoder.hash(domain, TYPES, message).toLowerCase();

const res = await fetch(`${API}/orders-v3`, authed({
  method: "POST",
  body: JSON.stringify({ orders: [{ ...order, orderSignature }] }),
}));
console.log(`HTTP ${res.status}`, JSON.stringify(await res.json()));

// 4. The result is in your trades, not your orders — an IOC never rests.
//    Join /fills-v3 rows on fill.orderId.
await new Promise((r) => setTimeout(r, 8000));
const { data: f } = await fetch(`${API}/fills-v3`, authed()).then((r) => r.json());
const mine = f.fills.filter((x) => x.orderId === orderId);
for (const x of mine) console.log(`  ${x.fillAmount} @ ${x.fillOdds} → returns ${x.returnAmount}`);

import json, os, secrets, time, requests
from eth_account import Account
from eth_account.messages import encode_typed_data
from eth_utils import keccak, to_checksum_address

API = "https://api.sx.bet"  # Mainnet — use https://api.toronto.sx.bet for testnet
MARKET = os.environ["SX_MARKET_HASH"]
account = Account.from_key(os.environ["SX_PRIVATE_KEY"])
headers = {"Content-Type": "application/json", "x-sx-api-key": os.environ["SX_API_KEY"]}

meta = requests.get(f"{API}/metadata/obv3").json()["data"]

# 1. Read the book in YOUR frame. showTakerPerspective=true shows each side as
#    the price someone wanting that outcome would pay.
book = requests.get(
    f"{API}/orderbook-v3/snapshot", params={"marketHash": MARKET, "showTakerPerspective": "true"}
).json()["data"]

# 2. Best available price for outcome TWO is index 0 of outcomeTwo.
outcome_two = book["outcomeTwo"]
if not outcome_two:
    raise Exception("no liquidity on outcome two")
best = outcome_two[0]

# 3. Submit an IOC at that price. Anything at this price or better fills.
order = {
    "marketHash": MARKET,
    "maker": account.address,
    "totalBetSize": "1000000",
    "percentageOdds": best["percentageOdds"],
    "salt": str(int.from_bytes(secrets.token_bytes(32), "big")),
    "expiry": 0,
    "baseToken": meta["activeAsset"]["baseToken"],
    "isMakerBettingOutcomeOne": False,      # betting outcome TWO
    "timeInForce": "IOC",
}
TYPES = {"Order": [
    {"name": "marketHash", "type": "bytes32"},
    {"name": "baseToken", "type": "address"},
    {"name": "totalBetSize", "type": "uint256"},
    {"name": "percentageOdds", "type": "uint256"},
    {"name": "salt", "type": "uint256"},
    {"name": "expiry", "type": "uint256"},
    {"name": "maker", "type": "address"},
    {"name": "isMakerBettingOutcomeOne", "type": "bool"},
]}
domain = {
    "name": meta["domain"]["name"],
    "version": meta["domain"]["version"],
    "chainId": meta["chainId"],
    "verifyingContract": to_checksum_address(meta["activeAsset"]["escrowAddress"]),
}
message = {
    **order,
    "baseToken": to_checksum_address(order["baseToken"]),
    "totalBetSize": int(order["totalBetSize"]),
    "percentageOdds": int(order["percentageOdds"]),
    "salt": int(order["salt"]),
    "maker": to_checksum_address(order["maker"]),
}
del message["timeInForce"]  # not part of the signed struct
signable = encode_typed_data(domain_data=domain, message_types=TYPES, message_data=message)
order_signature = account.sign_message(signable).signature.to_0x_hex()
order_id = "0x" + keccak(b"\x19" + signable.version + signable.header + signable.body).hex()

res = requests.post(f"{API}/orders-v3", headers=headers,
                    json={"orders": [{**order, "orderSignature": order_signature}]})
print(f"HTTP {res.status_code}", res.json())

# 4. The result is in your trades, not your orders — an IOC never rests.
#    Join /fills-v3 rows on fill.orderId.
time.sleep(8)
fills = requests.get(f"{API}/fills-v3", headers=headers).json()["data"]["fills"]
mine = [f for f in fills if f["orderId"] == order_id]
for f in mine:
    print(f"  {f['fillAmount']} @ {f['fillOdds']} -> returns {f['returnAmount']}")