context-markets-cli 0.1.0

package/dist/orders-IA2XKE5J.js

@@ -0,0 +1,448 @@
+import {
+  formatAddress,
+  formatDate,
+  formatPrice,
+  truncate
+} from "./chunk-IRVQREUN.js";
+import {
+  readClient,
+  tradingClient
+} from "./chunk-BUZKJ7FR.js";
+import {
+  confirmAction,
+  confirmOrder
+} from "./chunk-BJIFIOK6.js";
+import {
+  fail,
+  out,
+  requireFlag,
+  requirePositional
+} from "./chunk-QC6BGRUQ.js";
+
+// src/commands/orders.ts
+var HELP = `Usage: context orders <subcommand> [options]
+
+Subcommands:
+  list                              List orders
+    --trader <address>                Filter by trader (uses readClient)
+    --market <id>                     Filter by market
+    --status <status>                 Filter by status
+    --cursor <token>                  Pagination cursor
+    --limit <n>                       Max results
+
+  mine                              List your own orders (requires signer)
+    --market <id>                     Filter by market
+
+  get <id>                          Get a single order by ID
+
+  recent                            Recent orders (requires signer)
+    --trader <address>                Filter by trader
+    --market <id>                     Filter by market
+    --status <status>                 Filter by status
+    --limit <n>                       Max results
+    --window-seconds <n>              Time window in seconds
+
+  simulate                          Simulate an order (read-only)
+    --market <id>                     (required) Market ID
+    --outcome <yes|no>                Outcome (default: yes)
+    --side <bid|ask>                  Side (default: bid)
+    --price <n>                       Max price
+    --size <n>                        Max size
+    --trader <address>                Trader address
+
+  create                            Place a limit order (requires signer)
+    --market <id>                     (required) Market ID
+    --outcome <yes|no>                (required) Outcome
+    --side <buy|sell>                 (required) Side
+    --price <1-99>                    (required) Price in cents
+    --size <n>                        (required) Size (>=1)
+    --expiry-seconds <n>              Expiry in seconds (optional)
+    --inventory-mode <mode>           any (default), hold (require tokens), mint (mint on fill)
+    --maker-role <role>               any (default), taker (fill-only). Do NOT use maker \u2014 breaks settlement.
+
+  market                            Place a market order (requires signer)
+    --market <id>                     (required) Market ID
+    --outcome <yes|no>                (required) Outcome
+    --side <buy|sell>                 (required) Side
+    --max-price <1-99>                (required) Max price in cents
+    --max-size <n>                    (required) Max size (>=1)
+    --expiry-seconds <n>              Expiry in seconds (optional)
+
+  cancel <nonce>                    Cancel an order by nonce (requires signer)
+
+  cancel-replace <nonce>            Cancel and replace an order (requires signer)
+    (same flags as create)
+
+  bulk-create                       Create multiple orders (requires signer)
+    --orders <json>                   JSON array of PlaceOrderRequest objects
+
+  bulk-cancel                       Cancel multiple orders (requires signer)
+    --nonces <hex,hex,...>            Comma-separated nonces
+
+  bulk                              Create and cancel in one call (requires signer)
+    --creates <json>                  JSON array of PlaceOrderRequest objects
+    --cancels <hex,hex,...>           Comma-separated nonces to cancel
+
+  help                              Show this help text
+
+Global options:
+  --api-key <key>                   Context API key (or CONTEXT_API_KEY env)
+  --private-key <key>               Private key for signing (or CONTEXT_PRIVATE_KEY env)`;
+async function handleOrders(parsed) {
+  const { subcommand, positional, flags } = parsed;
+  switch (subcommand) {
+    case "list":
+      return list(flags);
+    case "mine":
+      return mine(flags);
+    case "get":
+      return get(positional, flags);
+    case "recent":
+      return recent(flags);
+    case "simulate":
+      return simulate(flags);
+    case "create":
+      return create(flags);
+    case "market":
+      return marketOrder(flags);
+    case "cancel":
+      return cancel(positional, flags);
+    case "cancel-replace":
+      return cancelReplace(positional, flags);
+    case "bulk-create":
+      return bulkCreate(flags);
+    case "bulk-cancel":
+      return bulkCancel(flags);
+    case "bulk":
+      return bulk(flags);
+    case "help":
+    case void 0:
+      console.log(HELP);
+      return;
+    default:
+      fail(`Unknown orders subcommand: "${subcommand}". Run "context orders help" for usage.`);
+  }
+}
+var ORDER_LIST_COLUMNS = [
+  { key: "nonce", label: "Nonce", format: (v) => truncate(v, 14) },
+  { key: "marketId", label: "Market", format: (v) => truncate(v, 14) },
+  { key: "side", label: "Side", format: (v) => String(v ?? "\u2014").toUpperCase() },
+  { key: "outcomeIndex", label: "Outcome", format: (v) => v === 1 || v === "1" ? "YES" : "NO" },
+  { key: "price", label: "Price", format: (v) => formatPrice(v) },
+  { key: "size", label: "Size", format: (v) => String(v ?? "\u2014") },
+  { key: "status", label: "Status", format: (v) => String(v ?? "\u2014") },
+  { key: "percentFilled", label: "Filled", format: (v) => v != null ? `${v}%` : "\u2014" }
+];
+async function list(flags) {
+  const ctx = flags["trader"] ? readClient(flags) : tradingClient(flags);
+  const result = await ctx.orders.list({
+    trader: flags["trader"] || void 0,
+    marketId: flags["market"] || void 0,
+    status: flags["status"] || void 0,
+    cursor: flags["cursor"] || void 0,
+    limit: flags["limit"] ? parseInt(flags["limit"], 10) : void 0
+  });
+  out(result, {
+    rows: result.orders || [],
+    columns: ORDER_LIST_COLUMNS,
+    numbered: true,
+    emptyMessage: "No orders found.",
+    cursor: result.cursor || null
+  });
+}
+async function mine(flags) {
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.mine(flags["market"] || void 0);
+  out(result, {
+    rows: result.orders || [],
+    columns: ORDER_LIST_COLUMNS,
+    numbered: true,
+    emptyMessage: "No orders found.",
+    cursor: result.cursor || null
+  });
+}
+async function get(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context orders get <id>");
+  const ctx = readClient(flags);
+  const order = await ctx.orders.get(id);
+  const o = order;
+  out(order, {
+    detail: [
+      ["Nonce", String(o.nonce || "\u2014")],
+      ["Market", String(o.marketId || "\u2014")],
+      ["Status", String(o.status || "\u2014")],
+      ["Side", String(o.side ?? "\u2014").toUpperCase()],
+      ["Outcome", o.outcomeIndex === 1 || o.outcomeIndex === "1" ? "YES" : "NO"],
+      ["Price", formatPrice(o.price)],
+      ["Size", String(o.size || "\u2014")],
+      ["Filled", o.percentFilled != null ? `${o.percentFilled}%` : "\u2014"],
+      ["Trader", formatAddress(o.trader)],
+      ["Created", formatDate(o.insertedAt)]
+    ]
+  });
+}
+async function recent(flags) {
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.recent({
+    trader: flags["trader"] || void 0,
+    marketId: flags["market"] || void 0,
+    status: flags["status"] || void 0,
+    limit: flags["limit"] ? parseInt(flags["limit"], 10) : void 0,
+    windowSeconds: flags["window-seconds"] ? parseInt(flags["window-seconds"], 10) : void 0
+  });
+  out(result, {
+    rows: result.orders || [],
+    columns: ORDER_LIST_COLUMNS,
+    numbered: true,
+    emptyMessage: "No orders found.",
+    cursor: result.cursor || null
+  });
+}
+async function simulate(flags) {
+  const marketId = requireFlag(flags, "market", "context orders simulate --market <id>");
+  const trader = requireFlag(flags, "trader", "context orders simulate --market <id> --trader <address> --size <n> --price <n>");
+  const sizeRaw = requireFlag(flags, "size", "context orders simulate --market <id> --trader <address> --size <n> --price <n>");
+  const priceRaw = requireFlag(flags, "price", "context orders simulate --market <id> --trader <address> --size <n> --price <n>");
+  const outcome = flags["outcome"] ?? "yes";
+  if (outcome !== "yes" && outcome !== "no") {
+    fail("--outcome must be 'yes' or 'no'", { received: outcome });
+  }
+  const side = flags["side"] ?? "bid";
+  if (side !== "bid" && side !== "ask") {
+    fail("--side must be 'bid' or 'ask'", { received: side });
+  }
+  const ctx = readClient(flags);
+  const result = await ctx.orders.simulate({
+    marketId,
+    trader,
+    maxSize: sizeRaw,
+    maxPrice: priceRaw,
+    outcomeIndex: outcome === "yes" ? 1 : 0,
+    side
+  });
+  out(result);
+}
+function parsePlaceOrderFlags(flags, usage) {
+  const marketId = requireFlag(flags, "market", usage);
+  const outcome = requireFlag(flags, "outcome", usage);
+  const side = requireFlag(flags, "side", usage);
+  const priceRaw = requireFlag(flags, "price", usage);
+  const sizeRaw = requireFlag(flags, "size", usage);
+  if (outcome !== "yes" && outcome !== "no") {
+    fail("--outcome must be 'yes' or 'no'", { received: outcome });
+  }
+  if (side !== "buy" && side !== "sell") {
+    fail("--side must be 'buy' or 'sell'", { received: side });
+  }
+  const priceCents = parseInt(priceRaw, 10);
+  if (isNaN(priceCents) || priceCents < 1 || priceCents > 99) {
+    fail("--price must be between 1 and 99 (cents)", { received: priceRaw });
+  }
+  const size = parseFloat(sizeRaw);
+  if (isNaN(size) || size < 1) {
+    fail("--size must be >= 1", { received: sizeRaw });
+  }
+  const INVENTORY_MODES = { any: 0, hold: 1, mint: 2 };
+  const MAKER_ROLES = { any: 0, taker: 2 };
+  let inventoryMode;
+  if (flags["inventory-mode"]) {
+    inventoryMode = INVENTORY_MODES[flags["inventory-mode"]];
+    if (inventoryMode === void 0) {
+      fail("--inventory-mode must be 'any', 'hold', or 'mint'", { received: flags["inventory-mode"] });
+    }
+  }
+  let makerRole;
+  if (flags["maker-role"]) {
+    if (flags["maker-role"] === "maker" || flags["maker-role"] === "1") {
+      fail("makerRoleConstraint=1 (maker/post-only) breaks settlement when two maker-only orders cross \u2014 use 'any' instead", { received: flags["maker-role"] });
+    }
+    makerRole = MAKER_ROLES[flags["maker-role"]];
+    if (makerRole === void 0) {
+      fail("--maker-role must be 'any' or 'taker'", { received: flags["maker-role"] });
+    }
+  }
+  return {
+    marketId,
+    outcome,
+    side,
+    priceCents,
+    size,
+    expirySeconds: flags["expiry-seconds"] ? parseInt(flags["expiry-seconds"], 10) : void 0,
+    inventoryModeConstraint: inventoryMode,
+    makerRoleConstraint: makerRole
+  };
+}
+async function create(flags) {
+  const usage = "context orders create --market <id> --outcome <yes|no> --side <buy|sell> --price <1-99> --size <n>";
+  const order = parsePlaceOrderFlags(flags, usage);
+  await confirmOrder({
+    market: order.marketId,
+    side: order.side,
+    outcome: order.outcome,
+    price: `${order.priceCents}\xA2`,
+    size: String(order.size),
+    estimatedCost: `$${(order.priceCents / 100 * order.size).toFixed(2)} USDC`
+  }, flags);
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.create(order);
+  const r = result;
+  out(result, {
+    detail: [
+      ["Status", r.success ? "\u2713 Order placed" : "\u2717 Failed"],
+      ["Nonce", String(r.order?.nonce || "\u2014")],
+      ["Market", String(r.order?.marketId || "\u2014")],
+      ["Type", String(r.order?.type || "\u2014")],
+      ["Order Status", String(r.order?.status || "\u2014")],
+      ["Filled", r.order?.percentFilled != null ? `${r.order.percentFilled}%` : "\u2014"]
+    ]
+  });
+}
+async function cancel(positional, flags) {
+  const nonce = requirePositional(
+    positional,
+    0,
+    "nonce",
+    "context orders cancel <nonce>"
+  );
+  await confirmAction(`Cancel order ${nonce}?`, flags);
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.cancel(nonce);
+  const r = result;
+  out(result, {
+    detail: [
+      ["Status", r.success ? "\u2713 Cancelled" : "\u2717 Failed"],
+      ["Already Cancelled", String(r.alreadyCancelled ?? "\u2014")]
+    ]
+  });
+}
+async function cancelReplace(positional, flags) {
+  const nonce = requirePositional(
+    positional,
+    0,
+    "nonce",
+    "context orders cancel-replace <nonce> --market <id> --outcome <yes|no> --side <buy|sell> --price <1-99> --size <n>"
+  );
+  const usage = "context orders cancel-replace <nonce> --market <id> --outcome <yes|no> --side <buy|sell> --price <1-99> --size <n>";
+  const newOrder = parsePlaceOrderFlags(flags, usage);
+  await confirmAction(`Cancel order ${nonce} and place replacement?`, flags);
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.cancelReplace(nonce, newOrder);
+  const r = result;
+  out(result, {
+    detail: [
+      ["Cancel", r.cancel?.success ? "\u2713 Cancelled" : "\u2717 Failed"],
+      ["New Order", r.create?.success ? "\u2713 Created" : "\u2717 Failed"],
+      ["New Nonce", String(r.create?.order?.nonce || "\u2014")]
+    ]
+  });
+}
+async function bulkCreate(flags) {
+  const raw = requireFlag(
+    flags,
+    "orders",
+    `context orders bulk-create --orders '[{"marketId":"...","outcome":"yes","side":"buy","priceCents":50,"size":10}]'`
+  );
+  let orders;
+  try {
+    orders = JSON.parse(raw);
+  } catch {
+    fail("--orders must be valid JSON", { received: raw });
+  }
+  if (!Array.isArray(orders)) {
+    fail("--orders must be a JSON array", { received: raw });
+  }
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.bulkCreate(orders);
+  out(result);
+}
+async function bulkCancel(flags) {
+  const raw = requireFlag(
+    flags,
+    "nonces",
+    "context orders bulk-cancel --nonces 0xabc,0xdef"
+  );
+  const nonces = raw.split(",").map((s) => s.trim());
+  if (nonces.length === 0) {
+    fail("--nonces must contain at least one nonce");
+  }
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.bulkCancel(nonces);
+  out(result);
+}
+async function bulk(flags) {
+  const createsRaw = flags["creates"];
+  const cancelsRaw = flags["cancels"];
+  if (!createsRaw && !cancelsRaw) {
+    fail("At least one of --creates or --cancels is required", {
+      usage: "context orders bulk --creates '[...]' --cancels 0xabc,0xdef"
+    });
+  }
+  let creates = [];
+  if (createsRaw) {
+    try {
+      creates = JSON.parse(createsRaw);
+    } catch {
+      fail("--creates must be valid JSON", { received: createsRaw });
+    }
+    if (!Array.isArray(creates)) {
+      fail("--creates must be a JSON array", { received: createsRaw });
+    }
+  }
+  const cancelNonces = cancelsRaw ? cancelsRaw.split(",").map((s) => s.trim()) : [];
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.bulk(creates, cancelNonces);
+  out(result);
+}
+async function marketOrder(flags) {
+  const usage = "context orders market --market <id> --outcome <yes|no> --side <buy|sell> --max-price <1-99> --max-size <n>";
+  const marketId = requireFlag(flags, "market", usage);
+  const outcome = requireFlag(flags, "outcome", usage);
+  const side = requireFlag(flags, "side", usage);
+  const maxPriceRaw = requireFlag(flags, "max-price", usage);
+  const maxSizeRaw = requireFlag(flags, "max-size", usage);
+  if (outcome !== "yes" && outcome !== "no") {
+    fail("--outcome must be 'yes' or 'no'", { received: outcome });
+  }
+  if (side !== "buy" && side !== "sell") {
+    fail("--side must be 'buy' or 'sell'", { received: side });
+  }
+  const maxPriceCents = parseInt(maxPriceRaw, 10);
+  if (isNaN(maxPriceCents) || maxPriceCents < 1 || maxPriceCents > 99) {
+    fail("--max-price must be between 1 and 99 (cents)", { received: maxPriceRaw });
+  }
+  const maxSize = parseFloat(maxSizeRaw);
+  if (isNaN(maxSize) || maxSize < 1) {
+    fail("--max-size must be >= 1", { received: maxSizeRaw });
+  }
+  await confirmOrder({
+    market: marketId,
+    side,
+    outcome,
+    price: `max ${maxPriceCents}\xA2`,
+    size: `max ${maxSize}`,
+    estimatedCost: `up to $${(maxPriceCents / 100 * maxSize).toFixed(2)} USDC`
+  }, flags);
+  const ctx = tradingClient(flags);
+  const result = await ctx.orders.createMarket({
+    marketId,
+    outcome,
+    side,
+    maxPriceCents,
+    maxSize,
+    expirySeconds: flags["expiry-seconds"] ? parseInt(flags["expiry-seconds"], 10) : void 0
+  });
+  const r = result;
+  out(result, {
+    detail: [
+      ["Status", r.success ? "\u2713 Order placed" : "\u2717 Failed"],
+      ["Nonce", String(r.order?.nonce || "\u2014")],
+      ["Market", String(r.order?.marketId || "\u2014")],
+      ["Type", String(r.order?.type || "\u2014")],
+      ["Order Status", String(r.order?.status || "\u2014")],
+      ["Filled", r.order?.percentFilled != null ? `${r.order.percentFilled}%` : "\u2014"]
+    ]
+  });
+}
+export {
+  handleOrders as default
+};

package/dist/portfolio-73RM2RAQ.js

@@ -0,0 +1,147 @@
+import {
+  formatAddress,
+  formatVolume,
+  truncate
+} from "./chunk-IRVQREUN.js";
+import {
+  readClient,
+  tradingClient
+} from "./chunk-BUZKJ7FR.js";
+import {
+  fail,
+  out,
+  requirePositional
+} from "./chunk-QC6BGRUQ.js";
+
+// src/commands/portfolio.ts
+var HELP = `Usage: context portfolio <subcommand> [options]
+
+Subcommands:
+  get                               Get portfolio positions
+    --address <addr>                  Query a specific address (read-only)
+    --kind <all|active|won|lost|claimable>  Filter by position kind
+    --market <id>                     Filter by market
+    --cursor <token>                  Pagination cursor
+    --page-size <n>                   Results per page
+
+  claimable                         Get claimable winnings
+    --address <addr>                  Query a specific address (read-only)
+
+  stats                             Get portfolio statistics
+    --address <addr>                  Query a specific address (read-only)
+
+  balance                           Get account balance
+    --address <addr>                  Query a specific address (read-only)
+
+  token-balance <address> <token-address>
+                                    Get token balance for an address (read-only)
+
+  help                              Show this help text
+
+Client behaviour:
+  If --address is given the command uses a read-only client (no signer needed).
+  Otherwise the trading client is used and the signer's own address is implied.
+
+Global options:
+  --api-key <key>                   Context API key (or CONTEXT_API_KEY env)
+  --private-key <key>               Private key for signing (or CONTEXT_PRIVATE_KEY env)`;
+async function handlePortfolio(parsed) {
+  const { subcommand, positional, flags } = parsed;
+  switch (subcommand) {
+    case "get":
+      return getPortfolio(flags);
+    case "claimable":
+      return claimable(flags);
+    case "stats":
+      return stats(flags);
+    case "balance":
+      return balance(flags);
+    case "token-balance":
+      return tokenBalance(positional, flags);
+    case "help":
+    case void 0:
+      console.log(HELP);
+      return;
+    default:
+      fail(`Unknown portfolio subcommand: "${subcommand}". Run "context portfolio help" for usage.`);
+  }
+}
+function clientFor(flags) {
+  return flags["address"] ? readClient(flags) : tradingClient(flags);
+}
+function addressFlag(flags) {
+  return flags["address"] || void 0;
+}
+async function getPortfolio(flags) {
+  const ctx = clientFor(flags);
+  const address = addressFlag(flags);
+  const result = await ctx.portfolio.get(address, {
+    kind: flags["kind"] || void 0,
+    marketId: flags["market"] || void 0,
+    cursor: flags["cursor"] || void 0,
+    pageSize: flags["page-size"] ? parseInt(flags["page-size"], 10) : void 0
+  });
+  out(result, {
+    rows: result.portfolio || [],
+    columns: [
+      { key: "marketId", label: "Market", format: (v) => truncate(v, 14) },
+      { key: "outcomeName", label: "Outcome", format: (v) => String(v ?? "\u2014") },
+      { key: "balance", label: "Shares", format: formatVolume },
+      { key: "netInvestment", label: "Invested", format: formatVolume },
+      { key: "currentValue", label: "Value", format: formatVolume }
+    ],
+    numbered: true,
+    emptyMessage: "No positions found.",
+    cursor: result.cursor || null
+  });
+}
+async function claimable(flags) {
+  const ctx = clientFor(flags);
+  const address = addressFlag(flags);
+  const result = await ctx.portfolio.claimable(address);
+  const c = result;
+  out(result, {
+    detail: [
+      ["Total Claimable", formatVolume(c.totalClaimable)],
+      ["Positions", String((c.positions || []).length)]
+    ]
+  });
+}
+async function stats(flags) {
+  const ctx = clientFor(flags);
+  const address = addressFlag(flags);
+  const result = await ctx.portfolio.stats(address);
+  out(result);
+}
+async function balance(flags) {
+  const ctx = clientFor(flags);
+  const address = addressFlag(flags);
+  const result = await ctx.portfolio.balance(address);
+  const b = result;
+  out(result, {
+    detail: [
+      ["Address", String(b.address || "\u2014")],
+      ["USDC Balance", formatVolume(b.usdc?.balance)],
+      ["Settlement", formatVolume(b.usdc?.settlementBalance)],
+      ["Wallet", formatVolume(b.usdc?.walletBalance)]
+    ]
+  });
+}
+async function tokenBalance(positional, flags) {
+  const usage = "context portfolio token-balance <address> <token-address>";
+  const address = requirePositional(positional, 0, "address", usage);
+  const tokenAddress = requirePositional(positional, 1, "token-address", usage);
+  const ctx = readClient(flags);
+  const result = await ctx.portfolio.tokenBalance(address, tokenAddress);
+  const tb = result;
+  out(result, {
+    detail: [
+      ["Address", formatAddress(tb.address || tb.owner)],
+      ["Token", formatAddress(tb.token || tb.tokenAddress)],
+      ["Balance", String(tb.balance ?? "\u2014")]
+    ]
+  });
+}
+export {
+  handlePortfolio as default
+};