polytown 0.1.0

package/dist/index.js

@@ -0,0 +1,2056 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/status.ts
+import { Command } from "commander";
+
+// src/lib/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".polytown");
+var CONFIG_ENV_PATH = join(CONFIG_DIR, ".env");
+function loadEnvFile(path) {
+  if (!existsSync(path)) return;
+  const content = readFileSync(path, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+var LOCAL_ENV_PATH = join(process.cwd(), ".env");
+loadEnvFile(LOCAL_ENV_PATH);
+loadEnvFile(CONFIG_ENV_PATH);
+var POLYGON_CHAIN_ID = Number(process.env.POLYMARKET_CHAIN_ID || "137");
+var RPC_URL = process.env.POLYMARKET_RPC_URL || "https://polygon.drpc.org";
+var CLOB_URL = process.env.POLYMARKET_CLOB_URL || "https://proxy.polytown.app";
+var GAMMA_URL = process.env.POLYMARKET_GAMMA_URL || "https://gamma-api.polymarket.com";
+var DATA_URL = process.env.POLYMARKET_DATA_URL || "https://data-api.polymarket.com";
+var BRIDGE_URL = process.env.POLYMARKET_BRIDGE_URL || "https://bridge-api.polymarket.com";
+var RELAYER_URL = process.env.POLYMARKET_RELAYER_URL || "https://proxy.polytown.app/relayer";
+function resolvePrivateKey(flag) {
+  const key = flag || process.env.POLYMARKET_PRIVATE_KEY;
+  if (!key) {
+    throw new Error(
+      "No wallet configured. Run `polytown setup` to create or import a wallet."
+    );
+  }
+  const normalized = key.startsWith("0x") ? key : `0x${key}`;
+  return normalized;
+}
+
+// src/commands/status.ts
+async function check(name, url) {
+  const start = Date.now();
+  try {
+    const res = await fetch(url);
+    const latency = Date.now() - start;
+    return { name, status: res.ok ? "ok" : `error (${res.status})`, latency };
+  } catch (e) {
+    return { name, status: `error (${e.message})`, latency: Date.now() - start };
+  }
+}
+var statusCommand = new Command("status").description("API health checks").action(async () => {
+  const results = await Promise.all([
+    check("CLOB", `${CLOB_URL}/`),
+    check("Gamma", `${GAMMA_URL}/status`),
+    check("Data", `${DATA_URL}/`),
+    check("RPC", RPC_URL)
+  ]);
+  console.log(JSON.stringify(results, null, 2));
+});
+
+// src/commands/markets.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/gamma.ts
+function buildUrl(base, path, params) {
+  const url = new URL(path, base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          if (v !== void 0) {
+            url.searchParams.append(key, String(v));
+          }
+        }
+      } else if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+async function fetchJson(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}: ${res.statusText} \u2014 ${url}`);
+  }
+  return res.json();
+}
+var GammaClient = class {
+  constructor(baseUrl = GAMMA_URL) {
+    this.baseUrl = baseUrl;
+  }
+  // Markets
+  async getMarkets(params) {
+    return fetchJson(buildUrl(this.baseUrl, "/markets", params));
+  }
+  async getMarket(idOrSlug) {
+    if (/^\d+$/.test(idOrSlug)) {
+      return fetchJson(buildUrl(this.baseUrl, `/markets/${idOrSlug}`));
+    }
+    const results = await fetchJson(buildUrl(this.baseUrl, "/markets", { slug: idOrSlug }));
+    return Array.isArray(results) ? results[0] : results;
+  }
+  async searchMarkets(query, params) {
+    return fetchJson(
+      buildUrl(this.baseUrl, "/markets", { text_query: query, ...params })
+    );
+  }
+  // Events
+  async getEvents(params) {
+    return fetchJson(buildUrl(this.baseUrl, "/events", params));
+  }
+  async getEvent(idOrSlug) {
+    return fetchJson(buildUrl(this.baseUrl, `/events/${idOrSlug}`));
+  }
+  // Tags
+  async getTags(params) {
+    return fetchJson(buildUrl(this.baseUrl, "/tags", params));
+  }
+  async getTag(idOrSlug) {
+    return fetchJson(buildUrl(this.baseUrl, `/tags/${idOrSlug}`));
+  }
+  async getRelated(idOrSlug) {
+    return fetchJson(buildUrl(this.baseUrl, `/tags/${idOrSlug}/related`));
+  }
+  async getRelatedTags(idOrSlug) {
+    return fetchJson(buildUrl(this.baseUrl, `/tags/${idOrSlug}/related-tags`));
+  }
+  // Series
+  async getSeries(params) {
+    return fetchJson(buildUrl(this.baseUrl, "/series", params));
+  }
+  async getSeriesById(id) {
+    return fetchJson(buildUrl(this.baseUrl, `/series/${id}`));
+  }
+  // Comments
+  async getComments(params) {
+    return fetchJson(
+      buildUrl(this.baseUrl, "/comments", params)
+    );
+  }
+  async getComment(id) {
+    return fetchJson(buildUrl(this.baseUrl, `/comments/${id}`));
+  }
+  async getCommentsByUser(address, params) {
+    return fetchJson(
+      buildUrl(this.baseUrl, `/comments/user_address/${address}`, params)
+    );
+  }
+  // Profiles
+  async getProfile(address) {
+    return fetchJson(`https://polymarket.com/api/profile/userData?address=${address}`);
+  }
+  async getProfileStats(proxyAddress) {
+    return fetchJson(`https://data-api.polymarket.com/v1/user-stats?proxyAddress=${proxyAddress}`);
+  }
+  // Sports
+  async getSports() {
+    return fetchJson(buildUrl(this.baseUrl, "/sports"));
+  }
+  async getMarketTypes() {
+    return fetchJson(buildUrl(this.baseUrl, "/sports/market-types"));
+  }
+  async getTeams(params) {
+    return fetchJson(
+      buildUrl(this.baseUrl, "/sports/teams", params)
+    );
+  }
+  // Health
+  async getStatus() {
+    const res = await fetch(buildUrl(this.baseUrl, "/status"));
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    const text = await res.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+};
+
+// src/commands/markets.ts
+var marketsCommand = new Command2("markets").description(
+  "Markets commands"
+);
+marketsCommand.command("list").description("List markets").option("--active", "Only active markets").option("--closed", "Only closed markets").option("--cyom", "Filter by create-your-own-market").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).option("--order <field>", "Order by field").option("--ascending", "Sort ascending").option("--id <ids>", "Filter by market IDs (comma-separated)").option("--slug <slugs>", "Filter by slug(s)").option("--clob-token-ids <ids>", "Filter by CLOB token IDs").option("--condition-ids <ids>", "Filter by condition IDs").option("--tag-id <id>", "Filter by tag ID", parseInt).option("--related-tags", "Include related tags").option("--include-tag", "Include tag data").option("--liquidity-min <n>", "Min liquidity", parseFloat).option("--liquidity-max <n>", "Max liquidity", parseFloat).option("--volume-min <n>", "Min volume", parseFloat).option("--volume-max <n>", "Max volume", parseFloat).option("--start-date-min <date>", "Earliest start date").option("--start-date-max <date>", "Latest start date").option("--end-date-min <date>", "Earliest end date").option("--end-date-max <date>", "Latest end date").option("--uma-resolution-status <status>", "UMA resolution status").option("--game-id <id>", "Filter by game ID").option("--sports-market-types <types>", "Filter by sports market types").option("--rewards-min-size <n>", "Min rewards size", parseFloat).option("--question-ids <ids>", "Filter by question IDs").action(async (opts) => {
+  const gamma = new GammaClient();
+  const params = {
+    active: opts.active ?? true,
+    closed: opts.closed ?? false,
+    order: opts.order ?? "volume24hr",
+    ascending: opts.ascending ?? false
+  };
+  if (opts.cyom) params.cyom = true;
+  if (opts.limit) params.limit = opts.limit;
+  if (opts.offset) params.offset = opts.offset;
+  if (opts.id) params.id = opts.id;
+  if (opts.slug) params.slug = opts.slug;
+  if (opts.clobTokenIds) params.clob_token_ids = opts.clobTokenIds;
+  if (opts.conditionIds) params.condition_ids = opts.conditionIds;
+  if (opts.tagId) params.tag_id = opts.tagId;
+  if (opts.relatedTags) params.related_tags = true;
+  if (opts.includeTag) params.include_tag = true;
+  if (opts.liquidityMin) params.liquidity_num_min = opts.liquidityMin;
+  if (opts.liquidityMax) params.liquidity_num_max = opts.liquidityMax;
+  if (opts.volumeMin) params.volume_num_min = opts.volumeMin;
+  if (opts.volumeMax) params.volume_num_max = opts.volumeMax;
+  if (opts.startDateMin) params.start_date_min = opts.startDateMin;
+  if (opts.startDateMax) params.start_date_max = opts.startDateMax;
+  if (opts.endDateMin) params.end_date_min = opts.endDateMin;
+  if (opts.endDateMax) params.end_date_max = opts.endDateMax;
+  if (opts.umaResolutionStatus) params.uma_resolution_status = opts.umaResolutionStatus;
+  if (opts.gameId) params.game_id = opts.gameId;
+  if (opts.sportsMarketTypes) params.sports_market_types = opts.sportsMarketTypes;
+  if (opts.rewardsMinSize) params.rewards_min_size = opts.rewardsMinSize;
+  if (opts.questionIds) params.question_ids = opts.questionIds;
+  const result = await gamma.getMarkets(params);
+  console.log(JSON.stringify(result, null, 2));
+});
+marketsCommand.command("get <id_or_slug>").description("Get market by ID or slug").action(async (idOrSlug) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getMarket(idOrSlug);
+  console.log(JSON.stringify(result, null, 2));
+});
+marketsCommand.command("search <query>").description("Search markets").option("--limit <n>", "Limit results", parseInt).action(async (query, opts) => {
+  const gamma = new GammaClient();
+  const result = await gamma.searchMarkets(query, opts);
+  console.log(JSON.stringify(result, null, 2));
+});
+
+// src/commands/events.ts
+import { Command as Command3 } from "commander";
+var eventsCommand = new Command3("events").description(
+  "Events commands"
+);
+eventsCommand.command("list").description("List events").option("--active", "Only active events").option("--closed", "Only closed events").option("--archived", "Include archived events").option("--featured", "Only featured events").option("--cyom", "Filter by create-your-own-market").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).option("--order <field>", "Order by field").option("--ascending", "Sort ascending").option("--id <ids>", "Filter by event IDs (comma-separated)").option("--tag <tag>", "Filter by tag slug").option("--tag-id <id>", "Filter by tag ID", parseInt).option("--exclude-tag-id <ids>", "Exclude tag IDs (comma-separated)").option("--slug <slugs>", "Filter by slug(s)").option("--related-tags", "Include related tags").option("--recurrence <pattern>", "Filter by recurrence pattern").option("--liquidity-min <n>", "Min liquidity", parseFloat).option("--liquidity-max <n>", "Max liquidity", parseFloat).option("--volume-min <n>", "Min volume", parseFloat).option("--volume-max <n>", "Max volume", parseFloat).option("--start-date-min <date>", "Earliest start date").option("--start-date-max <date>", "Latest start date").option("--end-date-min <date>", "Earliest end date").option("--end-date-max <date>", "Latest end date").action(async (opts) => {
+  const gamma = new GammaClient();
+  const params = {
+    active: opts.active ?? true,
+    closed: opts.closed ?? false,
+    archived: opts.archived ?? false,
+    order: opts.order ?? "volume24hr",
+    ascending: opts.ascending ?? false
+  };
+  if (opts.featured) params.featured = true;
+  if (opts.cyom) params.cyom = true;
+  if (opts.limit) params.limit = opts.limit;
+  if (opts.offset) params.offset = opts.offset;
+  if (opts.id) params.id = opts.id;
+  if (opts.tag) params.tag_slug = opts.tag;
+  if (opts.tagId) params.tag_id = opts.tagId;
+  if (opts.excludeTagId) params.exclude_tag_id = opts.excludeTagId.split(",");
+  if (opts.slug) params.slug = opts.slug;
+  if (opts.relatedTags) params.related_tags = true;
+  if (opts.recurrence) params.recurrence = opts.recurrence;
+  if (opts.liquidityMin) params.liquidity_min = opts.liquidityMin;
+  if (opts.liquidityMax) params.liquidity_max = opts.liquidityMax;
+  if (opts.volumeMin) params.volume_min = opts.volumeMin;
+  if (opts.volumeMax) params.volume_max = opts.volumeMax;
+  if (opts.startDateMin) params.start_date_min = opts.startDateMin;
+  if (opts.startDateMax) params.start_date_max = opts.startDateMax;
+  if (opts.endDateMin) params.end_date_min = opts.endDateMin;
+  if (opts.endDateMax) params.end_date_max = opts.endDateMax;
+  const result = await gamma.getEvents(params);
+  console.log(JSON.stringify(result, null, 2));
+});
+eventsCommand.command("get <id_or_slug>").description("Get event by ID or slug").action(async (idOrSlug) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getEvent(idOrSlug);
+  console.log(JSON.stringify(result, null, 2));
+});
+
+// src/commands/tags.ts
+import { Command as Command4 } from "commander";
+var tagsCommand = new Command4("tags").description("Tags commands");
+tagsCommand.command("list").description("List tags").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).option("--ascending", "Sort ascending").action(async (opts) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getTags(opts);
+  console.log(JSON.stringify(result, null, 2));
+});
+tagsCommand.command("get <id_or_slug>").description("Get tag by ID or slug").action(async (idOrSlug) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getTag(idOrSlug);
+  console.log(JSON.stringify(result, null, 2));
+});
+tagsCommand.command("related <id_or_slug>").description("Get related items for tag").action(async (idOrSlug) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getRelated(idOrSlug);
+  console.log(JSON.stringify(result, null, 2));
+});
+tagsCommand.command("related-tags <id_or_slug>").description("Get related tags").action(async (idOrSlug) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getRelatedTags(idOrSlug);
+  console.log(JSON.stringify(result, null, 2));
+});
+
+// src/commands/series.ts
+import { Command as Command5 } from "commander";
+var seriesCommand = new Command5("series").description(
+  "Series commands"
+);
+seriesCommand.command("list").description("List series").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).option("--order <field>", "Order by field").option("--ascending", "Sort ascending").option("--closed", "Include closed").action(async (opts) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getSeries(opts);
+  console.log(JSON.stringify(result, null, 2));
+});
+seriesCommand.command("get <id>").description("Get series by ID").action(async (id) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getSeriesById(id);
+  console.log(JSON.stringify(result, null, 2));
+});
+
+// src/commands/comments.ts
+import { Command as Command6 } from "commander";
+var out = (data) => console.log(JSON.stringify(data, null, 2));
+var commentsCommand = new Command6("comments").description("Get comments for an event by ID").argument("<event_id>", "Event ID (use 'resolve' command to get ID from URL)").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).option("--order <field>", "Order by (createdAt, updatedAt, reactionCount)", "createdAt").option("--ascending", "Sort ascending").option("--holders-only", "Only show holders' comments").action(async (eventId, opts) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getComments({
+    parent_entity_type: "Event",
+    parent_entity_id: Number(eventId),
+    limit: opts.limit,
+    offset: opts.offset,
+    order: opts.order,
+    ascending: opts.ascending,
+    holders_only: opts.holdersOnly
+  });
+  out(result);
+});
+
+// src/commands/profiles.ts
+import { Command as Command7 } from "commander";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/lib/wallet.ts
+import { getAddress, encodeAbiParameters, keccak256, concat } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var POLYMARKET_SAFE_FACTORY = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b";
+var SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf";
+function deriveGnosisSafeWallet(ownerAddress) {
+  const owner = getAddress(ownerAddress);
+  const salt = keccak256(
+    encodeAbiParameters([{ type: "address" }], [owner])
+  );
+  const create2Hash = keccak256(
+    concat([
+      "0xff",
+      POLYMARKET_SAFE_FACTORY,
+      salt,
+      SAFE_INIT_CODE_HASH
+    ])
+  );
+  return getAddress(`0x${create2Hash.slice(26)}`);
+}
+function createRandomWallet() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  return { privateKey, address: account.address };
+}
+
+// src/commands/profiles.ts
+var out2 = (data) => console.log(JSON.stringify(data, null, 2));
+var profilesCommand = new Command7("profile").description("Get user profile by address").argument("[address]", "Wallet address (use 'resolve' for @username, defaults to your wallet)").option("--private-key <key>", "Private key").action(async (address, opts) => {
+  let addr = address;
+  if (!addr) {
+    const key = resolvePrivateKey(opts.privateKey);
+    const account = privateKeyToAccount2(key);
+    addr = deriveGnosisSafeWallet(account.address);
+  }
+  const gamma = new GammaClient();
+  const [profile, stats] = await Promise.all([
+    gamma.getProfile(addr).catch(() => null),
+    gamma.getProfileStats(addr).catch(() => null)
+  ]);
+  out2({ ...profile, stats });
+});
+
+// src/commands/sports.ts
+import { Command as Command8 } from "commander";
+var sportsCommand = new Command8("sports").description(
+  "Sports commands"
+);
+sportsCommand.command("list").description("List sports").action(async () => {
+  const gamma = new GammaClient();
+  const result = await gamma.getSports();
+  console.log(JSON.stringify(result, null, 2));
+});
+sportsCommand.command("market-types").description("List market types").action(async () => {
+  const gamma = new GammaClient();
+  const result = await gamma.getMarketTypes();
+  console.log(JSON.stringify(result, null, 2));
+});
+sportsCommand.command("teams").description("List teams").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).option("--league <league>", "Filter by league").option("--ascending", "Sort ascending").action(async (opts) => {
+  const gamma = new GammaClient();
+  const result = await gamma.getTeams(opts);
+  console.log(JSON.stringify(result, null, 2));
+});
+
+// src/commands/clob.ts
+import { Command as Command9 } from "commander";
+
+// src/client.ts
+import { ClobClient } from "@polymarket/clob-client";
+import { createWalletClient, http } from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import { polygon } from "viem/chains";
+function createReadonlyClobClient() {
+  return new ClobClient(CLOB_URL, POLYGON_CHAIN_ID);
+}
+async function createAuthenticatedClobClient(privateKey) {
+  const account = privateKeyToAccount3(privateKey);
+  const walletClient = createWalletClient({
+    account,
+    chain: polygon,
+    transport: http(RPC_URL)
+  });
+  const derivedAddress = deriveGnosisSafeWallet(account.address);
+  let creds;
+  const tempClient = new ClobClient(
+    CLOB_URL,
+    POLYGON_CHAIN_ID,
+    walletClient,
+    void 0,
+    2,
+    // POLY_GNOSIS_SAFE
+    derivedAddress
+  );
+  const origError = console.error;
+  console.error = () => {
+  };
+  try {
+    creds = await tempClient.deriveApiKey();
+    if (!creds?.key || !creds?.secret) throw new Error("empty");
+  } catch {
+    try {
+      creds = await tempClient.createApiKey();
+      if (!creds?.key || !creds?.secret) {
+        throw new Error("API key creation returned empty credentials");
+      }
+    } catch (e) {
+      console.error = origError;
+      throw new Error(`Failed to obtain CLOB API key: ${e.message || e}`);
+    }
+  } finally {
+    console.error = origError;
+  }
+  return new ClobClient(
+    CLOB_URL,
+    POLYGON_CHAIN_ID,
+    walletClient,
+    creds,
+    2,
+    // POLY_GNOSIS_SAFE
+    derivedAddress
+  );
+}
+
+// src/commands/clob.ts
+import { AssetType } from "@polymarket/clob-client";
+var out3 = (data) => console.log(JSON.stringify(data, null, 2));
+async function quietCall(fn) {
+  const origLog = console.log;
+  const origError = console.error;
+  console.log = () => {
+  };
+  console.error = () => {
+  };
+  try {
+    return await fn();
+  } catch (e) {
+    console.log = origLog;
+    console.error = origError;
+    console.error(`Error: ${formatError(e)}`);
+    process.exit(1);
+  } finally {
+    console.log = origLog;
+    console.error = origError;
+  }
+}
+function formatError(e) {
+  const data = e?.response?.data || e?.data;
+  if (data?.error) return data.error;
+  return e?.message || String(e);
+}
+async function getAuthClient(opts) {
+  try {
+    const key = resolvePrivateKey(opts.privateKey);
+    return await createAuthenticatedClobClient(key);
+  } catch (e) {
+    console.error(`Error: ${formatError(e)}`);
+    process.exit(1);
+  }
+}
+var clobCommand = new Command9("clob").description("CLOB commands");
+clobCommand.command("ok").description("Check CLOB API health").action(async () => {
+  const client = createReadonlyClobClient();
+  const result = await client.getOk();
+  out3(result);
+});
+clobCommand.command("price <token_id>").description("Get price for token").requiredOption("--side <side>", "buy or sell").action(async (tokenId, opts) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getPrice(tokenId, opts.side);
+  out3(result);
+});
+clobCommand.command("batch-prices <ids>").description("Get prices for multiple tokens (comma-separated)").requiredOption("--side <side>", "buy or sell").action(async (ids, opts) => {
+  const client = createReadonlyClobClient();
+  const tokenIds = ids.split(",");
+  const result = await client.getPrices(tokenIds.map((token_id) => ({ token_id, side: opts.side })));
+  out3(result);
+});
+clobCommand.command("midpoint <token_id>").description("Get midpoint for token").action(async (tokenId) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getMidpoint(tokenId);
+  out3(result);
+});
+clobCommand.command("midpoints <token_ids>").description("Get midpoints for multiple tokens (comma-separated)").action(async (tokenIds) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getMidpoints(tokenIds.split(","));
+  out3(result);
+});
+clobCommand.command("spread <token_id>").description("Get spread for token").option("--side <side>", "buy or sell").action(async (tokenId, opts) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getSpread(tokenId);
+  out3(result);
+});
+clobCommand.command("spreads <token_ids>").description("Get spreads for multiple tokens (comma-separated)").action(async (tokenIds) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getSpreads(tokenIds.split(","));
+  out3(result);
+});
+clobCommand.command("book <token_id>").description("Get order book for token").action(async (tokenId) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getOrderBook(tokenId);
+  out3(result);
+});
+clobCommand.command("books <token_ids>").description("Get order books for multiple tokens (comma-separated)").action(async (tokenIds) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getOrderBooks(tokenIds.split(","));
+  out3(result);
+});
+clobCommand.command("last-trade <token_id>").description("Get last trade price").action(async (tokenId) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getLastTradePrice(tokenId);
+  out3(result);
+});
+clobCommand.command("last-trades <token_ids>").description("Get last trade prices (comma-separated)").action(async (tokenIds) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getLastTradesPrices(tokenIds.split(","));
+  out3(result);
+});
+clobCommand.command("market <condition_id>").description("Get CLOB market by condition ID").action(async (conditionId) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getMarket(conditionId);
+  out3(result);
+});
+clobCommand.command("tick-size <token_id>").description("Get tick size for token").action(async (tokenId) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getTickSize(tokenId);
+  out3(result);
+});
+clobCommand.command("fee-rate <token_id>").description("Get fee rate for token").option("--private-key <key>", "Private key").action(async (tokenId, opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getFeeRateBps(tokenId);
+  out3(result);
+});
+clobCommand.command("neg-risk <token_id>").description("Check if token is neg-risk").action(async (tokenId) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getNegRisk(tokenId);
+  out3(result);
+});
+clobCommand.command("price-history <token_id>").description("Get price history").requiredOption("--interval <interval>", "Time interval (e.g. max, 1d, 1w)").option("--fidelity <fidelity>", "Data fidelity", parseInt).action(async (tokenId, opts) => {
+  const client = createReadonlyClobClient();
+  const result = await client.getPricesHistory({
+    market: tokenId,
+    interval: opts.interval,
+    fidelity: opts.fidelity
+  });
+  out3(result);
+});
+clobCommand.command("time").description("Get server time").action(async () => {
+  const client = createReadonlyClobClient();
+  const result = await client.getServerTime();
+  out3(result);
+});
+clobCommand.command("geoblock").description("Check geo-blocking status").action(async () => {
+  const client = createReadonlyClobClient();
+  try {
+    const result = await client.getOk();
+    out3({ geoblocked: false, response: result });
+  } catch (e) {
+    out3({ geoblocked: true, error: e.message });
+  }
+});
+clobCommand.command("create-order").description("Place a limit order").requiredOption("--token <token_id>", "Token ID").requiredOption("--side <side>", "buy or sell").requiredOption("--price <price>", "Price", parseFloat).requiredOption("--size <size>", "Size", parseFloat).option("--order-type <type>", "Order type (GTC, GTD, FOK)", "GTC").option("--post-only", "Post-only order").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const order = await client.createOrder({
+    tokenID: opts.token,
+    side: opts.side.toUpperCase(),
+    price: opts.price,
+    size: opts.size,
+    ...opts.postOnly ? { postOnly: true } : {}
+  });
+  const result = await quietCall(() => client.postOrder(order, opts.orderType));
+  out3(result);
+});
+clobCommand.command("market-order").description("Place a market order").requiredOption("--token <token_id>", "Token ID").requiredOption("--side <side>", "buy or sell").requiredOption("--amount <amount>", "Amount", parseFloat).option("--order-type <type>", "Order type", "FOK").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const order = await client.createMarketOrder({
+    tokenID: opts.token,
+    side: opts.side.toUpperCase(),
+    amount: opts.amount
+  });
+  const result = await quietCall(() => client.postOrder(order, opts.orderType));
+  out3(result);
+});
+clobCommand.command("post-orders").description("Batch post orders").requiredOption("--tokens <ids>", "Token IDs (comma-separated)").requiredOption("--side <side>", "buy or sell").requiredOption("--prices <prices>", "Prices (comma-separated)").requiredOption("--sizes <sizes>", "Sizes (comma-separated)").option("--order-type <type>", "Order type", "GTC").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const tokens = opts.tokens.split(",");
+  const prices = opts.prices.split(",").map(Number);
+  const sizes = opts.sizes.split(",").map(Number);
+  const orders = await Promise.all(
+    tokens.map(
+      (token, i) => client.createOrder({
+        tokenID: token,
+        side: opts.side.toUpperCase(),
+        price: prices[i],
+        size: sizes[i]
+      })
+    )
+  );
+  const result = await client.postOrders(orders.map((order) => ({ order, orderType: opts.orderType })));
+  out3(result);
+});
+clobCommand.command("orders").description("List open orders").option("--market <condition_id>", "Filter by market").option("--asset <token_id>", "Filter by asset").option("--cursor <cursor>", "Pagination cursor").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const params = {};
+  if (opts.market) params.market = opts.market;
+  if (opts.asset) params.asset_id = opts.asset;
+  if (opts.cursor) params.next_cursor = opts.cursor;
+  const result = await client.getOpenOrders(params);
+  out3(result);
+});
+clobCommand.command("order <order_id>").description("Get order details").option("--private-key <key>", "Private key").action(async (orderId, opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getOrder(orderId);
+  out3(result);
+});
+clobCommand.command("cancel <order_id>").description("Cancel an order").option("--private-key <key>", "Private key").action(async (orderId, opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.cancelOrder({ orderID: orderId });
+  out3(result);
+});
+clobCommand.command("cancel-orders <ids>").description("Cancel multiple orders (comma-separated)").option("--private-key <key>", "Private key").action(async (ids, opts) => {
+  const client = await getAuthClient(opts);
+  const orderIds = ids.split(",");
+  const result = await client.cancelOrders(
+    orderIds.map((id) => ({ orderID: id }))
+  );
+  out3(result);
+});
+clobCommand.command("cancel-all").description("Cancel all open orders").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.cancelAll();
+  out3(result);
+});
+clobCommand.command("cancel-market").description("Cancel orders by market").option("--market <condition_id>", "Market condition ID").option("--asset <token_id>", "Asset token ID").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const params = {};
+  if (opts.market) params.market = opts.market;
+  if (opts.asset) params.asset_id = opts.asset;
+  const result = await client.cancelMarketOrders(params);
+  out3(result);
+});
+clobCommand.command("trades").description("Trade history").option("--market <condition_id>", "Filter by market").option("--asset <token_id>", "Filter by asset").option("--cursor <cursor>", "Pagination cursor").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const params = {};
+  if (opts.market) params.market = opts.market;
+  if (opts.asset) params.asset_id = opts.asset;
+  if (opts.cursor) params.next_cursor = opts.cursor;
+  const result = await client.getTrades(params);
+  out3(result);
+});
+clobCommand.command("balance").description("Check balance").requiredOption("--asset-type <type>", "Asset type (collateral or conditional)").option("--token <token_id>", "Token ID (for conditional)").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const params = { asset_type: opts.assetType };
+  if (opts.token) params.token_id = opts.token;
+  const result = await client.getBalanceAllowance(params);
+  out3(result);
+});
+clobCommand.command("update-balance").description("Refresh balance").requiredOption("--asset-type <type>", "Asset type (collateral or conditional)").option("--token <token_id>", "Token ID (for conditional)").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const params = { asset_type: opts.assetType };
+  if (opts.token) params.token_id = opts.token;
+  const result = await client.updateBalanceAllowance(params);
+  out3(result);
+});
+clobCommand.command("notifications").description("Get notifications").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getNotifications();
+  out3(result);
+});
+clobCommand.command("delete-notifications <ids>").description("Delete notifications (comma-separated)").option("--private-key <key>", "Private key").action(async (ids, opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.dropNotifications({ ids: ids.split(",") });
+  out3(result);
+});
+clobCommand.command("rewards").description("Daily rewards").requiredOption("--date <date>", "Date (YYYY-MM-DD)").option("--cursor <cursor>", "Pagination cursor").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getEarningsForUserForDay(opts.date);
+  out3(result);
+});
+clobCommand.command("earnings").description("Daily earnings").requiredOption("--date <date>", "Date (YYYY-MM-DD)").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getTotalEarningsForUserForDay(opts.date);
+  out3(result);
+});
+clobCommand.command("earnings-markets").description("Earnings by market").requiredOption("--date <date>", "Date (YYYY-MM-DD)").option("--cursor <cursor>", "Pagination cursor").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getUserEarningsAndMarketsConfig(opts.date);
+  out3(result);
+});
+clobCommand.command("reward-percentages").description("Reward percentages").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getRewardPercentages();
+  out3(result);
+});
+clobCommand.command("current-rewards").description("Current rewards").option("--cursor <cursor>", "Pagination cursor").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const params = {};
+  if (opts.cursor) params.next_cursor = opts.cursor;
+  const result = await client.getCurrentRewards();
+  out3(result);
+});
+clobCommand.command("market-reward <condition_id>").description("Market rewards").option("--cursor <cursor>", "Pagination cursor").option("--private-key <key>", "Private key").action(async (conditionId, opts) => {
+  const client = await getAuthClient(opts);
+  const params = { conditionId };
+  if (opts.cursor) params.next_cursor = opts.cursor;
+  const result = await client.getRawRewardsForMarket(params);
+  out3(result);
+});
+clobCommand.command("order-scoring <order_id>").description("Order scoring").option("--private-key <key>", "Private key").action(async (orderId, opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.isOrderScoring({ order_id: orderId });
+  out3(result);
+});
+clobCommand.command("orders-scoring <ids>").description("Batch order scoring (comma-separated)").option("--private-key <key>", "Private key").action(async (ids, opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.areOrdersScoring({
+    orderIds: ids.split(",")
+  });
+  out3(result);
+});
+clobCommand.command("api-keys").description("List API keys").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.getApiKeys();
+  out3(result);
+});
+clobCommand.command("create-api-key").description("Create API key").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.createApiKey();
+  out3(result);
+});
+clobCommand.command("delete-api-key").description("Delete API key").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const result = await client.deleteApiKey();
+  out3(result);
+});
+clobCommand.command("account-status").description("Account status").option("--private-key <key>", "Private key").action(async (opts) => {
+  const client = await getAuthClient(opts);
+  const [apiKeys, balance] = await Promise.all([
+    client.getApiKeys().catch(() => null),
+    client.getBalanceAllowance({ asset_type: AssetType.COLLATERAL }).catch(() => null)
+  ]);
+  out3({ apiKeys, balance });
+});
+
+// src/commands/wallet.ts
+import { Command as Command10 } from "commander";
+import { createPublicClient, http as http2, formatUnits, parseUnits, encodeFunctionData as encodeFunctionData2, isAddress } from "viem";
+import { polygon as polygon2 } from "viem/chains";
+import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
+
+// src/lib/contracts.ts
+var USDCE_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+var CTF_ADDRESS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045";
+var CTF_EXCHANGE = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E";
+var NEG_RISK_CTF_EXCHANGE = "0xC5d563A36AE78145C45a50134d48A1215220f80a";
+var NEG_RISK_ADAPTER = "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296";
+var ERC20_ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  }
+];
+var ERC1155_ABI = [
+  {
+    name: "setApprovalForAll",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    name: "isApprovedForAll",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var CTF_ABI = [
+  {
+    name: "splitPosition",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "collateralToken", type: "address" },
+      { name: "parentCollectionId", type: "bytes32" },
+      { name: "conditionId", type: "bytes32" },
+      { name: "partition", type: "uint256[]" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "mergePositions",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "collateralToken", type: "address" },
+      { name: "parentCollectionId", type: "bytes32" },
+      { name: "conditionId", type: "bytes32" },
+      { name: "partition", type: "uint256[]" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "redeemPositions",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "collateralToken", type: "address" },
+      { name: "parentCollectionId", type: "bytes32" },
+      { name: "conditionId", type: "bytes32" },
+      { name: "indexSets", type: "uint256[]" }
+    ],
+    outputs: []
+  },
+  {
+    name: "getConditionId",
+    type: "function",
+    stateMutability: "pure",
+    inputs: [
+      { name: "oracle", type: "address" },
+      { name: "questionId", type: "bytes32" },
+      { name: "outcomeSlotCount", type: "uint256" }
+    ],
+    outputs: [{ type: "bytes32" }]
+  },
+  {
+    name: "getCollectionId",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "parentCollectionId", type: "bytes32" },
+      { name: "conditionId", type: "bytes32" },
+      { name: "indexSet", type: "uint256" }
+    ],
+    outputs: [{ type: "bytes32" }]
+  },
+  {
+    name: "getPositionId",
+    type: "function",
+    stateMutability: "pure",
+    inputs: [
+      { name: "collateralToken", type: "address" },
+      { name: "collectionId", type: "bytes32" }
+    ],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var NEG_RISK_ADAPTER_ABI = [
+  {
+    name: "redeemPositions",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "conditionId", type: "bytes32" },
+      { name: "amounts", type: "uint256[]" }
+    ],
+    outputs: []
+  }
+];
+
+// src/lib/relayer.ts
+import {
+  encodeFunctionData,
+  encodePacked,
+  hashTypedData,
+  hexToBytes,
+  hexToBigInt,
+  concat as concat2,
+  zeroAddress
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+var MULTISEND_ADDRESS = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var POLYMARKET_SAFE_FACTORY2 = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b";
+var SAFE_FACTORY_NAME = "Polymarket Contract Proxy Factory";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var SAFE_TX_TYPES = {
+  SafeTx: [
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "data", type: "bytes" },
+    { name: "operation", type: "uint8" },
+    { name: "safeTxGas", type: "uint256" },
+    { name: "baseGas", type: "uint256" },
+    { name: "gasPrice", type: "uint256" },
+    { name: "gasToken", type: "address" },
+    { name: "refundReceiver", type: "address" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+function resolveBuilderCreds() {
+  const key = process.env.POLYMARKET_BUILDER_API_KEY;
+  const secret = process.env.POLYMARKET_BUILDER_SECRET;
+  const passphrase = process.env.POLYMARKET_BUILDER_PASSPHRASE;
+  if (key && secret && passphrase) {
+    return { key, secret, passphrase };
+  }
+  return null;
+}
+async function buildHmacSignature(secret, timestamp, method, requestPath, body) {
+  const secretBytes = Uint8Array.from(atob(secret.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0));
+  let message = `${timestamp}${method}${requestPath}`;
+  if (body) {
+    message += body.replace(/'/g, '"');
+  }
+  const key = await crypto.subtle.importKey(
+    "raw",
+    secretBytes,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(message));
+  return btoa(String.fromCharCode(...new Uint8Array(sig))).replace(/\+/g, "-").replace(/\//g, "_");
+}
+function generateBuilderHeaders(creds, method, path, body) {
+  const timestamp = String(Math.floor(Date.now() / 1e3));
+  return buildHmacSignature(creds.secret, timestamp, method, path, body).then((sig) => ({
+    "Content-Type": "application/json",
+    "POLY_BUILDER_API_KEY": creds.key,
+    "POLY_BUILDER_PASSPHRASE": creds.passphrase,
+    "POLY_BUILDER_SIGNATURE": sig,
+    "POLY_BUILDER_TIMESTAMP": timestamp
+  }));
+}
+var RelayerClient = class {
+  constructor(baseUrl = RELAYER_URL) {
+    this.baseUrl = baseUrl;
+    this.creds = resolveBuilderCreds();
+    if (!this.creds && baseUrl.includes("relayer-v2.polymarket.com")) {
+      throw new Error(
+        "Relayer requires authentication. Either:\n  1. Set POLYMARKET_BUILDER_API_KEY, POLYMARKET_BUILDER_SECRET, POLYMARKET_BUILDER_PASSPHRASE, or\n  2. Set POLYMARKET_RELAYER_URL to a proxy that injects builder credentials (e.g. https://proxy.polytown.app/relayer)"
+      );
+    }
+  }
+  creds;
+  async authedHeaders(method, path, body) {
+    if (!this.creds) {
+      return { "Content-Type": "application/json" };
+    }
+    return generateBuilderHeaders(this.creds, method, path, body);
+  }
+  async getNonce(safeAddress, type = "SAFE") {
+    const path = `/nonce?address=${safeAddress}&type=${type}`;
+    const headers = await this.authedHeaders("GET", "/nonce");
+    const res = await fetch(`${this.baseUrl}${path}`, { headers });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Relayer /nonce failed: ${res.status} ${res.statusText} \u2014 ${text}`);
+    }
+    const data = await res.json();
+    return String(data.nonce ?? data);
+  }
+  async isDeployed(safeAddress) {
+    const path = `/deployed?address=${safeAddress}`;
+    const headers = await this.authedHeaders("GET", "/deployed");
+    const res = await fetch(`${this.baseUrl}${path}`, { headers });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Relayer /deployed failed: ${res.status} ${res.statusText} \u2014 ${text}`);
+    }
+    const data = await res.json();
+    return !!data.deployed;
+  }
+  async submit(payload) {
+    const body = JSON.stringify(payload);
+    const headers = await this.authedHeaders("POST", "/submit", body);
+    const res = await fetch(`${this.baseUrl}/submit`, {
+      method: "POST",
+      headers,
+      body
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Relayer /submit failed: ${res.status} ${res.statusText} \u2014 ${text}`);
+    }
+    return res.json();
+  }
+  async getTransaction(txId) {
+    const res = await fetch(`${this.baseUrl}/transaction?id=${txId}`);
+    if (!res.ok) throw new Error(`Relayer /transaction failed: ${res.status}`);
+    return res.json();
+  }
+};
+async function signSafeTransaction(privateKey, safeAddress, to, data, nonce, operation = 0) {
+  const account = privateKeyToAccount4(privateKey);
+  const structHash = hashTypedData({
+    domain: {
+      chainId: POLYGON_CHAIN_ID,
+      verifyingContract: safeAddress
+    },
+    types: SAFE_TX_TYPES,
+    primaryType: "SafeTx",
+    message: {
+      to,
+      value: 0n,
+      data,
+      operation,
+      safeTxGas: 0n,
+      baseGas: 0n,
+      gasPrice: 0n,
+      gasToken: ZERO_ADDRESS,
+      refundReceiver: ZERO_ADDRESS,
+      nonce: BigInt(nonce)
+    }
+  });
+  const signature = await account.signMessage({
+    message: { raw: hexToBytes(structHash) }
+  });
+  return splitAndPackSig(signature);
+}
+function splitAndPackSig(sig) {
+  let sigV = parseInt(sig.slice(-2), 16);
+  switch (sigV) {
+    case 0:
+    case 1:
+      sigV += 31;
+      break;
+    case 27:
+    case 28:
+      sigV += 4;
+      break;
+    default:
+      throw new Error("Invalid signature v value");
+  }
+  const adjusted = sig.slice(0, -2) + sigV.toString(16);
+  const r = hexToBigInt("0x" + adjusted.slice(2, 66));
+  const s = hexToBigInt("0x" + adjusted.slice(66, 130));
+  const v = parseInt(adjusted.slice(130, 132), 16);
+  return encodePacked(["uint256", "uint256", "uint8"], [r, s, v]);
+}
+function encodeMultiSend(txns) {
+  let packed = "0x";
+  for (const txn of txns) {
+    const dataBytes = hexToBytes(txn.data);
+    const encoded = encodePacked(
+      ["uint8", "address", "uint256", "uint256", "bytes"],
+      [txn.operation ?? 0, txn.to, txn.value ?? 0n, BigInt(dataBytes.length), txn.data]
+    );
+    packed = concat2([packed, encoded]);
+  }
+  return encodeFunctionData({
+    abi: [
+      {
+        name: "multiSend",
+        type: "function",
+        inputs: [{ name: "transactions", type: "bytes" }],
+        outputs: []
+      }
+    ],
+    functionName: "multiSend",
+    args: [packed]
+  });
+}
+async function relayTransaction(privateKey, to, data, metadata, operation = 0) {
+  const account = privateKeyToAccount4(privateKey);
+  const safeAddress = deriveGnosisSafeWallet(account.address);
+  const relayer = new RelayerClient();
+  const noncePayload = await relayer.getNonce(account.address);
+  const signature = await signSafeTransaction(
+    privateKey,
+    safeAddress,
+    to,
+    data,
+    noncePayload,
+    operation
+  );
+  const payload = {
+    type: "SAFE",
+    from: account.address,
+    to,
+    proxyWallet: safeAddress,
+    data,
+    nonce: noncePayload,
+    signature,
+    signatureParams: {
+      gasPrice: "0",
+      operation: String(operation),
+      safeTxnGas: "0",
+      baseGas: "0",
+      gasToken: ZERO_ADDRESS,
+      refundReceiver: ZERO_ADDRESS
+    },
+    metadata
+  };
+  return relayer.submit(payload);
+}
+async function relayMultiSend(privateKey, txns, metadata) {
+  const multiSendData = encodeMultiSend(txns);
+  return relayTransaction(
+    privateKey,
+    MULTISEND_ADDRESS,
+    multiSendData,
+    metadata,
+    1
+    // DelegateCall for MultiSend
+  );
+}
+function buildRedeemCalldata(conditionId, indexSets = [1n, 2n], collateral = USDCE_ADDRESS, parentCollectionId = ZERO_BYTES32) {
+  const data = encodeFunctionData({
+    abi: CTF_ABI,
+    functionName: "redeemPositions",
+    args: [collateral, parentCollectionId, conditionId, indexSets]
+  });
+  return { to: CTF_ADDRESS, data };
+}
+function buildNegRiskRedeemCalldata(conditionId, amounts) {
+  const data = encodeFunctionData({
+    abi: NEG_RISK_ADAPTER_ABI,
+    functionName: "redeemPositions",
+    args: [conditionId, amounts]
+  });
+  return { to: NEG_RISK_ADAPTER, data };
+}
+function buildSplitCalldata(conditionId, amount, partition = [1n, 2n], collateral = USDCE_ADDRESS, parentCollectionId = ZERO_BYTES32) {
+  const data = encodeFunctionData({
+    abi: CTF_ABI,
+    functionName: "splitPosition",
+    args: [collateral, parentCollectionId, conditionId, partition, amount]
+  });
+  return { to: CTF_ADDRESS, data };
+}
+function buildMergeCalldata(conditionId, amount, partition = [1n, 2n], collateral = USDCE_ADDRESS, parentCollectionId = ZERO_BYTES32) {
+  const data = encodeFunctionData({
+    abi: CTF_ABI,
+    functionName: "mergePositions",
+    args: [collateral, parentCollectionId, conditionId, partition, amount]
+  });
+  return { to: CTF_ADDRESS, data };
+}
+async function deploySafe(privateKey) {
+  const account = privateKeyToAccount4(privateKey);
+  const safeAddress = deriveGnosisSafeWallet(account.address);
+  const relayer = new RelayerClient();
+  const deployed = await relayer.isDeployed(safeAddress);
+  if (deployed) {
+    return { alreadyDeployed: true, safeAddress };
+  }
+  const signature = await account.signTypedData({
+    domain: {
+      name: SAFE_FACTORY_NAME,
+      chainId: BigInt(POLYGON_CHAIN_ID),
+      verifyingContract: POLYMARKET_SAFE_FACTORY2
+    },
+    types: {
+      CreateProxy: [
+        { name: "paymentToken", type: "address" },
+        { name: "payment", type: "uint256" },
+        { name: "paymentReceiver", type: "address" }
+      ]
+    },
+    primaryType: "CreateProxy",
+    message: {
+      paymentToken: zeroAddress,
+      payment: 0n,
+      paymentReceiver: zeroAddress
+    }
+  });
+  const payload = {
+    from: account.address,
+    to: POLYMARKET_SAFE_FACTORY2,
+    proxyWallet: safeAddress,
+    data: "0x",
+    signature,
+    signatureParams: {
+      paymentToken: zeroAddress,
+      payment: "0",
+      paymentReceiver: zeroAddress
+    },
+    type: "SAFE-CREATE"
+  };
+  const body = JSON.stringify(payload);
+  const headers = await relayer["authedHeaders"]("POST", "/submit", body);
+  const res = await fetch(`${relayer["baseUrl"]}/submit`, {
+    method: "POST",
+    headers,
+    body
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Relayer deploy failed: ${res.status} ${res.statusText} \u2014 ${text}`);
+  }
+  return res.json();
+}
+function buildApproveCalldata() {
+  const maxUint256 = 2n ** 256n - 1n;
+  return [
+    {
+      to: USDCE_ADDRESS,
+      data: encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [CTF_EXCHANGE, maxUint256]
+      })
+    },
+    {
+      to: USDCE_ADDRESS,
+      data: encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [NEG_RISK_CTF_EXCHANGE, maxUint256]
+      })
+    },
+    {
+      to: CTF_ADDRESS,
+      data: encodeFunctionData({
+        abi: ERC1155_ABI,
+        functionName: "setApprovalForAll",
+        args: [CTF_EXCHANGE, true]
+      })
+    },
+    {
+      to: CTF_ADDRESS,
+      data: encodeFunctionData({
+        abi: ERC1155_ABI,
+        functionName: "setApprovalForAll",
+        args: [NEG_RISK_CTF_EXCHANGE, true]
+      })
+    }
+  ];
+}
+
+// src/commands/wallet.ts
+var out4 = (data) => console.log(JSON.stringify(data, null, 2));
+function resolveAddress(opts) {
+  const key = resolvePrivateKey(opts.privateKey);
+  const account = privateKeyToAccount5(key);
+  return {
+    key,
+    eoa: account.address,
+    address: deriveGnosisSafeWallet(account.address)
+  };
+}
+var walletCommand = new Command10("wallet").description(
+  "Wallet management"
+);
+walletCommand.command("create").description("Create a new random wallet").action(async () => {
+  const wallet = createRandomWallet();
+  const address = deriveGnosisSafeWallet(wallet.address);
+  out4({
+    privateKey: wallet.privateKey,
+    eoa: wallet.address,
+    address
+  });
+});
+walletCommand.command("import <key>").description("Import wallet from private key").action(async (key) => {
+  const normalized = key.startsWith("0x") ? key : `0x${key}`;
+  const account = privateKeyToAccount5(normalized);
+  const address = deriveGnosisSafeWallet(account.address);
+  out4({
+    eoa: account.address,
+    address
+  });
+});
+walletCommand.command("address").description("Show active wallet address").option("--private-key <key>", "Private key").action(async (opts) => {
+  const { address } = resolveAddress(opts);
+  out4({ address });
+});
+walletCommand.command("show").description("Show wallet details").option("--private-key <key>", "Private key").action(async (opts) => {
+  const { eoa, address } = resolveAddress(opts);
+  out4({ eoa, address });
+});
+walletCommand.command("balance").description("Show wallet USDC.e balance").option("--private-key <key>", "Private key").action(async (opts) => {
+  const { address } = resolveAddress(opts);
+  const publicClient = createPublicClient({ chain: polygon2, transport: http2(RPC_URL) });
+  const usdce = await publicClient.readContract({
+    address: USDCE_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [address]
+  });
+  out4({
+    address,
+    "usdc.e": formatUnits(usdce, 6)
+  });
+});
+walletCommand.command("withdraw <amount> <to>").description("Withdraw USDC.e from Safe wallet via relayer (gasless)").option("--private-key <key>", "Private key").action(async (amount, to, opts) => {
+  if (!isAddress(to)) throw new Error(`Invalid address: ${to}`);
+  const key = resolvePrivateKey(opts.privateKey);
+  const amountInWei = parseUnits(amount, 6);
+  const data = encodeFunctionData2({
+    abi: ERC20_ABI,
+    functionName: "transfer",
+    args: [to, amountInWei]
+  });
+  const result = await relayTransaction(
+    key,
+    USDCE_ADDRESS,
+    data,
+    `Withdraw ${amount} USDC.e to ${to}`
+  );
+  out4(result);
+});
+walletCommand.command("reset").description("Reset wallet (clear env reminder)").action(async () => {
+  out4({
+    message: "To reset, remove POLYMARKET_PRIVATE_KEY from ~/.polytown/.env"
+  });
+});
+
+// src/commands/data.ts
+import { Command as Command11 } from "commander";
+import { privateKeyToAccount as privateKeyToAccount6 } from "viem/accounts";
+
+// src/lib/data.ts
+function buildUrl2(base, path, params) {
+  const url = new URL(path, base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+async function fetchJson2(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}: ${res.statusText} \u2014 ${url}`);
+  }
+  return res.json();
+}
+var DataClient = class {
+  constructor(baseUrl = DATA_URL) {
+    this.baseUrl = baseUrl;
+  }
+  // User data
+  async getPositions(address, params) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/positions", { user: address, ...params })
+    );
+  }
+  async getClosedPositions(address, params) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/positions", {
+        user: address,
+        closed: true,
+        ...params
+      })
+    );
+  }
+  async getValue(address) {
+    return fetchJson2(buildUrl2(this.baseUrl, "/value", { user: address }));
+  }
+  async getTraded(address) {
+    return fetchJson2(buildUrl2(this.baseUrl, "/traded", { user: address }));
+  }
+  async getTrades(address, params) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/trades", { user: address, ...params })
+    );
+  }
+  async getActivity(address, params) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/activity", { user: address, ...params })
+    );
+  }
+  // Market data
+  async getHolders(conditionId, params) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/holders", { conditionId, ...params })
+    );
+  }
+  async getOpenInterest(conditionId) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/open-interest", { conditionId })
+    );
+  }
+  async getVolume(eventId) {
+    return fetchJson2(buildUrl2(this.baseUrl, "/volume", { eventId }));
+  }
+  // Leaderboards
+  async getLeaderboard(params) {
+    return fetchJson2(
+      buildUrl2(this.baseUrl, "/leaderboard", {
+        period: params?.period,
+        order_by: params?.orderBy,
+        limit: params?.limit,
+        offset: params?.offset
+      })
+    );
+  }
+  async getBuilderLeaderboard(params) {
+    return fetchJson2(
+      buildUrl2(
+        this.baseUrl,
+        "/leaderboard/builders",
+        params
+      )
+    );
+  }
+  async getBuilderVolume(params) {
+    return fetchJson2(
+      buildUrl2(
+        this.baseUrl,
+        "/leaderboard/builders/volume",
+        params
+      )
+    );
+  }
+};
+
+// src/commands/data.ts
+var out5 = (data) => console.log(JSON.stringify(data, null, 2));
+function resolveAddr(address, opts) {
+  if (address) return address;
+  const key = resolvePrivateKey(opts?.privateKey);
+  const account = privateKeyToAccount6(key);
+  return deriveGnosisSafeWallet(account.address);
+}
+var dataCommand = new Command11("data").description(
+  "Data API commands"
+);
+dataCommand.command("positions [address]").description("Get positions (defaults to your wallet)").option("--private-key <key>", "Private key").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).action(async (address, opts) => {
+  const addr = resolveAddr(address, opts);
+  const client = new DataClient();
+  const result = await client.getPositions(addr, opts);
+  out5(result);
+});
+dataCommand.command("closed-positions [address]").description("Get closed positions (defaults to your wallet)").option("--private-key <key>", "Private key").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).action(async (address, opts) => {
+  const addr = resolveAddr(address, opts);
+  const client = new DataClient();
+  const result = await client.getClosedPositions(addr, opts);
+  out5(result);
+});
+dataCommand.command("value [address]").description("Get portfolio value (defaults to your wallet)").option("--private-key <key>", "Private key").action(async (address, opts) => {
+  const addr = resolveAddr(address, opts);
+  const client = new DataClient();
+  const result = await client.getValue(addr);
+  out5(result);
+});
+dataCommand.command("traded [address]").description("Check if address has traded (defaults to your wallet)").option("--private-key <key>", "Private key").action(async (address, opts) => {
+  const addr = resolveAddr(address, opts);
+  const client = new DataClient();
+  const result = await client.getTraded(addr);
+  out5(result);
+});
+dataCommand.command("trades [address]").description("Get trade history (defaults to your wallet)").option("--private-key <key>", "Private key").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).action(async (address, opts) => {
+  const addr = resolveAddr(address, opts);
+  const client = new DataClient();
+  const result = await client.getTrades(addr, opts);
+  out5(result);
+});
+dataCommand.command("activity [address]").description("Get activity history (defaults to your wallet)").option("--private-key <key>", "Private key").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).action(async (address, opts) => {
+  const addr = resolveAddr(address, opts);
+  const client = new DataClient();
+  const result = await client.getActivity(addr, opts);
+  out5(result);
+});
+dataCommand.command("holders <condition_id>").description("Get holders for condition").option("--limit <n>", "Limit results", parseInt).action(async (conditionId, opts) => {
+  const client = new DataClient();
+  const result = await client.getHolders(conditionId, opts);
+  out5(result);
+});
+dataCommand.command("open-interest <condition_id>").description("Get open interest").action(async (conditionId) => {
+  const client = new DataClient();
+  const result = await client.getOpenInterest(conditionId);
+  out5(result);
+});
+dataCommand.command("volume <event_id>").description("Get volume for event").action(async (eventId) => {
+  const client = new DataClient();
+  const result = await client.getVolume(eventId);
+  out5(result);
+});
+dataCommand.command("leaderboard").description("Get leaderboard").option("--period <period>", "Time period").option("--order-by <field>", "Order by field").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).action(async (opts) => {
+  const client = new DataClient();
+  const result = await client.getLeaderboard({
+    period: opts.period,
+    orderBy: opts.orderBy,
+    limit: opts.limit,
+    offset: opts.offset
+  });
+  out5(result);
+});
+dataCommand.command("builder-leaderboard").description("Get builder leaderboard").option("--period <period>", "Time period").option("--limit <n>", "Limit results", parseInt).option("--offset <n>", "Offset results", parseInt).action(async (opts) => {
+  const client = new DataClient();
+  const result = await client.getBuilderLeaderboard(opts);
+  out5(result);
+});
+dataCommand.command("builder-volume").description("Get builder volume").option("--period <period>", "Time period").action(async (opts) => {
+  const client = new DataClient();
+  const result = await client.getBuilderVolume(opts);
+  out5(result);
+});
+
+// src/commands/approve.ts
+import { Command as Command12 } from "commander";
+import { createPublicClient as createPublicClient2, http as http3 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount7 } from "viem/accounts";
+import { polygon as polygon3 } from "viem/chains";
+var out6 = (data) => console.log(JSON.stringify(data, null, 2));
+var approveCommand = new Command12("approve").description(
+  "Token approval management"
+);
+approveCommand.command("check [address]").description("Check approval status").option("--private-key <key>", "Private key").action(async (address, opts) => {
+  let targetAddress;
+  if (address) {
+    targetAddress = address;
+  } else {
+    const key = resolvePrivateKey(opts.privateKey);
+    const account = privateKeyToAccount7(key);
+    targetAddress = deriveGnosisSafeWallet(account.address);
+  }
+  const publicClient = createPublicClient2({
+    chain: polygon3,
+    transport: http3(RPC_URL)
+  });
+  const [usdcCtfExchange, usdcNegRisk, ctfCtfExchange, ctfNegRisk] = await Promise.all([
+    publicClient.readContract({
+      address: USDCE_ADDRESS,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [targetAddress, CTF_EXCHANGE]
+    }),
+    publicClient.readContract({
+      address: USDCE_ADDRESS,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [targetAddress, NEG_RISK_CTF_EXCHANGE]
+    }),
+    publicClient.readContract({
+      address: CTF_ADDRESS,
+      abi: ERC1155_ABI,
+      functionName: "isApprovedForAll",
+      args: [targetAddress, CTF_EXCHANGE]
+    }),
+    publicClient.readContract({
+      address: CTF_ADDRESS,
+      abi: ERC1155_ABI,
+      functionName: "isApprovedForAll",
+      args: [targetAddress, NEG_RISK_CTF_EXCHANGE]
+    })
+  ]);
+  out6({
+    address: targetAddress,
+    "usdc.e": {
+      ctfExchange: usdcCtfExchange.toString(),
+      negRiskExchange: usdcNegRisk.toString()
+    },
+    ctf: {
+      ctfExchange: ctfCtfExchange,
+      negRiskExchange: ctfNegRisk
+    }
+  });
+});
+approveCommand.command("set").description("Set all approvals for trading (gas-free via relayer)").option("--private-key <key>", "Private key").action(async (opts) => {
+  const key = resolvePrivateKey(opts.privateKey);
+  const account = privateKeyToAccount7(key);
+  const safeAddress = deriveGnosisSafeWallet(account.address);
+  const txns = buildApproveCalldata();
+  const result = await relayMultiSend(key, txns, "approve");
+  out6({
+    address: account.address,
+    safeAddress,
+    method: "relayer (gas-free)",
+    ...result
+  });
+});
+approveCommand.command("deploy").description("Deploy Gnosis Safe wallet via relayer (gas-free)").option("--private-key <key>", "Private key").action(async (opts) => {
+  const key = resolvePrivateKey(opts.privateKey);
+  const account = privateKeyToAccount7(key);
+  const safeAddress = deriveGnosisSafeWallet(account.address);
+  console.log(`EOA: ${account.address}`);
+  console.log(`Safe: ${safeAddress}`);
+  console.log("Deploying...");
+  const result = await deploySafe(key);
+  out6(result);
+});
+
+// src/commands/ctf.ts
+import { Command as Command13 } from "commander";
+import { createPublicClient as createPublicClient3, http as http4 } from "viem";
+import { polygon as polygon4 } from "viem/chains";
+var out7 = (data) => console.log(JSON.stringify(data, null, 2));
+var ZERO_BYTES322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ctfCommand = new Command13("ctf").description(
+  "Conditional Token Framework commands"
+);
+ctfCommand.command("split").description("Split position").requiredOption("--condition <id>", "Condition ID").requiredOption("--amount <amount>", "Amount in USDC.e units", parseFloat).option("--collateral <address>", "Collateral token address", USDCE_ADDRESS).option("--partition <sets>", "Partition index sets (comma-separated)", "1,2").option("--parent-collection <id>", "Parent collection ID", ZERO_BYTES322).option("--private-key <key>", "Private key").action(async (opts) => {
+  const key = resolvePrivateKey(opts.privateKey);
+  const partition = opts.partition.split(",").map((s) => BigInt(s));
+  const amount = BigInt(Math.round(opts.amount * 1e6));
+  const { to, data } = buildSplitCalldata(
+    opts.condition,
+    amount,
+    partition,
+    opts.collateral,
+    opts.parentCollection
+  );
+  const result = await relayTransaction(key, to, data, "split");
+  out7({ action: "splitPosition", ...result });
+});
+ctfCommand.command("merge").description("Merge positions").requiredOption("--condition <id>", "Condition ID").requiredOption("--amount <amount>", "Amount in USDC.e units", parseFloat).option("--collateral <address>", "Collateral token address", USDCE_ADDRESS).option("--partition <sets>", "Partition index sets (comma-separated)", "1,2").option("--parent-collection <id>", "Parent collection ID", ZERO_BYTES322).option("--private-key <key>", "Private key").action(async (opts) => {
+  const key = resolvePrivateKey(opts.privateKey);
+  const partition = opts.partition.split(",").map((s) => BigInt(s));
+  const amount = BigInt(Math.round(opts.amount * 1e6));
+  const { to, data } = buildMergeCalldata(
+    opts.condition,
+    amount,
+    partition,
+    opts.collateral,
+    opts.parentCollection
+  );
+  const result = await relayTransaction(key, to, data, "merge");
+  out7({ action: "mergePositions", ...result });
+});
+ctfCommand.command("redeem").description("Redeem positions (via relayer, gas-free)").requiredOption("--condition <id>", "Condition ID").option("--collateral <address>", "Collateral token address", USDCE_ADDRESS).option("--index-sets <sets>", "Index sets (comma-separated)", "1,2").option("--parent-collection <id>", "Parent collection ID", ZERO_BYTES322).option("--private-key <key>", "Private key").action(async (opts) => {
+  const key = resolvePrivateKey(opts.privateKey);
+  const indexSets = opts.indexSets.split(",").map((s) => BigInt(s));
+  const { to, data } = buildRedeemCalldata(
+    opts.condition,
+    indexSets,
+    opts.collateral,
+    opts.parentCollection
+  );
+  const result = await relayTransaction(key, to, data, "redeem");
+  out7({ action: "redeemPositions", ...result });
+});
+ctfCommand.command("redeem-neg-risk").description("Redeem neg-risk positions (via relayer, gas-free)").requiredOption("--condition <id>", "Condition ID").requiredOption("--amounts <amounts>", "Amounts (comma-separated)").option("--private-key <key>", "Private key").action(async (opts) => {
+  const key = resolvePrivateKey(opts.privateKey);
+  const amounts = opts.amounts.split(",").map((s) => BigInt(s));
+  const { to, data } = buildNegRiskRedeemCalldata(opts.condition, amounts);
+  const result = await relayTransaction(key, to, data, "redeem");
+  out7({ action: "redeemPositions (neg-risk)", ...result });
+});
+ctfCommand.command("condition-id").description("Compute condition ID").requiredOption("--oracle <address>", "Oracle address").requiredOption("--question <id>", "Question ID (bytes32)").requiredOption("--outcomes <n>", "Number of outcomes", parseInt).action(async (opts) => {
+  const publicClient = createPublicClient3({ chain: polygon4, transport: http4(RPC_URL) });
+  const result = await publicClient.readContract({
+    address: CTF_ADDRESS,
+    abi: CTF_ABI,
+    functionName: "getConditionId",
+    args: [opts.oracle, opts.question, BigInt(opts.outcomes)]
+  });
+  out7({ conditionId: result });
+});
+ctfCommand.command("collection-id").description("Compute collection ID").requiredOption("--condition <id>", "Condition ID").requiredOption("--index-set <n>", "Index set", parseInt).action(async (opts) => {
+  const publicClient = createPublicClient3({ chain: polygon4, transport: http4(RPC_URL) });
+  const result = await publicClient.readContract({
+    address: CTF_ADDRESS,
+    abi: CTF_ABI,
+    functionName: "getCollectionId",
+    args: [ZERO_BYTES322, opts.condition, BigInt(opts.indexSet)]
+  });
+  out7({ collectionId: result });
+});
+ctfCommand.command("position-id").description("Compute position ID").requiredOption("--collection <id>", "Collection ID").action(async (opts) => {
+  const publicClient = createPublicClient3({ chain: polygon4, transport: http4(RPC_URL) });
+  const result = await publicClient.readContract({
+    address: CTF_ADDRESS,
+    abi: CTF_ABI,
+    functionName: "getPositionId",
+    args: [USDCE_ADDRESS, opts.collection]
+  });
+  out7({ positionId: result.toString() });
+});
+
+// src/commands/resolve.ts
+import { Command as Command14 } from "commander";
+var out8 = (data) => console.log(JSON.stringify(data, null, 2));
+var resolveCommand = new Command14("resolve").description("Resolve a Polymarket URL/username to event ID, market ID, condition ID, token IDs, or wallet address").argument("<url>", "e.g. https://polymarket.com/event/<slug>, @username").action(async (input) => {
+  const profileMatch = input.match(/(?:polymarket\.com\/)?\@([^/?\s]+)/) || (!input.includes("/") && input.startsWith("@") ? [null, input.slice(1)] : null);
+  if (profileMatch) {
+    const username = profileMatch[1];
+    const res = await fetch(`https://polymarket.com/@${username}`);
+    if (!res.ok) throw new Error(`Profile not found: @${username}`);
+    const html = await res.text();
+    const walletMatch = html.match(/"proxyWallet":"(0x[a-fA-F0-9]+)"/);
+    if (!walletMatch) throw new Error(`Could not resolve @${username}`);
+    out8({ type: "profile", username, address: walletMatch[1] });
+    return;
+  }
+  const eventMatch = input.match(/(?:polymarket\.com\/)?event\/([^/?\s]+)(?:\/([^/?\s]+))?/);
+  if (eventMatch) {
+    const eventSlug = eventMatch[1];
+    const marketSlug = eventMatch[2];
+    const gamma = new GammaClient();
+    const events = await gamma.getEvents({ slug: eventSlug });
+    if (!events || events.length === 0) throw new Error(`Event not found: ${eventSlug}`);
+    const event = events[0];
+    const result = {
+      type: "event",
+      eventId: event.id,
+      slug: event.slug,
+      title: event.title
+    };
+    if (marketSlug) {
+      const markets = await gamma.getMarkets({ slug: marketSlug });
+      if (markets && markets.length > 0) {
+        const market = markets[0];
+        result.type = "market";
+        result.marketId = market.id;
+        result.marketSlug = market.slug;
+        result.conditionId = market.conditionId;
+        result.question = market.question;
+        if (market.clobTokenIds) {
+          try {
+            result.tokenIds = JSON.parse(market.clobTokenIds);
+          } catch {
+          }
+        }
+      }
+    }
+    out8(result);
+    return;
+  }
+  throw new Error(`Unrecognized format. Expected a Polymarket URL, event slug, or @username.`);
+});
+
+// src/commands/setup.ts
+import { Command as Command15 } from "commander";
+import { privateKeyToAccount as privateKeyToAccount8 } from "viem/accounts";
+import { createPublicClient as createPublicClient4, http as http5, formatUnits as formatUnits2 } from "viem";
+import { polygon as polygon5 } from "viem/chains";
+import { select, confirm, password } from "@inquirer/prompts";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var red = (s) => `\x1B[31m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+function step(n, total, title) {
+  console.log(`
+${bold(`[${n}/${total}]`)} ${bold(title)}`);
+}
+async function pollTransaction(relayer, txId) {
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 3e3));
+    try {
+      const tx = await relayer.getTransaction(txId);
+      const state = Array.isArray(tx) ? tx[0]?.state : tx?.state;
+      if (state === "STATE_CONFIRMED" || state === "STATE_MINED") {
+        console.log(` ${green("done")}`);
+        return true;
+      }
+      if (state === "STATE_FAILED") {
+        console.log(` ${red("failed")}`);
+        return false;
+      }
+    } catch {
+    }
+    process.stdout.write(".");
+  }
+  console.log(` ${red("timeout")}`);
+  return false;
+}
+function updateEnvFile(vars) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  let content = "";
+  if (existsSync2(CONFIG_ENV_PATH)) {
+    content = readFileSync2(CONFIG_ENV_PATH, "utf-8");
+  }
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content = content.trimEnd() + `
+${key}=${value}
+`;
+    }
+  }
+  writeFileSync(CONFIG_ENV_PATH, content, { mode: 384 });
+}
+var setupCommand = new Command15("setup").description("Interactive setup wizard for Polymarket trading").action(async () => {
+  console.log(bold("\nPolymarket CLI Setup\n"));
+  let privateKey;
+  let eoaAddress;
+  const existingKey = process.env.POLYMARKET_PRIVATE_KEY;
+  if (existingKey) {
+    privateKey = resolvePrivateKey(existingKey);
+    const account = privateKeyToAccount8(privateKey);
+    eoaAddress = account.address;
+    step(1, 4, "Wallet");
+    console.log(`  ${green("Found existing key in environment")}`);
+    console.log(`  EOA: ${cyan(eoaAddress)}`);
+  } else {
+    step(1, 4, "Wallet");
+    const walletChoice = await select({
+      message: "How would you like to set up your wallet?",
+      choices: [
+        { name: "Import existing private key", value: "import" },
+        { name: "Generate new wallet", value: "generate" }
+      ]
+    });
+    if (walletChoice === "import") {
+      const keyInput = await password({
+        message: "Enter your private key:",
+        mask: "*"
+      });
+      privateKey = resolvePrivateKey(keyInput);
+      const account = privateKeyToAccount8(privateKey);
+      eoaAddress = account.address;
+      updateEnvFile({ POLYMARKET_PRIVATE_KEY: privateKey });
+      console.log(`  EOA: ${cyan(eoaAddress)}`);
+      console.log(`  ${green("Saved to ~/.polytown/.env")}`);
+    } else {
+      const wallet = createRandomWallet();
+      privateKey = wallet.privateKey;
+      eoaAddress = wallet.address;
+      updateEnvFile({ POLYMARKET_PRIVATE_KEY: privateKey });
+      console.log(`  EOA: ${cyan(eoaAddress)}`);
+      console.log(`  Private Key: ${yellow(wallet.privateKey)}`);
+      console.log(`  ${green("Saved to ~/.polytown/.env")}`);
+    }
+  }
+  step(2, 4, "Gnosis Safe");
+  const safeAddress = deriveGnosisSafeWallet(eoaAddress);
+  console.log(`  Safe: ${cyan(safeAddress)}`);
+  const relayer = new RelayerClient();
+  const deployed = await relayer.isDeployed(safeAddress);
+  if (deployed) {
+    console.log(`  Status: ${green("deployed")}`);
+  } else {
+    console.log(`  Status: ${yellow("not deployed")}`);
+    const doDeploy = await confirm({
+      message: "Deploy your Gnosis Safe now? (gas-free via relayer)",
+      default: true
+    });
+    if (doDeploy) {
+      process.stdout.write("  Deploying...");
+      const result = await deploySafe(privateKey);
+      if (result.alreadyDeployed) {
+        console.log(` ${green("already deployed")}`);
+      } else {
+        await pollTransaction(relayer, result.transactionID);
+      }
+    } else {
+      console.log(dim("  Skipped. Run later: polymarket approve deploy"));
+    }
+  }
+  step(3, 4, "Token Approvals");
+  const publicClient = createPublicClient4({
+    chain: polygon5,
+    transport: http5(RPC_URL)
+  });
+  const [usdcCtf, usdcNeg, ctfCtf, ctfNeg] = await Promise.all([
+    publicClient.readContract({
+      address: USDCE_ADDRESS,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [safeAddress, CTF_EXCHANGE]
+    }),
+    publicClient.readContract({
+      address: USDCE_ADDRESS,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [safeAddress, NEG_RISK_CTF_EXCHANGE]
+    }),
+    publicClient.readContract({
+      address: CTF_ADDRESS,
+      abi: ERC1155_ABI,
+      functionName: "isApprovedForAll",
+      args: [safeAddress, CTF_EXCHANGE]
+    }),
+    publicClient.readContract({
+      address: CTF_ADDRESS,
+      abi: ERC1155_ABI,
+      functionName: "isApprovedForAll",
+      args: [safeAddress, NEG_RISK_CTF_EXCHANGE]
+    })
+  ]);
+  const allApproved = usdcCtf > 0n && usdcNeg > 0n && ctfCtf && ctfNeg;
+  const tag = (ok) => ok ? green("approved") : red("not approved");
+  console.log(`  USDC.e -> CTF Exchange:      ${tag(usdcCtf > 0n)}`);
+  console.log(`  USDC.e -> Neg Risk Exchange:  ${tag(usdcNeg > 0n)}`);
+  console.log(`  CTF    -> CTF Exchange:       ${tag(ctfCtf)}`);
+  console.log(`  CTF    -> Neg Risk Exchange:   ${tag(ctfNeg)}`);
+  if (!allApproved) {
+    const doApprove = await confirm({
+      message: "Set all approvals now? (gas-free via relayer)",
+      default: true
+    });
+    if (doApprove) {
+      process.stdout.write("  Approving...");
+      try {
+        const txns = buildApproveCalldata();
+        const result = await relayMultiSend(privateKey, txns, "approve");
+        await pollTransaction(relayer, result.transactionID);
+      } catch (e) {
+        console.log(` ${red("failed")}: ${e.message}`);
+      }
+    } else {
+      console.log(dim("  Skipped. Run later: polymarket approve set"));
+    }
+  }
+  step(4, 4, "Balance");
+  const balance = await publicClient.readContract({
+    address: USDCE_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [safeAddress]
+  });
+  const formatted = formatUnits2(balance, 6);
+  if (balance > 0n) {
+    console.log(`  USDC.e: ${green(`$${formatted}`)}`);
+    console.log(green(bold("\n  Setup complete! You're ready to trade.\n")));
+  } else {
+    console.log(`  USDC.e: ${yellow("$0.00")}`);
+    console.log(`
+  Send ${bold("USDC.e")} on ${bold("Polygon")} to:`);
+    console.log(`  ${cyan(safeAddress)}
+`);
+  }
+});
+
+// src/commands/movers.ts
+import { Command as Command16 } from "commander";
+var CATEGORIES = [
+  "all",
+  "sports",
+  "politics",
+  "crypto",
+  "culture",
+  "weather",
+  "economics",
+  "tech",
+  "finance"
+];
+var moversCommand = new Command16("movers").description("Get biggest movers (highest price change markets)").option(
+  "--category <category>",
+  `Filter by category (${CATEGORIES.join(", ")})`
+).action(async (opts) => {
+  const params = {};
+  if (opts.category && opts.category !== "all") {
+    params.category = opts.category;
+  }
+  const url = new URL("https://polymarket.com/api/biggest-movers");
+  for (const [k, v] of Object.entries(params)) {
+    url.searchParams.set(k, v);
+  }
+  const res = await fetch(url.toString());
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+  }
+  const data = await res.json();
+  console.log(JSON.stringify(data.markets || [], null, 2));
+});
+
+// src/index.ts
+program.name("polytown").description("Polymarket CLI in Bun/TypeScript").version("0.1.0");
+program.addCommand(statusCommand);
+program.addCommand(marketsCommand);
+program.addCommand(eventsCommand);
+program.addCommand(tagsCommand);
+program.addCommand(seriesCommand);
+program.addCommand(commentsCommand);
+program.addCommand(profilesCommand);
+program.addCommand(sportsCommand);
+program.addCommand(clobCommand);
+program.addCommand(walletCommand);
+program.addCommand(dataCommand);
+program.addCommand(approveCommand);
+program.addCommand(ctfCommand);
+program.addCommand(resolveCommand);
+program.addCommand(setupCommand);
+program.addCommand(moversCommand);
+process.on("unhandledRejection", (err) => {
+  console.error(`\x1B[31merror:\x1B[0m ${err?.message ?? err}`);
+  process.exit(1);
+});
+program.parseAsync(process.argv);