EIP-712 signing

const domain = {
  name: 'PredictStreet',
  version: '1',
  chainId: 99999,
  verifyingContract: '0x4074c225b296E1E556c565B0C3Ddba305E63E7c4', // CTFExchange (binary)
};

struct Order {
    uint256 salt;
    address maker;
    address signer;
    address taker;
    uint256 tokenId;
    uint256 makerAmount;
    uint256 takerAmount;
    uint256 expiration;
    uint256 feeRateBps;
    uint8   side;
    uint8   signatureType;
}

calculatePrice(BUY)  = makerAmount × 1e18 / takerAmount   (floor)
calculatePrice(SELL) = takerAmount × 1e18 / makerAmount   (floor)

const priceWei = parseUnits('0.52', 6);        //         520_000
const qtyWei   = parseUnits('67.307692', 6);   //      67_307_692
const product  = priceWei * qtyWei;            // 34_999_999_840_000

// WRONG — FLOOR. Placement REJECTS with order_signed_with_floor_notional.
const notionalFloor = product / 1_000_000n;              // 34_999_999

// CORRECT — CEIL.
const notionalCeil  = (product + 999_999n) / 1_000_000n; // 35_000_000

import { Wallet, randomBytes, hexlify, parseUnits } from 'ethers';

// Inputs: `wallet` (your EOA signer), `userVaultAddress`
// (= VaultFactory.vaultOf(wallet.address)), `symbol`, and
// `market` = GET /api/markets/{symbol}.

const domain = {
  name: 'PredictStreet',
  version: '1',
  chainId: 99999,
  // negRiskEligible === true → neg-risk exchange; false / null → binary.
  verifyingContract: market.negRiskEligible === true
    ? '0x2eB97912c333963a21410Af1eF7E9a0aAB7631bf'  // NegRiskCtfExchange
    : '0x4074c225b296E1E556c565B0C3Ddba305E63E7c4', // CTFExchange (binary)
};

const types = {
  Order: [
    { name: 'salt', type: 'uint256' },
    { name: 'maker', type: 'address' },
    { name: 'signer', type: 'address' },
    { name: 'taker', type: 'address' },
    { name: 'tokenId', type: 'uint256' },
    { name: 'makerAmount', type: 'uint256' },
    { name: 'takerAmount', type: 'uint256' },
    { name: 'expiration', type: 'uint256' },
    { name: 'feeRateBps', type: 'uint256' },
    { name: 'side', type: 'uint8' },
    { name: 'signatureType', type: 'uint8' },
  ],
};

// BUY 10 YES @ 0.42 USDC (notional 4.20, above the 1 USDC minimum order size)
const priceWei = parseUnits('0.42', 6);        //    420_000
const qtyWei   = parseUnits('10',   6);        // 10_000_000
// CEIL on BUY notional — sub-cent +1-wei guard against the
// matcher's per-fill CEIL math overflowing your signed cap. See
// "Rounding rule" above for the full rationale. FLOOR-signed BUY
// orders are rejected at placement with
// `order_signed_with_floor_notional`.
const product     = priceWei * qtyWei;
const notionalWei = (product + 999_999n) / 1_000_000n; // 4_200_000

// CRITICAL — feeRateBps MUST equal `market.feeTakerBps` from
// `GET /api/markets/{symbol}`. The platform reconstructs the canonical
// Order struct with the live taker fee, hashes it, and recovers the
// signer against THAT digest. Signing with `0n` (or any other constant)
// produces a different hash → recovery returns the wrong address →
// `POST /api/orders/place` rejects with `bad_signature` (or with
// `stale_fee_quote` when you echo the signed value, as below). There is no
// override; the fee is per-market and partner SDKs must thread it
// through to the signer.
const feeRateBps = BigInt(market.feeTakerBps);

// Outcome index you trade (binary: 0 = YES, 1 = NO). The platform verifies
// against the tokenId of the outcomes[] entry with this outcomeIndex.
const outcome = 0;
const tokenId = BigInt(
  market.outcomes.find((o) => o.outcomeIndex === outcome)!.tokenId,
);

// 256-bit random salt. ethers v6 randomBytes() returns a Uint8Array,
// so convert it with hexlify(). `.toString('hex')` does NOT produce hex.
const salt = BigInt(hexlify(randomBytes(32)));

const order = {
  salt,
  maker:         userVaultAddress,         // VaultFactory.vaultOf(signer), never the EOA
  signer:        wallet.address,           // EOA you authenticate as
  taker:         '0x0000000000000000000000000000000000000000',
  tokenId,
  makerAmount:   notionalWei,              // BUY → USDC notional
  takerAmount:   qtyWei,                   // BUY → outcome qty
  expiration:    0n,                       // 0 = no on-chain expiry (recommended)
  feeRateBps,                              // = market.feeTakerBps (see above)
  side:          0,                        // BUY
  signatureType: 1,                        // VAULT, the only accepted value
};

const signature = await wallet.signTypedData(domain, types, order);

// REST body for POST /api/orders/place. The platform rebuilds the Order
// struct from these fields, so they must describe exactly what you signed.
const body = {
  marketId:   symbol,
  side:       'buy',                       // → side 0
  outcome:    String(outcome),             // index whose tokenId you signed
  price:      '0.42',                      // → makerAmount / takerAmount
  quantity:   '10',
  nonce:      salt.toString(),             // MUST equal the signed salt (base-10)
  expiry:     0,                           // MUST equal the signed expiration
  maker:      userVaultAddress,            // your vault (your EOA is also accepted here)
  feeRateBps: Number(feeRateBps),          // echo of the signed fee
  signature,
};

import secrets
from eth_account import Account

# Inputs: `private_key` (your EOA key), `vault_address`
# (= VaultFactory.vaultOf(signer)), `symbol`, and
# `market` = GET /api/markets/{symbol}.
acct = Account.from_key(private_key)

domain = {
    "name": "PredictStreet",
    "version": "1",
    "chainId": 99999,
    # negRiskEligible True -> neg-risk exchange; False / None -> binary CTFExchange.
    "verifyingContract": (
        "0x2eB97912c333963a21410Af1eF7E9a0aAB7631bf"
        if market.get("negRiskEligible") is True
        else "0x4074c225b296E1E556c565B0C3Ddba305E63E7c4"
    ),
}
types = {
    "EIP712Domain": [
        {"name": "name", "type": "string"},
        {"name": "version", "type": "string"},
        {"name": "chainId", "type": "uint256"},
        {"name": "verifyingContract", "type": "address"},
    ],
    "Order": [
        {"name": "salt", "type": "uint256"},
        {"name": "maker", "type": "address"},
        {"name": "signer", "type": "address"},
        {"name": "taker", "type": "address"},
        {"name": "tokenId", "type": "uint256"},
        {"name": "makerAmount", "type": "uint256"},
        {"name": "takerAmount", "type": "uint256"},
        {"name": "expiration", "type": "uint256"},
        {"name": "feeRateBps", "type": "uint256"},
        {"name": "side", "type": "uint8"},
        {"name": "signatureType", "type": "uint8"},
    ],
}

# BUY 10 YES @ 0.42 USDC (6-decimal wei)
price_wei = 420_000
qty_wei = 10_000_000
notional_wei = (price_wei * qty_wei + 999_999) // 1_000_000  # CEIL on BUY -> 4_200_000

outcome = 0  # binary: 0 = YES, 1 = NO
token_id = int(next(o for o in market["outcomes"] if o["outcomeIndex"] == outcome)["tokenId"])
fee_rate_bps = int(market["feeTakerBps"])  # must equal the live market fee
salt = secrets.randbits(256)               # send str(salt) as the body's `nonce`

order_dict = {
    "salt": salt,
    "maker": vault_address,                # VaultFactory.vaultOf(signer), never the EOA
    "signer": acct.address,                # EOA you authenticate as
    "taker": "0x0000000000000000000000000000000000000000",
    "tokenId": token_id,
    "makerAmount": notional_wei,           # BUY -> USDC notional
    "takerAmount": qty_wei,                # BUY -> outcome qty
    "expiration": 0,                       # 0 = no on-chain expiry (recommended)
    "feeRateBps": fee_rate_bps,
    "side": 0,                             # BUY
    "signatureType": 1,                    # VAULT, the only accepted value
}

# Pass the typed data as `full_message=`: the second positional argument
# of sign_typed_data is `domain_data`, not the full message.
signed = Account.sign_typed_data(
    private_key,
    full_message={"domain": domain, "primaryType": "Order", "types": types, "message": order_dict},
)
# The API requires a 0x-prefixed signature. bytes.hex() never adds the
# prefix (and neither does HexBytes.hex() in hexbytes >= 1.0).
signature = "0x" + bytes(signed.signature).hex()

body = {
    "marketId": symbol,
    "side": "buy",
    "outcome": str(outcome),
    "price": "0.42",
    "quantity": "10",
    "nonce": str(salt),                    # MUST equal the signed salt (base-10)
    "expiry": 0,                           # MUST equal the signed expiration
    "maker": vault_address,
    "feeRateBps": fee_rate_bps,            # echo of the signed fee
    "signature": signature,
}

const vaultDomain = {
  name: 'PredictStreetVault',
  version: '1',
  chainId: 99999,
  verifyingContract: userVaultAddress, // VaultFactory.vaultOf(signer)
};