Quickstart: REST

export API=https://api.agg.market
export APP_ID=your-app-id
export ORIGIN=https://app.example.com   # one of your app's allowed origins
export DOMAIN=${ORIGIN#*://}            # app.example.com

# A throwaway test wallet. Keep the key out of source control.
cast wallet new
export PK=0x...                         # private key from the output
export ADDRESS=$(cast wallet address --private-key $PK)   # EIP-55 checksummed

import { createAggClient } from "@agg-build/sdk";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";

const client = createAggClient({
  baseUrl: "https://api.agg.market",
  appId: "your-app-id",
});
const ORIGIN = "https://app.example.com"; // one of your app's allowed origins
const account = privateKeyToAccount(process.env.PK as `0x${string}` ?? generatePrivateKey());

NONCE=$(curl -s -X POST $API/auth/start \
  -H "x-app-id: $APP_ID" -H "content-type: application/json" \
  -d '{ "provider": "siwe" }' | jq -r .nonce)

ISSUED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)
MESSAGE=$(printf '%s wants you to sign in with your Ethereum account:\n%s\n\n\nURI: %s\nVersion: 1\nChain ID: 1\nNonce: %s\nIssued At: %s' \
  "$DOMAIN" "$ADDRESS" "$ORIGIN" "$NONCE" "$ISSUED_AT")
SIGNATURE=$(cast wallet sign --private-key $PK "$MESSAGE")

export ACCESS_TOKEN=$(curl -s -X POST $API/auth/verify \
  -H "x-app-id: $APP_ID" -H "content-type: application/json" \
  -d "$(jq -n --arg m "$MESSAGE" --arg s "$SIGNATURE" '{message: $m, signature: $s}')" \
  | jq -r .accessToken)

const { nonce } = await client.authStart({ provider: "siwe" });
const message = client.buildSiweMessage({
  address: account.address,
  chainId: 1,
  nonce,
  domain: new URL(ORIGIN).host,
  uri: ORIGIN,
});
const signature = await account.signMessage({ message });
await client.verify({ message, signature }); // the client now sends the token for you

# 202 { "ready": false } while addresses are created. Repeat until 200.
curl -s $API/execution/deposit-addresses \
  -H "x-app-id: $APP_ID" -H "Authorization: Bearer $ACCESS_TOKEN" | jq

let deposit = await client.getDepositAddresses();
while (!deposit.ready) {
  await new Promise((r) => setTimeout(r, 2000));
  deposit = await client.getDepositAddresses();
}
console.log(deposit.evmAddress, deposit.supportedChains);

curl -s $API/execution/balances \
  -H "x-app-id: $APP_ID" -H "Authorization: Bearer $ACCESS_TOKEN" \
  | jq '.cash[] | {tokenSymbol, availableRaw, decimals}'

const balances = await client.getManagedBalances();
console.log(balances.cash.map((c) => [c.tokenSymbol, c.availableRaw, c.decimals]));

curl -s "$API/venue-markets?status=open&search=bitcoin&limit=5" -H "x-app-id: $APP_ID" \
  | jq '.data[] | {question, venue, outcomes: [.venueMarketOutcomes[] | {id, label}]}'

export OUTCOME_ID=...   # a venueMarketOutcomes[].id, for example the "Yes" outcome

const markets = await client.getVenueMarkets({ status: "open", search: "bitcoin", limit: 5 });
const outcomeId = markets.data[0]!.venueMarketOutcomes![0]!.id;

QUOTE=$(curl -s -G "$API/orderbook/$OUTCOME_ID/route" \
  -H "x-app-id: $APP_ID" -H "Authorization: Bearer $ACCESS_TOKEN" \
  --data-urlencode "side=buy" --data-urlencode "maxSpend=5")
echo "$QUOTE" | jq '{quoteId, status, expiresAt, totalFilled, totalCostIncFees, fills: [.fills[] | {venue, avgPrice, venueQty}], warnings}'

export QUOTE_ID=$(echo "$QUOTE" | jq -r .quoteId)

const quote = await client.getSmartRoute({
  venueMarketOutcomeId: outcomeId,
  tradeSide: "buy",
  maxSpend: 5,
});
if (quote.status !== "ok") throw new Error(`${quote.status}: ${quote.message ?? ""}`);

curl -s -X POST $API/execution/fill \
  -H "x-app-id: $APP_ID" -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "content-type: application/json" \
  -d "{ \"quoteId\": \"$QUOTE_ID\" }" | jq

const fill = await client.executeManaged({ quoteId: quote.quoteId });

while :; do
  STATUS=$(curl -s -G $API/execution/status \
    -H "x-app-id: $APP_ID" -H "Authorization: Bearer $ACCESS_TOKEN" \
    --data-urlencode "quoteId=$QUOTE_ID")
  echo "$STATUS" | jq -c '{overallState, terminal}'
  [ "$(echo "$STATUS" | jq -r .terminal)" = "true" ] && break
  sleep 1
done
echo "$STATUS" | jq '{overallState, errorReason, orders: [.orders[] | {venue, status, filledAmountRaw, actualSharesRaw, executionPriceRaw, txHash}]}'

let status = await client.getExecutionStatus({ quoteId: fill.quoteId });
while (!status.terminal) {
  await new Promise((r) => setTimeout(r, status.pollAfterMs ?? 1000));
  status = await client.getExecutionStatus({ quoteId: fill.quoteId });
}
console.log(status.overallState, status.orders);