Posting orders

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 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,
  },
});

// 1. Fetch metadata and build the signing domain.
const { data: meta } = await fetch(`${API}/metadata/obv3`).then((r) => r.json());
const domain = meta.domain;                         // complete EIP-712 domain

// 2. Round the odds DOWN onto the ladder, before signing.
const step = BigInt(meta.oddsLadderStepSize) * 10n ** 15n;
const wanted = 40000000000000000000n;               // 40.000% implied
const percentageOdds = ((wanted / step) * step).toString();

// 3. Build the order. `expiry` is a NUMBER; the three amounts are STRINGS.
const order = {
  marketHash: process.env.SX_MARKET_HASH,
  maker: wallet.address,
  totalBetSize: "1000000",                          // 1 USDC, 6 dp
  percentageOdds,
  salt: hexlify(randomBytes(32)),
  expiry: Math.floor(Date.now() / 1000) + 3600,     // 0 = never expires
  baseToken: meta.activeAsset.baseToken,
  isMakerBettingOutcomeOne: true,                   // the outcome YOU want to bet
  timeInForce: "GTC",
};

// 4. Sign the eight-field struct. Order matters: salt precedes expiry.
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 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);

// The order id IS the EIP-712 digest, lowercased. Compute it before submitting.
const orderId = TypedDataEncoder.hash(domain, TYPES, message).toLowerCase();

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

console.log(`HTTP ${res.status}`);
console.log(JSON.stringify(body, null, 2));

// 6. PENDING is not live. Poll until it appears, or watch the account channel.
for (let i = 0; i < 10; i++) {
  await new Promise((r) => setTimeout(r, 1000));
  const { data } = await fetch(`${API}/orders-v3?marketHash=${order.marketHash}`, authed())
    .then((r) => r.json());
  const row = data.orders.find((o) => o.id === orderId);
  if (row) {
    console.log(`ACTIVE after ${i + 1}s:`);
    console.log(JSON.stringify(row, null, 2));
    break;
  }
}

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
account = Account.from_key(os.environ["SX_PRIVATE_KEY"])
headers = {"Content-Type": "application/json", "x-sx-api-key": os.environ["SX_API_KEY"]}

# 1. Fetch metadata and build the signing domain.
meta = requests.get(f"{API}/metadata/obv3").json()["data"]
domain = {
    "name": meta["domain"]["name"],                   # "OBv3 Escrow"
    "version": meta["domain"]["version"],             # "1"
    "chainId": meta["chainId"],                       # from metadata, never a constant
    "verifyingContract": to_checksum_address(meta["activeAsset"]["escrowAddress"]),
}

# 2. Round the odds DOWN onto the ladder, before signing.
step = int(meta["oddsLadderStepSize"]) * 10**15
wanted = 40_000_000_000_000_000_000                   # 40.000% implied
percentage_odds = (wanted // step) * step

# 3. Build the order. `expiry` is a NUMBER; the three amounts are STRINGS.
order = {
    "marketHash": os.environ["SX_MARKET_HASH"],
    "maker": account.address,
    "totalBetSize": "1000000",                        # 1 USDC, 6 dp
    "percentageOdds": str(percentage_odds),
    "salt": str(int.from_bytes(secrets.token_bytes(32), "big")),
    "expiry": int(time.time()) + 3600,                # 0 = never expires
    "baseToken": meta["activeAsset"]["baseToken"],
    "isMakerBettingOutcomeOne": True,                 # the outcome YOU want to bet
    "timeInForce": "GTC",
}

# 4. Sign the eight-field struct. Order matters: salt precedes expiry.
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"},
]}
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()

# The order id IS the EIP-712 digest, lowercased. Compute it before submitting.
order_id = "0x" + keccak(b"\x19" + signable.version + signable.header + signable.body).hex()

# 5. Submit.
res = requests.post(f"{API}/orders-v3", headers=headers,
                    json={"orders": [{**order, "orderSignature": order_signature}]})
body = res.json()

print(f"HTTP {res.status_code}")
print(json.dumps(body, indent=2))
returned = body["data"]["orders"][0]["orderId"]
print(f"local digest  : {order_id}")
print(f"returned id   : {returned}")
print(f"match         : {returned.lower() == order_id}")

# 6. PENDING is not live. Poll until it appears, or watch the account channel.
for i in range(10):
    time.sleep(1)
    data = requests.get(f"{API}/orders-v3", headers=headers,
                        params={"marketHash": order["marketHash"]}).json()["data"]
    row = next((o for o in data["orders"] if o["id"].lower() == order_id), None)
    if row:
        print(f"ACTIVE after {i + 1}s:")
        print(json.dumps(row, indent=2))
        break