context-markets-cli 0.1.0 → 0.1.2

package/README.md

@@ -80,8 +80,8 @@ context portfolio get
 | Package | Description |
 |---------|-------------|
 | **[context-markets](https://github.com/contextwtf/context-sdk)** | TypeScript SDK for trading |
-| **[@contextwtf/react](https://github.com/contextwtf/context-react)** | React hooks for market data and trading |
-| **[@contextwtf/mcp](https://github.com/contextwtf/context-mcp)** | MCP server for AI agents |
+| **[context-markets-react](https://github.com/contextwtf/context-react)** | React hooks for market data and trading |
+| **[context-markets-mcp](https://github.com/contextwtf/context-mcp)** | MCP server for AI agents |
 | **[context-markets-cli](https://github.com/contextwtf/context-cli)** | CLI for trading from the terminal |
 | **[context-skills](https://github.com/contextwtf/context-skills)** | AI agent skill files |
 | **[context-plugin](https://github.com/contextwtf/context-plugin)** | Claude Code plugin |

package/dist/account-X5TGY5RX.js

@@ -0,0 +1,207 @@
+import {
+  formatAddress,
+  formatMoney,
+  truncate
+} from "./chunk-IRVQREUN.js";
+import {
+  tradingClient
+} from "./chunk-Q7JYRQZG.js";
+import {
+  fail,
+  out,
+  requirePositional
+} from "./chunk-QC6BGRUQ.js";
+
+// src/commands/account.ts
+var HELP = `Usage: context account <subcommand> [options]
+
+Subcommands:
+  status                            Check wallet status (balances, approvals)
+  setup                             Approve contracts for gasless trading
+  mint-test-usdc                    Mint test USDC on testnet
+    --amount <n>                      Amount to mint (default: 1000)
+
+  deposit <amount>                  Deposit USDC into the exchange
+  withdraw <amount>                 Withdraw USDC from the exchange
+
+  mint-complete-sets <market-id> <amount>
+                                    Mint complete sets of outcome tokens
+  burn-complete-sets <market-id> <amount>
+                                    Burn complete sets of outcome tokens
+    --credit-internal <true|false>    Credit internal balance (default: true)
+
+  help                              Show this help text
+
+All account commands require a signer (--private-key or CONTEXT_PRIVATE_KEY).
+
+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 handleAccount(parsed) {
+  const { subcommand, positional, flags } = parsed;
+  switch (subcommand) {
+    case "status":
+      return status(flags);
+    case "setup":
+      return setup(flags);
+    case "mint-test-usdc":
+      return mintTestUsdc(flags);
+    case "deposit":
+      return deposit(positional, flags);
+    case "withdraw":
+      return withdraw(positional, flags);
+    case "mint-complete-sets":
+      return mintCompleteSets(positional, flags);
+    case "burn-complete-sets":
+      return burnCompleteSets(positional, flags);
+    case "relay-operator-approval":
+      return fail(
+        "Use `context gasless-approve` for gasless operator approval."
+      );
+    case "relay-deposit":
+      return fail(
+        "Use `context gasless-deposit <amount>` for gasless deposit."
+      );
+    case "help":
+    case void 0:
+      console.log(HELP);
+      return;
+    default:
+      fail(
+        `Unknown account subcommand: "${subcommand}". Run "context account help" for usage.`
+      );
+  }
+}
+async function status(flags) {
+  const ctx = tradingClient(flags);
+  const result = await ctx.account.status();
+  const s = result;
+  out(result, {
+    detail: [
+      ["Address", formatAddress(s.address)],
+      ["ETH Balance", s.ethBalance || "\u2014"],
+      ["USDC Allowance", s.usdcAllowance ? "\u2713 Approved" : "\u2717 None"],
+      ["Operator", s.isOperatorApproved ? "\u2713 Approved" : "\u2717 Not approved"],
+      ["Needs Setup", s.needsApprovals ? "Yes \u2014 run `context setup`" : "No"]
+    ]
+  });
+}
+async function setup(flags) {
+  const ctx = tradingClient(flags);
+  const result = await ctx.account.setup();
+  out(result, {
+    detail: [
+      ["Status", "\u2713 Contracts approved"]
+    ]
+  });
+}
+async function mintTestUsdc(flags) {
+  const amountRaw = flags["amount"];
+  let amount;
+  if (amountRaw) {
+    amount = parseFloat(amountRaw);
+    if (isNaN(amount) || amount <= 0) {
+      fail("--amount must be a positive number", { received: amountRaw });
+    }
+  }
+  const ctx = tradingClient(flags);
+  const result = await ctx.account.mintTestUsdc(amount);
+  const r = result;
+  out(result, {
+    detail: [
+      ["Status", "\u2713 Minted"],
+      ["Amount", formatMoney(r.amount ?? amount)],
+      ["Tx Hash", formatAddress(r.txHash || r.tx_hash)]
+    ]
+  });
+}
+async function deposit(positional, flags) {
+  const raw = requirePositional(
+    positional,
+    0,
+    "amount",
+    "context account deposit <amount>"
+  );
+  const amount = parseFloat(raw);
+  if (isNaN(amount) || amount <= 0) {
+    fail("Deposit amount must be a positive number", { received: raw });
+  }
+  const ctx = tradingClient(flags);
+  const txHash = await ctx.account.deposit(amount);
+  out({ status: "deposited", amount_usdc: amount, tx_hash: txHash }, {
+    detail: [
+      ["Status", "\u2713 Deposited"],
+      ["Amount", formatMoney(amount)],
+      ["Tx Hash", formatAddress(txHash)]
+    ]
+  });
+}
+async function withdraw(positional, flags) {
+  const raw = requirePositional(
+    positional,
+    0,
+    "amount",
+    "context account withdraw <amount>"
+  );
+  const amount = parseFloat(raw);
+  if (isNaN(amount) || amount <= 0) {
+    fail("Withdraw amount must be a positive number", { received: raw });
+  }
+  const ctx = tradingClient(flags);
+  const txHash = await ctx.account.withdraw(amount);
+  out({ status: "withdrawn", amount_usdc: amount, tx_hash: txHash }, {
+    detail: [
+      ["Status", "\u2713 Withdrawn"],
+      ["Amount", formatMoney(amount)],
+      ["Tx Hash", formatAddress(txHash)]
+    ]
+  });
+}
+async function mintCompleteSets(positional, flags) {
+  const usage = "context account mint-complete-sets <market-id> <amount>";
+  const marketId = requirePositional(positional, 0, "market-id", usage);
+  const amountRaw = requirePositional(positional, 1, "amount", usage);
+  const amount = parseFloat(amountRaw);
+  if (isNaN(amount) || amount <= 0) {
+    fail("Amount must be a positive number", { received: amountRaw });
+  }
+  const ctx = tradingClient(flags);
+  const txHash = await ctx.account.mintCompleteSets(marketId, amount);
+  out({ status: "minted", market_id: marketId, amount, tx_hash: txHash }, {
+    detail: [
+      ["Status", "\u2713 Minted complete sets"],
+      ["Market", truncate(marketId, 20)],
+      ["Amount", String(amount)],
+      ["Tx Hash", formatAddress(txHash)]
+    ]
+  });
+}
+async function burnCompleteSets(positional, flags) {
+  const usage = "context account burn-complete-sets <market-id> <amount>";
+  const marketId = requirePositional(positional, 0, "market-id", usage);
+  const amountRaw = requirePositional(positional, 1, "amount", usage);
+  const amount = parseFloat(amountRaw);
+  if (isNaN(amount) || amount <= 0) {
+    fail("Amount must be a positive number", { received: amountRaw });
+  }
+  const creditInternalRaw = flags["credit-internal"];
+  const creditInternal = creditInternalRaw !== "false";
+  const ctx = tradingClient(flags);
+  const txHash = await ctx.account.burnCompleteSets(
+    marketId,
+    amount,
+    creditInternal
+  );
+  out({ status: "burned", market_id: marketId, amount, credit_internal: creditInternal, tx_hash: txHash }, {
+    detail: [
+      ["Status", "\u2713 Burned complete sets"],
+      ["Market", truncate(marketId, 20)],
+      ["Amount", String(amount)],
+      ["Credit Internal", String(creditInternal)],
+      ["Tx Hash", formatAddress(txHash)]
+    ]
+  });
+}
+export {
+  handleAccount as default
+};

package/dist/chunk-Q7JYRQZG.js

@@ -0,0 +1,45 @@
+import {
+  fail
+} from "./chunk-QC6BGRUQ.js";
+
+// src/client.ts
+import { ContextClient } from "context-markets";
+function resolveChain(flags) {
+  const raw = flags.chain ?? process.env.CONTEXT_CHAIN;
+  if (!raw) return void 0;
+  return raw;
+}
+function readClient(flags = {}) {
+  const apiKey = flags["api-key"] ?? process.env.CONTEXT_API_KEY;
+  if (!apiKey) fail("Missing CONTEXT_API_KEY env var or --api-key flag");
+  const rpcUrl = flags["rpc-url"] ?? process.env.CONTEXT_RPC_URL;
+  const baseUrl = flags["base-url"] ?? process.env.CONTEXT_BASE_URL;
+  const chain = resolveChain(flags);
+  return new ContextClient({ apiKey, rpcUrl, baseUrl, chain });
+}
+function tradingClient(flags = {}) {
+  const apiKey = flags["api-key"] ?? process.env.CONTEXT_API_KEY;
+  if (!apiKey) fail("Missing CONTEXT_API_KEY env var or --api-key flag");
+  const privateKey = flags["private-key"] ?? process.env.CONTEXT_PRIVATE_KEY;
+  if (!privateKey) {
+    fail(
+      "A private key is required for trading operations.",
+      { hint: "Set CONTEXT_PRIVATE_KEY env var or pass --private-key <key>" }
+    );
+  }
+  const rpcUrl = flags["rpc-url"] ?? process.env.CONTEXT_RPC_URL;
+  const baseUrl = flags["base-url"] ?? process.env.CONTEXT_BASE_URL;
+  const chain = resolveChain(flags);
+  return new ContextClient({
+    apiKey,
+    rpcUrl,
+    baseUrl,
+    chain,
+    signer: { privateKey }
+  });
+}
+
+export {
+  readClient,
+  tradingClient
+};

package/dist/cli.js

@@ -31,6 +31,7 @@ Options:
   --api-key <key>                 Context API key (or CONTEXT_API_KEY env)
   --private-key <key>             Private key (or CONTEXT_PRIVATE_KEY env)
   --rpc-url <url>                 Base Sepolia RPC URL (or CONTEXT_RPC_URL env)
+  --chain <chain>                 Target chain (or CONTEXT_CHAIN env, default: mainnet)
   --yes                           Skip confirmations (for automation)
 
 Run "context help" for this message, or "context <command> help" for details.`;
@@ -88,34 +89,34 @@ async function main() {
   const parsed = parseArgs(process.argv);
   setOutputMode(parsed.flags);
   if (parsed.command === "help" && process.stdout.isTTY && process.stdin.isTTY) {
-    const { runShell } = await import("./shell-XBM2FEIR.js");
+    const { runShell } = await import("./shell-HLJLCIUW.js");
     await runShell();
     return;
   }
   try {
     switch (parsed.command) {
       case "markets": {
-        const mod = await import("./markets-WZCKLKJR.js");
+        const mod = await import("./markets-WZG67OAH.js");
         await mod.default(parsed);
         break;
       }
       case "questions": {
-        const mod = await import("./questions-P6AUM6D4.js");
+        const mod = await import("./questions-NJZXH3AZ.js");
         await mod.default(parsed);
         break;
       }
       case "orders": {
-        const mod = await import("./orders-IA2XKE5J.js");
+        const mod = await import("./orders-KGS5MLNX.js");
         await mod.default(parsed);
         break;
       }
       case "portfolio": {
-        const mod = await import("./portfolio-73RM2RAQ.js");
+        const mod = await import("./portfolio-2R52VSBA.js");
         await mod.default(parsed);
         break;
       }
       case "account": {
-        const mod = await import("./account-DL4WGQCC.js");
+        const mod = await import("./account-X5TGY5RX.js");
         await mod.default(parsed);
         break;
       }
@@ -124,7 +125,7 @@ async function main() {
       case "deposit":
       case "gasless-approve":
       case "gasless-deposit": {
-        const mod = await import("./setup-KDTGKF6O.js");
+        const mod = await import("./setup-STVAAHHF.js");
         const positional = parsed.subcommand ? [parsed.subcommand, ...parsed.positional] : parsed.positional;
         await mod.default({ ...parsed, subcommand: parsed.command, positional });
         break;
@@ -135,7 +136,7 @@ async function main() {
         break;
       }
       case "shell": {
-        const { runShell } = await import("./shell-XBM2FEIR.js");
+        const { runShell } = await import("./shell-HLJLCIUW.js");
         await runShell();
         break;
       }

package/dist/markets-WZG67OAH.js

@@ -0,0 +1,313 @@
+import {
+  formatAddress,
+  formatDate,
+  formatPrice,
+  formatVolume,
+  truncate
+} from "./chunk-IRVQREUN.js";
+import {
+  readClient,
+  tradingClient
+} from "./chunk-Q7JYRQZG.js";
+import {
+  fail,
+  out,
+  requireFlag,
+  requirePositional
+} from "./chunk-QC6BGRUQ.js";
+
+// src/commands/markets.ts
+var HELP = `Usage: context markets <subcommand> [options]
+
+Subcommands:
+  list                              Browse markets
+    --status <status>                 Filter by status
+    --limit <n>                       Max results
+    --sort-by <field>                 Sort field
+    --sort <asc|desc>                 Sort direction
+    --visibility <value>              Visibility filter
+    --resolution-status <value>       Resolution status filter
+    --creator <address>               Filter by creator
+    --category <slug>                 Filter by category
+    --cursor <token>                  Pagination cursor
+
+  search <query>                    Search markets by text
+    --limit <n>                       Max results (default: 10)
+    --offset <n>                      Offset for pagination
+
+  get <id>                          Get a single market by ID
+  quotes <id>                       Current quotes for a market
+  orderbook <id>                    Full orderbook (YES and NO sides)
+    --depth <n>                       Number of price levels
+
+  simulate <id>                     Simulate a trade
+    --side <yes|no>                   (required) Trade side
+    --amount <n>                      (required) Trade amount
+    --amount-type <usd|contracts>     Amount type (default: usd)
+    --trader <address>                Trader address
+
+  price-history <id>                Price history for a market
+    --timeframe <1h|6h|1d|1w|1M|all> Timeframe
+
+  oracle <id>                       Oracle info for a market
+  oracle-quotes <id>                Oracle quotes for a market
+  request-oracle-quote <id>         Request a new oracle quote
+
+  activity <id>                     Activity feed for a market
+    --limit <n>                       Max results
+    --cursor <token>                  Pagination cursor
+
+  global-activity                   Global activity feed
+    --limit <n>                       Max results
+    --cursor <token>                  Pagination cursor
+
+  create <questionId>               Create a market from a generated question ID
+
+  help                              Show this help text
+
+Global options:
+  --api-key <key>                   Context API key (or CONTEXT_API_KEY env)`;
+async function handleMarkets(parsed) {
+  const { subcommand, positional, flags } = parsed;
+  switch (subcommand) {
+    case "list":
+      return list(flags);
+    case "search":
+      return search(positional, flags);
+    case "get":
+      return get(positional, flags);
+    case "quotes":
+      return quotes(positional, flags);
+    case "orderbook":
+      return orderbook(positional, flags);
+    case "simulate":
+      return simulate(positional, flags);
+    case "price-history":
+      return priceHistory(positional, flags);
+    case "oracle":
+      return oracle(positional, flags);
+    case "oracle-quotes":
+      return oracleQuotes(positional, flags);
+    case "request-oracle-quote":
+      return requestOracleQuote(positional, flags);
+    case "activity":
+      return activity(positional, flags);
+    case "global-activity":
+      return globalActivity(flags);
+    case "create":
+      return create(positional, flags);
+    case "help":
+    case void 0:
+      console.log(HELP);
+      return;
+    default:
+      fail(`Unknown markets subcommand: "${subcommand}". Run "context markets help" for usage.`);
+  }
+}
+async function list(flags) {
+  const ctx = readClient(flags);
+  const result = await ctx.markets.list({
+    status: flags["status"] || void 0,
+    sortBy: flags["sort-by"] || void 0,
+    sort: flags["sort"] || void 0,
+    limit: flags["limit"] ? parseInt(flags["limit"], 10) : void 0,
+    cursor: flags["cursor"] || void 0,
+    visibility: flags["visibility"] || void 0,
+    resolutionStatus: flags["resolution-status"] || void 0,
+    creator: flags["creator"] || void 0,
+    category: flags["category"] || void 0
+  });
+  out(result, {
+    rows: result.markets || [],
+    columns: [
+      { key: "shortQuestion", label: "Question", format: (v) => truncate(v, 34) },
+      { key: "outcomePrices[1].buyPrice", label: "Yes", format: formatPrice },
+      { key: "outcomePrices[0].buyPrice", label: "No", format: formatPrice },
+      { key: "volume", label: "Volume", format: formatVolume },
+      { key: "status", label: "Status", format: (v) => String(v ?? "\u2014") }
+    ],
+    numbered: true,
+    emptyMessage: "No markets found.",
+    cursor: result.cursor || null
+  });
+}
+async function search(positional, flags) {
+  const q = requirePositional(positional, 0, "query", "context markets search <query>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.search({
+    q,
+    limit: flags["limit"] ? parseInt(flags["limit"], 10) : void 0,
+    offset: flags["offset"] ? parseInt(flags["offset"], 10) : void 0
+  });
+  out(result, {
+    rows: result.markets || [],
+    columns: [
+      { key: "shortQuestion", label: "Question", format: (v) => truncate(v, 34) },
+      { key: "outcomePrices[1].currentPrice", label: "Yes", format: formatPrice },
+      { key: "outcomePrices[0].currentPrice", label: "No", format: formatPrice },
+      { key: "volume", label: "Volume", format: formatVolume },
+      { key: "status", label: "Status", format: (v) => String(v ?? "\u2014") }
+    ],
+    numbered: true,
+    emptyMessage: "No markets found."
+  });
+}
+async function get(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets get <id>");
+  const ctx = readClient(flags);
+  const market = await ctx.markets.get(id);
+  const m = market;
+  out(market, {
+    detail: [
+      ["ID", String(m.id || "\u2014")],
+      ["Question", String(m.question || m.shortQuestion || "\u2014")],
+      ["Status", String(m.status || "\u2014")],
+      ["Yes", m.outcomePrices?.[1] ? `${formatPrice(m.outcomePrices[1].bestBid)} bid / ${formatPrice(m.outcomePrices[1].bestAsk)} ask` : "\u2014"],
+      ["No", m.outcomePrices?.[0] ? `${formatPrice(m.outcomePrices[0].bestBid)} bid / ${formatPrice(m.outcomePrices[0].bestAsk)} ask` : "\u2014"],
+      ["Volume", formatVolume(m.volume)],
+      ["24h Volume", formatVolume(m.volume24h)],
+      ["Participants", String(m.participantCount ?? "\u2014")],
+      ["Deadline", formatDate(m.deadline)],
+      ["Creator", formatAddress(m.creator || m.metadata?.creator)]
+    ]
+  });
+}
+async function quotes(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets quotes <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.quotes(id);
+  const q = result;
+  out(result, {
+    detail: [
+      ["Market", String(q.marketId || "\u2014")],
+      ["Yes", `${formatPrice(q.yes?.bid)} bid / ${formatPrice(q.yes?.ask)} ask / ${formatPrice(q.yes?.last)} last`],
+      ["No", `${formatPrice(q.no?.bid)} bid / ${formatPrice(q.no?.ask)} ask / ${formatPrice(q.no?.last)} last`],
+      ["Spread", q.spread != null ? `${formatPrice(q.spread)}` : "\u2014"]
+    ]
+  });
+}
+async function orderbook(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets orderbook <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.fullOrderbook(id, {
+    depth: flags["depth"] ? parseInt(flags["depth"], 10) : void 0
+  });
+  const ob = result;
+  out(result, {
+    detail: [
+      ["Market", String(ob.marketId || "\u2014")],
+      ["Yes Bids", (ob.yes?.bids || []).map((l) => `${formatPrice(l.price)} \xD7 ${l.size}`).join(", ") || "\u2014"],
+      ["Yes Asks", (ob.yes?.asks || []).map((l) => `${formatPrice(l.price)} \xD7 ${l.size}`).join(", ") || "\u2014"],
+      ["No Bids", (ob.no?.bids || []).map((l) => `${formatPrice(l.price)} \xD7 ${l.size}`).join(", ") || "\u2014"],
+      ["No Asks", (ob.no?.asks || []).map((l) => `${formatPrice(l.price)} \xD7 ${l.size}`).join(", ") || "\u2014"]
+    ]
+  });
+}
+async function simulate(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets simulate <id> --side <yes|no> --amount <n>");
+  const side = requireFlag(flags, "side", "context markets simulate <id> --side <yes|no> --amount <n>");
+  const amountRaw = requireFlag(flags, "amount", "context markets simulate <id> --side <yes|no> --amount <n>");
+  if (side !== "yes" && side !== "no") {
+    fail("--side must be 'yes' or 'no'", { received: side });
+  }
+  const amount = parseFloat(amountRaw);
+  if (isNaN(amount) || amount <= 0) {
+    fail("--amount must be a positive number", { received: amountRaw });
+  }
+  const ctx = readClient(flags);
+  const result = await ctx.markets.simulate(id, {
+    side,
+    amount,
+    amountType: flags["amount-type"] === "contracts" ? "contracts" : "usd",
+    trader: flags["trader"] || void 0
+  });
+  const sim = result;
+  out(result, {
+    detail: [
+      ["Market", String(sim.marketId || "\u2014")],
+      ["Side", String(sim.side || "\u2014")],
+      ["Amount", String(sim.amount ?? "\u2014")],
+      ["Est. Contracts", String(sim.estimatedContracts ?? "\u2014")],
+      ["Avg Price", formatPrice(sim.estimatedAvgPrice)],
+      ["Slippage", sim.estimatedSlippage != null ? `${(sim.estimatedSlippage * 100).toFixed(1)}%` : "\u2014"]
+    ]
+  });
+}
+async function priceHistory(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets price-history <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.priceHistory(id, {
+    timeframe: flags["timeframe"] || void 0
+  });
+  out(result);
+}
+async function oracle(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets oracle <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.oracle(id);
+  out(result);
+}
+async function oracleQuotes(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets oracle-quotes <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.oracleQuotes(id);
+  out(result);
+}
+async function requestOracleQuote(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets request-oracle-quote <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.requestOracleQuote(id);
+  out(result);
+}
+async function activity(positional, flags) {
+  const id = requirePositional(positional, 0, "id", "context markets activity <id>");
+  const ctx = readClient(flags);
+  const result = await ctx.markets.activity(id, {
+    limit: flags["limit"] ? parseInt(flags["limit"], 10) : void 0,
+    cursor: flags["cursor"] || void 0
+  });
+  const act = result;
+  out(result, {
+    rows: act.activity || [],
+    columns: [
+      { key: "type", label: "Type" },
+      { key: "timestamp", label: "Time", format: formatDate }
+    ],
+    numbered: true,
+    emptyMessage: "No activity found.",
+    cursor: act.pagination?.cursor || null
+  });
+}
+async function globalActivity(flags) {
+  const ctx = readClient(flags);
+  const result = await ctx.markets.globalActivity({
+    limit: flags["limit"] ? parseInt(flags["limit"], 10) : void 0,
+    cursor: flags["cursor"] || void 0
+  });
+  const act = result;
+  out(result, {
+    rows: act.activity || [],
+    columns: [
+      { key: "type", label: "Type" },
+      { key: "timestamp", label: "Time", format: formatDate }
+    ],
+    numbered: true,
+    emptyMessage: "No activity found.",
+    cursor: act.pagination?.cursor || null
+  });
+}
+async function create(positional, flags) {
+  const questionId = requirePositional(positional, 0, "questionId", "context markets create <questionId>");
+  const ctx = tradingClient(flags);
+  const result = await ctx.markets.create(questionId);
+  const r = result;
+  out(result, {
+    detail: [
+      ["Market ID", String(r.marketId || "\u2014")],
+      ["Tx Hash", String(r.txHash || "\u2014")]
+    ]
+  });
+}
+export {
+  handleMarkets as default
+};