Fees and order cost

# The arithmetic needs decimal maths, so it is in the other tabs. These are the two reads it starts from.
# Reuses KEY and SECRET from the signed-order example.
for URLPATH in /predictions-service/api/account /predictions-service/api/balance; do
  TS=$(( $(date +%s) * 1000 ))
  SIG=$(printf '%s' "${TS}GET${URLPATH}" | openssl dgst -sha256 -hmac "$SECRET" -binary | base64)
  curl -s "https://api.splashsports.com$URLPATH" \
    -H "SPLASH-ACCESS-KEY: $KEY" \
    -H "SPLASH-ACCESS-TIMESTAMP: $TS" \
    -H "SPLASH-ACCESS-SIGNATURE: $SIG"
  echo
done

# Reuses request() (and sign()) from the signed-order example in Authentication.
from decimal import Decimal, ROUND_FLOOR, ROUND_HALF_EVEN, ROUND_HALF_UP

MICRO = Decimal("0.000001")
CENT = Decimal("0.01")


def d(value):
    # Through str() so 0.655 is exactly 0.655, not the nearest binary float.
    return Decimal(str(value))


def cents(value):
    # Half up to the cent; ties go toward plus infinity, also for a negative amount.
    return (value + CENT / 2).quantize(CENT, rounding=ROUND_FLOOR)


def mul6(a, b):
    # Each multiplication step is rounded to 6 decimal places, half up, as Splash does.
    return (a * b).quantize(MICRO, rounding=ROUND_HALF_UP)


def fee_amount(fee, price, quantity):
    """The fee in dollars for one order: theta x C x p x (1 - p), from the `fee` object on GET /account."""
    if fee["type"] != "formula":
        raise ValueError("unknown fee type: " + fee["type"])
    p = d(price)
    raw = mul6(mul6(mul6(d(fee["theta"]), d(quantity)), p), Decimal(1) - p)
    return raw.quantize(CENT, rounding=ROUND_HALF_EVEN)


def order_cost(fee, price, quantity, closing=False):
    """What an order costs. Set closing=True for an order that sells contracts you hold."""
    p, qty = d(price), d(quantity)
    fee_dollars = fee_amount(fee, price, quantity)
    if closing:
        # A close debits nothing; the proceeds are credited when it fills.
        return {"contracts_cost": Decimal(0), "fee": fee_dollars, "debit": Decimal(0),
                "proceeds": cents(qty * (Decimal(1) - p) - fee_dollars)}
    contracts_cost = mul6(p, qty)
    return {"contracts_cost": contracts_cost, "fee": fee_dollars, "debit": cents(contracts_cost + fee_dollars)}


def can_afford(cost, cash_available, max_trade):
    """True when the debit fits in cash_available and the contracts cost fits in max_trade."""
    return cost["debit"] <= d(cash_available) and cost["contracts_cost"] <= d(max_trade)


account = request("GET", "/predictions-service/api/account").json()
cash_available = request("GET", "/predictions-service/api/balance").json()["balance"]["cash_available"]

order = {
    "market_id": "pm_6ae1e3c09e1d4c7a2b5f80e3d6a9c412",
    "side": "yes",
    "quantity": 10,
    "price": 0.59,
    "time_in_force": "FOK",
    "request_id": "3f1c2a9e-5b7d-4e0a-9c1d-8a6b2e4f7d10",
}
cost = order_cost(account["fee"], order["price"], order["quantity"])
print("fee", cost["fee"], "debit", cost["debit"])  # theta 0.07: fee 0.17 debit 6.07
if can_afford(cost, cash_available, account["max_trade"]):
    # The raw order, with no fee field: Splash computes the fee itself.
    response = request("POST", "/predictions-service/api/trading/orders", order)
    print(response.status_code, response.json())

// Reuses KEY, SECRET, HOST and sign() from the signed-order example in Authentication.
// All money is bigint micro-dollars (1 dollar = 1_000_000n), so nothing is lost to binary floats.
type Fee = { type: "formula"; formula_type: string; theta: number };

const ONE = 1_000_000n; // $1 in micro-dollars
const CENT = 10_000n; // $0.01

// Exact for any value with at most 6 decimal places, which every price and theta here has.
const micro = (value: number): bigint => BigInt(Math.round(value * 1_000_000));
// Rounds toward minus infinity; bigint division alone truncates toward zero.
const floorDiv = (a: bigint, b: bigint): bigint => (a >= 0n ? a / b : -((-a + b - 1n) / b));
// a and b are both micro-scaled; the product is rounded to 6 decimal places, half up, as Splash does.
const mul6 = (a: bigint, b: bigint): bigint => floorDiv(a * b + ONE / 2n, ONE);
const roundHalfUp = (value: bigint, unit: bigint): bigint => floorDiv(value + unit / 2n, unit) * unit;
const roundHalfEven = (value: bigint, unit: bigint): bigint => {
  const whole = floorDiv(value, unit);
  const rest = value - whole * unit;
  const up = rest * 2n > unit || (rest * 2n === unit && whole % 2n !== 0n);
  return (up ? whole + 1n : whole) * unit;
};

/** The fee in micro-dollars for one order: theta x C x p x (1 - p), from the `fee` object on GET /account. */
function feeAmount(fee: Fee, price: number, quantity: number): bigint {
  if (fee.type !== "formula") {
    throw new Error("unknown fee type");
  }
  const p = micro(price);
  return roundHalfEven(mul6(mul6(micro(fee.theta) * BigInt(quantity), p), ONE - p), CENT);
}

type OrderCost = { contractsCost: bigint; fee: bigint; debit: bigint; proceeds?: bigint };

/** What an order costs, in micro-dollars. Pass closing = true for an order that sells contracts you hold. */
function orderCost(fee: Fee, price: number, quantity: number, closing = false): OrderCost {
  const p = micro(price);
  const qty = BigInt(quantity);
  const feeMicro = feeAmount(fee, price, quantity);
  if (closing) {
    // A close debits nothing; the proceeds are credited when it fills.
    return { contractsCost: 0n, fee: feeMicro, debit: 0n, proceeds: roundHalfUp((ONE - p) * qty - feeMicro, CENT) };
  }
  const contractsCost = p * qty;
  return { contractsCost, fee: feeMicro, debit: roundHalfUp(contractsCost + feeMicro, CENT) };
}

/** True when the debit fits in cash_available and the contracts cost fits in max_trade. */
function canAfford(cost: OrderCost, cashAvailable: number, maxTrade: number): boolean {
  return cost.debit <= micro(cashAvailable) && cost.contractsCost <= micro(maxTrade);
}

/** Micro-dollars as a dollar string, for display: 6070000n -> "6.07". */
const dollars = (value: bigint): string => {
  const magnitude = value < 0n ? -value : value;
  return `${value < 0n ? "-" : ""}${magnitude / ONE}.${((magnitude % ONE) / CENT).toString().padStart(2, "0")}`;
};

async function signedJson(method: string, path: string, body = ""): Promise<any> {
  const timestamp = Date.now().toString();
  const response = await fetch(HOST + path, {
    method,
    headers: {
      ...(body ? { "Content-Type": "application/json" } : {}),
      "SPLASH-ACCESS-KEY": KEY,
      "SPLASH-ACCESS-TIMESTAMP": timestamp,
      "SPLASH-ACCESS-SIGNATURE": sign(SECRET, timestamp, method, path, body),
    },
    body: body || undefined,
  });
  return response.json();
}

const account = await signedJson("GET", "/predictions-service/api/account");
const { balance } = await signedJson("GET", "/predictions-service/api/balance");

const order = {
  market_id: "pm_6ae1e3c09e1d4c7a2b5f80e3d6a9c412",
  side: "yes",
  quantity: 10,
  price: 0.59,
  time_in_force: "FOK",
  request_id: "3f1c2a9e-5b7d-4e0a-9c1d-8a6b2e4f7d10",
};
const cost = orderCost(account.fee, order.price, order.quantity);
console.log("fee", dollars(cost.fee), "debit", dollars(cost.debit)); // theta 0.07: fee 0.17 debit 6.07
if (canAfford(cost, balance.cash_available, account.max_trade)) {
  // The raw order, with no fee field: Splash computes the fee itself.
  console.log(await signedJson("POST", "/predictions-service/api/trading/orders", JSON.stringify(order)));
}

package main

import (
	"encoding/json"
	"fmt"
	"math"
)

// Fee is the `fee` object from GET /account.
type Fee struct {
	Type        string  `json:"type"`
	FormulaType string  `json:"formula_type"`
	Theta       float64 `json:"theta"`
}

// All money is int64 micro-dollars (1 dollar = 1_000_000), so nothing is lost to binary floats.
const (
	one  int64 = 1_000_000 // $1
	cent int64 = 10_000    // $0.01
)

// Exact for any value with at most 6 decimal places, which every price and theta here has.
func micro(v float64) int64 { return int64(math.Round(v * 1_000_000)) }

// floorDiv rounds toward minus infinity; Go's / truncates toward zero.
func floorDiv(a, b int64) int64 {
	q := a / b
	if a%b != 0 && (a < 0) != (b < 0) {
		q--
	}
	return q
}

// a and b are both micro-scaled; the product is rounded to 6 decimal places, half up, as Splash does.
func mul6(a, b int64) int64           { return floorDiv(a*b+one/2, one) }
func roundHalfUp(v, unit int64) int64 { return floorDiv(v+unit/2, unit) * unit }

func roundHalfEven(v, unit int64) int64 {
	whole := floorDiv(v, unit)
	rest := v - whole*unit
	if rest*2 > unit || (rest*2 == unit && whole%2 != 0) {
		whole++
	}
	return whole * unit
}

// FeeAmount is the fee in micro-dollars for one order: theta x C x p x (1 - p), rounded to the cent half to even.
func FeeAmount(fee Fee, price float64, quantity int64) (int64, error) {
	if fee.Type != "formula" {
		return 0, fmt.Errorf("unknown fee type %q", fee.Type)
	}
	p := micro(price)
	return roundHalfEven(mul6(mul6(micro(fee.Theta)*quantity, p), one-p), cent), nil
}

// Cost is what one order costs, in micro-dollars.
type Cost struct {
	ContractsCost int64 // quantity x price; 0 on a close
	Fee           int64
	Debit         int64 // what a buy takes from cash_available; 0 on a close
	Proceeds      int64 // what a close credits when it fills; 0 on a buy
}

// OrderCost prices one order. Pass closing = true for an order that sells contracts you hold.
func OrderCost(fee Fee, price float64, quantity int64, closing bool) (Cost, error) {
	p := micro(price)
	feeMicro, err := FeeAmount(fee, price, quantity)
	if err != nil {
		return Cost{}, err
	}
	if closing {
		// A close debits nothing; the proceeds are credited when it fills.
		return Cost{Fee: feeMicro, Proceeds: roundHalfUp((one-p)*quantity-feeMicro, cent)}, nil
	}
	contractsCost := p * quantity
	return Cost{ContractsCost: contractsCost, Fee: feeMicro, Debit: roundHalfUp(contractsCost+feeMicro, cent)}, nil
}

// CanAfford is true when the debit fits in cash_available and the contracts cost fits in max_trade.
func CanAfford(cost Cost, cashAvailable, maxTrade float64) bool {
	return cost.Debit <= micro(cashAvailable) && cost.ContractsCost <= micro(maxTrade)
}

// dollars formats a whole-cent amount of micro-dollars: 6_070_000 -> "6.07".
func dollars(v int64) string {
	sign := ""
	if v < 0 {
		sign, v = "-", -v
	}
	return fmt.Sprintf("%s%d.%02d", sign, v/one, v%one/cent)
}

func main() {
	// `fee` and `max_trade` come from GET /account and `cash_available` from GET /balance, read with the
	// signed GET in Authentication. Here they are filled in by hand.
	var fee Fee
	if err := json.Unmarshal([]byte(`{"type":"formula","formula_type":"symmetric_price_uncertainty","theta":0.07}`), &fee); err != nil {
		panic(err)
	}
	maxTrade, cashAvailable := 100000.0, 250.0

	cost, err := OrderCost(fee, 0.59, 10, false)
	if err != nil {
		panic(err)
	}
	fmt.Println("fee", dollars(cost.Fee), "debit", dollars(cost.Debit)) // fee 0.17 debit 6.07
	if CanAfford(cost, cashAvailable, maxTrade) {
		// Send the raw order to POST /trading/orders: market_id, side, quantity, price, time_in_force and
		// request_id. There is no fee field; Splash computes the fee itself.
		fmt.Println("enough cash: send the order")
	}
}