hunch-cup 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# hunch-cup
+
+One-line CLI + typed SDK to play the **Hunch Cup** — a risk-free, **paper-trading**
+prediction-market tournament. Claim **1,000 $pHUNCH** (paper money, zero real-funds
+risk), trade the live Hunch catalog, run a 24/7 agent, and climb a public leaderboard
+scored on realized PnL. The top 50 wallets split a real **$5,000**.
+
+> Everything here is **paper**. $pHUNCH never touches a chain and is never redeemable.
+> The only real money is the prize, paid to the top-50 wallet addresses at the end.
+
+## CLI
+
+```bash
+# 1. Generate a wallet and claim 1,000 $pHUNCH (prints a private key — save it!)
+npx hunch-cup wallet new
+
+export HUNCH_CUP_PRIVATE_KEY=0x...   # the key it printed
+
+# 2. Look around
+npx hunch-cup markets
+npx hunch-cup quote <slug> yes 25
+
+# 3. Trade (a REAL paper trade is signed automatically by your key)
+npx hunch-cup trade <slug> yes 25
+
+# Binary markets take `yes`/`no` (up/down markets accept `yes`/`no` too).
+# Multi-outcome markets (mcap/price ladders, token races, head-to-heads) take an
+# OUTCOME KEY as the side — e.g. a ladder bucket key like `63m-67m`, or a token
+# candidate key like `zec`. Recurring markets trade on their current round.
+
+# 4. Or let an agent do it — momentum | contrarian | news-reactive
+npx hunch-cup run momentum 25            # dry-run (simulated)
+npx hunch-cup run contrarian 25 --live   # actually place trades
+
+npx hunch-cup board
+```
+
+Env: `HUNCH_CUP_PRIVATE_KEY`, `HUNCH_CUP_BASE_URL` (default `https://www.playhunch.xyz`),
+`HUNCH_CUP_SIZE` (default 25), `HUNCH_CUP_SENTIMENT` (for `news-reactive`).
+
+## SDK
+
+```ts
+import { CupClient, fromPrivateKey } from "hunch-cup";
+
+const client = new CupClient({ signer: fromPrivateKey(process.env.HUNCH_CUP_PRIVATE_KEY!) });
+
+await client.createWallet();                       // claim 1,000 $pHUNCH (once)
+const markets = await client.listMarkets();
+await client.simulateTrade(markets[0].slug, "yes", 25);   // dry run, no signature
+await client.trade({ slug: markets[0].slug, side: "yes", sizePhunch: 25 }); // signed
+await client.getPositions();
+await client.getLeaderboard({ wallet: client.address });
+
+// Built-in strategy templates (pure deciders, you control execution):
+await client.runStrategy({ strategy: "momentum", sizePhunch: 25, live: true });
+```
+
+## How auth works
+
+Reads are public. A **real** paper trade is proven with an **EIP-191 signature** over a
+canonical message binding `{ wallet, market, side, size, tradeId, issuedAt }` — so only a
+wallet's owner can spend its $pHUNCH. The SDK/CLI signs for you. A `simulate` trade writes
+nothing and needs no signature.
+
+## MCP
+
+There's also a remote MCP server at `https://www.playhunch.xyz/api/cup/mcp`
+(`create_wallet`, `list_markets`, `get_quote`, `place_paper_trade`, `get_positions`,
+`get_leaderboard`, `getting_started`). `place_paper_trade` defaults to simulate.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * `npx hunch-cup` — one-line Hunch Cup paper-trading agent (S8, scope §8.2.3).
+ *
+ *   hunch-cup wallet new              generate a wallet + claim 1,000 $pHUNCH
+ *   hunch-cup markets                 list tradable paper markets
+ *   hunch-cup quote <slug> <side> <n> price a paper trade
+ *   hunch-cup trade <slug> <side> <n> place a REAL signed paper trade
+ *   hunch-cup run <strategy> [n]      run momentum|contrarian|news-reactive
+ *   hunch-cup board                   show the leaderboard
+ *
+ * Config via env: HUNCH_CUP_PRIVATE_KEY (0x…), HUNCH_CUP_BASE_URL,
+ * HUNCH_CUP_SIZE (default 25). `run` simulates by default; pass --live to trade.
+ */
+import { CupClient } from "./client.js";
+import { fromPrivateKey, newWallet } from "./signer.js";
+function baseUrl() {
+    return process.env.HUNCH_CUP_BASE_URL;
+}
+function signerFromEnv() {
+    const pk = process.env.HUNCH_CUP_PRIVATE_KEY;
+    return pk ? fromPrivateKey(pk) : undefined;
+}
+function size(arg) {
+    const n = Number(arg ?? process.env.HUNCH_CUP_SIZE ?? 25);
+    return Number.isFinite(n) && n > 0 ? n : 25;
+}
+function out(value) {
+    console.log(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+}
+async function main(argv) {
+    const [cmd, ...args] = argv;
+    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+        out([
+            "hunch-cup — paper-trade the Hunch Cup from your terminal.",
+            "",
+            "  wallet new                 generate a wallet + claim 1,000 $pHUNCH",
+            "  markets                    list tradable paper markets",
+            "  quote <slug> <side> <n>    price a paper trade",
+            "  trade <slug> <side> <n>    place a REAL signed paper trade",
+            "  run <strategy> [n] [--live]  momentum | contrarian | news-reactive",
+            "  board                      show the leaderboard",
+            "",
+            "Env: HUNCH_CUP_PRIVATE_KEY, HUNCH_CUP_BASE_URL, HUNCH_CUP_SIZE",
+        ].join("\n"));
+        return 0;
+    }
+    if (cmd === "wallet" && args[0] === "new") {
+        let signer = signerFromEnv();
+        let privateKey = process.env.HUNCH_CUP_PRIVATE_KEY;
+        if (!signer) {
+            const w = newWallet();
+            signer = w.signer;
+            privateKey = w.privateKey;
+            out(`Generated a new wallet. SAVE THIS PRIVATE KEY:\n  ${privateKey}`);
+            out(`export HUNCH_CUP_PRIVATE_KEY=${privateKey}`);
+        }
+        const client = new CupClient({ baseUrl: baseUrl(), signer });
+        out(await client.createWallet());
+        return 0;
+    }
+    if (cmd === "markets") {
+        const client = new CupClient({ baseUrl: baseUrl() });
+        out(await client.listMarkets(Number(args[0] ?? 25)));
+        return 0;
+    }
+    if (cmd === "quote") {
+        const [slug, side, n] = args;
+        if (!slug || !side)
+            return usage("quote <slug> <side> <size>");
+        const client = new CupClient({ baseUrl: baseUrl() });
+        out(await client.getQuote(slug, side, size(n)));
+        return 0;
+    }
+    if (cmd === "trade") {
+        const [slug, side, n] = args;
+        if (!slug || !side)
+            return usage("trade <slug> <side> <size>");
+        const signer = signerFromEnv();
+        if (!signer)
+            return usage("set HUNCH_CUP_PRIVATE_KEY to trade");
+        const client = new CupClient({ baseUrl: baseUrl(), signer });
+        out(await client.trade({ slug, side, sizePhunch: size(n) }));
+        return 0;
+    }
+    if (cmd === "run") {
+        const strategy = args[0];
+        if (!strategy || !["momentum", "contrarian", "news-reactive"].includes(strategy)) {
+            return usage("run <momentum|contrarian|news-reactive> [size] [--live]");
+        }
+        const live = args.includes("--live");
+        const n = args.find((a, i) => i > 0 && !a.startsWith("--"));
+        const signer = signerFromEnv();
+        if (live && !signer)
+            return usage("set HUNCH_CUP_PRIVATE_KEY to run --live");
+        const client = new CupClient({ baseUrl: baseUrl(), signer });
+        out(await client.runStrategy({
+            strategy,
+            sizePhunch: size(n),
+            sentiment: Number(process.env.HUNCH_CUP_SENTIMENT ?? 0),
+            live,
+        }));
+        return 0;
+    }
+    if (cmd === "board") {
+        const client = new CupClient({ baseUrl: baseUrl() });
+        out(await client.getLeaderboard({ limit: Number(args[0] ?? 50) }));
+        return 0;
+    }
+    return usage(`unknown command: ${cmd}`);
+}
+function usage(message) {
+    console.error(`hunch-cup: ${message}`);
+    return 1;
+}
+main(process.argv.slice(2))
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/client.d.ts

@@ -0,0 +1,84 @@
+import { type CupStrategy } from "./strategy.js";
+export declare const DEFAULT_BASE_URL = "https://www.playhunch.xyz";
+/** Minimal signer the client needs — recover-able EIP-191 `personal_sign`. */
+export interface CupSigner {
+    address: string;
+    signMessage: (message: string) => Promise<string>;
+}
+export interface CupMarket {
+    slug: string;
+    marketId: string;
+    question: string;
+    shortTitle: string;
+    tokenSymbol: string;
+    direction: boolean;
+    deadlineAt: string;
+    yesCents: number;
+    noCents: number;
+    poolPhunch: number;
+    tradeCount: number;
+}
+export interface CupTradeReceipt {
+    simulated: boolean;
+    tradeId?: string;
+    slug: string;
+    side: string;
+    sizePhunch: number;
+    shares: number;
+    balancePhunch?: number;
+    projectedPayoutPhunch?: number;
+}
+export interface CupClientOptions {
+    baseUrl?: string;
+    /** Required only to claim or place REAL trades; reads work without it. */
+    signer?: CupSigner;
+    fetchImpl?: typeof fetch;
+}
+export declare class CupClient {
+    private readonly baseUrl;
+    private readonly signer?;
+    private readonly fetchImpl;
+    constructor(opts?: CupClientOptions);
+    get address(): string | undefined;
+    private json;
+    private requireSigner;
+    /** Claim 1,000 $pHUNCH once for the signer's wallet. */
+    createWallet(): Promise<{
+        walletAddress: string;
+        balancePhunch: number;
+        minted: boolean;
+    }>;
+    listMarkets(limit?: number): Promise<CupMarket[]>;
+    getQuote(slug: string, side: string, sizePhunch: number): Promise<{
+        shares: number;
+        projectedPayoutPhunch: number;
+        poolPhunch: number;
+    }>;
+    /** A dry run — full pricing, no signature, no write. */
+    simulateTrade(slug: string, side: string, sizePhunch: number): Promise<CupTradeReceipt>;
+    /** Place a REAL signed paper trade. Idempotent by the generated/own tradeId. */
+    trade(args: {
+        slug: string;
+        side: string;
+        sizePhunch: number;
+        tradeId?: string;
+    }): Promise<CupTradeReceipt>;
+    getPositions(address?: string): Promise<unknown>;
+    getLeaderboard(opts?: {
+        limit?: number;
+        week?: number;
+        wallet?: string;
+    }): Promise<unknown>;
+    /**
+     * One round of a built-in strategy: pick a side per market and place a trade
+     * (simulated unless `live`). Returns the receipts. The decision is pure
+     * ({@link pickFor}); placement is deterministic code.
+     */
+    runStrategy(opts: {
+        strategy: CupStrategy;
+        sizePhunch: number;
+        limit?: number;
+        sentiment?: number;
+        live?: boolean;
+    }): Promise<CupTradeReceipt[]>;
+}

package/dist/client.js

@@ -0,0 +1,146 @@
+/**
+ * Hunch Cup — thin typed SDK client over `/api/cup/v1/*` (S8).
+ *
+ * Wallet-native + keyless: pass a viem `LocalAccount` (or any `CupSigner`) and
+ * the client claims your 1,000 $pHUNCH, lists/quotes paper markets, and — for a
+ * REAL trade — signs the canonical message for you (the only thing that proves
+ * wallet ownership on the paper path). Reads need no signer. Uses global `fetch`
+ * (Node ≥ 20). `viem` is an optional peer used only by {@link fromPrivateKey}.
+ */
+import { buildCupTradeMessage } from "./message.js";
+import { pickFor } from "./strategy.js";
+export const DEFAULT_BASE_URL = "https://www.playhunch.xyz";
+export class CupClient {
+    baseUrl;
+    signer;
+    fetchImpl;
+    constructor(opts = {}) {
+        this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.signer = opts.signer;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+    }
+    get address() {
+        return this.signer?.address;
+    }
+    async json(path, init) {
+        const res = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+        const body = (await res.json().catch(() => null));
+        if (!res.ok) {
+            const err = (body && body.error) || `http_${res.status}`;
+            throw new Error(`Hunch Cup ${path} failed: ${err}`);
+        }
+        return body;
+    }
+    requireSigner() {
+        if (!this.signer)
+            throw new Error("A signer is required for this action (claim/trade).");
+        return this.signer;
+    }
+    /** Claim 1,000 $pHUNCH once for the signer's wallet. */
+    async createWallet() {
+        const signer = this.requireSigner();
+        return this.json("/api/cup/v1/wallet", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ walletAddress: signer.address }),
+        });
+    }
+    async listMarkets(limit = 25) {
+        const out = await this.json(`/api/cup/v1/markets?limit=${limit}`);
+        return out.markets;
+    }
+    async getQuote(slug, side, sizePhunch) {
+        const qs = new URLSearchParams({ side, sizePhunch: String(sizePhunch) });
+        return this.json(`/api/cup/v1/markets/${slug}/quote?${qs}`);
+    }
+    /** A dry run — full pricing, no signature, no write. */
+    async simulateTrade(slug, side, sizePhunch) {
+        const out = await this.json("/api/cup/v1/trade", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                walletAddress: this.signer?.address ?? "0x" + "0".repeat(40),
+                slug,
+                side,
+                sizePhunch,
+                simulate: true,
+            }),
+        });
+        return out.receipt;
+    }
+    /** Place a REAL signed paper trade. Idempotent by the generated/own tradeId. */
+    async trade(args) {
+        const signer = this.requireSigner();
+        const tradeId = args.tradeId ?? `cup:${args.slug}:${args.side}:${randomId()}`;
+        const issuedAt = nowIso();
+        const message = buildCupTradeMessage({
+            walletAddress: signer.address,
+            slug: args.slug,
+            side: args.side,
+            sizePhunch: args.sizePhunch,
+            tradeId,
+            issuedAt,
+        });
+        const signature = await signer.signMessage(message);
+        const out = await this.json("/api/cup/v1/trade", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                walletAddress: signer.address,
+                slug: args.slug,
+                side: args.side,
+                sizePhunch: args.sizePhunch,
+                tradeId,
+                issuedAt,
+                signature,
+            }),
+        });
+        return out.receipt;
+    }
+    async getPositions(address) {
+        const addr = address ?? this.signer?.address;
+        if (!addr)
+            throw new Error("No wallet address (pass one or construct with a signer).");
+        return this.json(`/api/cup/v1/wallet/${addr}`);
+    }
+    async getLeaderboard(opts = {}) {
+        const qs = new URLSearchParams();
+        if (opts.limit)
+            qs.set("limit", String(opts.limit));
+        if (opts.week)
+            qs.set("week", String(opts.week));
+        if (opts.wallet)
+            qs.set("wallet", opts.wallet);
+        const suffix = qs.toString() ? `?${qs}` : "";
+        return this.json(`/api/cup/v1/leaderboard${suffix}`);
+    }
+    /**
+     * One round of a built-in strategy: pick a side per market and place a trade
+     * (simulated unless `live`). Returns the receipts. The decision is pure
+     * ({@link pickFor}); placement is deterministic code.
+     */
+    async runStrategy(opts) {
+        const markets = await this.listMarkets(opts.limit ?? 10);
+        const receipts = [];
+        for (const m of markets) {
+            const card = {
+                slug: m.slug,
+                yesCents: m.yesCents,
+                noCents: m.noCents,
+                direction: m.direction,
+            };
+            const pick = pickFor(opts.strategy, card, opts.sentiment ?? 0);
+            receipts.push(opts.live
+                ? await this.trade({ slug: pick.slug, side: pick.side, sizePhunch: opts.sizePhunch })
+                : await this.simulateTrade(pick.slug, pick.side, opts.sizePhunch));
+        }
+        return receipts;
+    }
+}
+function randomId() {
+    // Best-effort unique id; the server idempotency key is the full tradeId.
+    return Math.abs(Math.floor(Math.random() * 1e15)).toString(36) + Date.now().toString(36);
+}
+function nowIso() {
+    return new Date().toISOString();
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { CupClient, DEFAULT_BASE_URL } from "./client.js";
+export type { CupClientOptions, CupSigner, CupMarket, CupTradeReceipt, } from "./client.js";
+export { fromViemAccount, fromPrivateKey, newWallet } from "./signer.js";
+export { buildCupTradeMessage } from "./message.js";
+export type { CupTradeMessageParams } from "./message.js";
+export { pickFor, momentumPick, contrarianPick, newsReactivePick, } from "./strategy.js";
+export type { CupStrategy, StrategyCard, StrategyPick } from "./strategy.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { CupClient, DEFAULT_BASE_URL } from "./client.js";
+export { fromViemAccount, fromPrivateKey, newWallet } from "./signer.js";
+export { buildCupTradeMessage } from "./message.js";
+export { pickFor, momentumPick, contrarianPick, newsReactivePick, } from "./strategy.js";

package/dist/message.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The canonical Hunch Cup paper-trade signing message.
+ *
+ * MUST stay byte-identical to the server core `src/core/cup/agent-auth.ts`
+ * (`buildCupTradeMessage`) — a parity test asserts the two implementations agree.
+ * The wallet is lowercased so a checksummed vs. lowercase address signs the same
+ * bytes. Pure, dependency-free.
+ */
+export interface CupTradeMessageParams {
+    walletAddress: string;
+    slug: string;
+    side: string;
+    sizePhunch: number;
+    tradeId: string;
+    issuedAt: string;
+}
+export declare function buildCupTradeMessage(p: CupTradeMessageParams): string;

package/dist/message.js

@@ -0,0 +1,11 @@
+export function buildCupTradeMessage(p) {
+    return [
+        "Hunch Cup paper trade",
+        `Wallet: ${p.walletAddress.toLowerCase()}`,
+        `Market: ${p.slug}`,
+        `Side: ${p.side}`,
+        `Size: ${p.sizePhunch} pHUNCH`,
+        `Trade: ${p.tradeId}`,
+        `Issued: ${p.issuedAt}`,
+    ].join("\n");
+}

package/dist/signer.d.ts

@@ -0,0 +1,11 @@
+import type { LocalAccount } from "viem";
+import type { CupSigner } from "./client.js";
+/** Adapt a viem local account to a {@link CupSigner}. */
+export declare function fromViemAccount(account: LocalAccount): CupSigner;
+/** Build a {@link CupSigner} from a 0x-prefixed private key. */
+export declare function fromPrivateKey(privateKey: string): CupSigner;
+/** Generate a fresh throwaway keypair → `{ privateKey, signer }`. */
+export declare function newWallet(): {
+    privateKey: string;
+    signer: CupSigner;
+};

package/dist/signer.js

@@ -0,0 +1,21 @@
+/**
+ * viem signer bridges for the Hunch Cup client. `viem` is a runtime peer used
+ * only here, so importing the SDK without trading pulls in nothing heavy.
+ */
+import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
+/** Adapt a viem local account to a {@link CupSigner}. */
+export function fromViemAccount(account) {
+    return {
+        address: account.address,
+        signMessage: (message) => account.signMessage({ message }),
+    };
+}
+/** Build a {@link CupSigner} from a 0x-prefixed private key. */
+export function fromPrivateKey(privateKey) {
+    return fromViemAccount(privateKeyToAccount(privateKey));
+}
+/** Generate a fresh throwaway keypair → `{ privateKey, signer }`. */
+export function newWallet() {
+    const privateKey = generatePrivateKey();
+    return { privateKey, signer: fromPrivateKey(privateKey) };
+}

package/dist/strategy.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Hunch Cup — built-in trading strategy templates (S8, scope §8.2.4).
+ *
+ * Pure, deterministic deciders. The LLM (if any) NEVER executes — a strategy
+ * maps a market card to a concrete `{ side }` and order placement is plain code.
+ * Direction markets resolve to UP/DOWN; binary markets to YES/NO.
+ */
+export interface StrategyCard {
+    slug: string;
+    /** Implied paper-pool probability of the positive outcome, in cents (0–100). */
+    yesCents: number;
+    /** Implied paper-pool probability of the negative outcome, in cents (0–100). */
+    noCents: number;
+    /** True → the positive/negative outcomes are UP/DOWN, not YES/NO. */
+    direction: boolean;
+}
+export interface StrategyPick {
+    slug: string;
+    side: string;
+}
+export type CupStrategy = "momentum" | "contrarian" | "news-reactive";
+/** Momentum: trade WITH the crowd — back the pool's favorite. */
+export declare function momentumPick(card: StrategyCard): StrategyPick;
+/** Contrarian: fade the crowd — back the underdog. */
+export declare function contrarianPick(card: StrategyCard): StrategyPick;
+/**
+ * News-reactive: trade off an external sentiment signal in [-1, 1] (e.g. a
+ * headline classifier). Positive → back the positive outcome; negative → the
+ * negative; a neutral 0 falls back to the pool favorite.
+ */
+export declare function newsReactivePick(card: StrategyCard, sentiment: number): StrategyPick;
+/** Dispatch a named strategy. `news-reactive` uses `sentiment` (default 0). */
+export declare function pickFor(strategy: CupStrategy, card: StrategyCard, sentiment?: number): StrategyPick;

package/dist/strategy.js

@@ -0,0 +1,49 @@
+/**
+ * Hunch Cup — built-in trading strategy templates (S8, scope §8.2.4).
+ *
+ * Pure, deterministic deciders. The LLM (if any) NEVER executes — a strategy
+ * maps a market card to a concrete `{ side }` and order placement is plain code.
+ * Direction markets resolve to UP/DOWN; binary markets to YES/NO.
+ */
+/** The outcome label for a pole on this card (UP/DOWN vs YES/NO). */
+function sideFor(card, pole) {
+    if (card.direction)
+        return pole === "pos" ? "up" : "down";
+    return pole === "pos" ? "yes" : "no";
+}
+/** The pool's favorite pole (ties → positive). */
+function favorite(card) {
+    return card.yesCents >= card.noCents ? "pos" : "neg";
+}
+/** Momentum: trade WITH the crowd — back the pool's favorite. */
+export function momentumPick(card) {
+    return { slug: card.slug, side: sideFor(card, favorite(card)) };
+}
+/** Contrarian: fade the crowd — back the underdog. */
+export function contrarianPick(card) {
+    const pole = favorite(card) === "pos" ? "neg" : "pos";
+    return { slug: card.slug, side: sideFor(card, pole) };
+}
+/**
+ * News-reactive: trade off an external sentiment signal in [-1, 1] (e.g. a
+ * headline classifier). Positive → back the positive outcome; negative → the
+ * negative; a neutral 0 falls back to the pool favorite.
+ */
+export function newsReactivePick(card, sentiment) {
+    if (sentiment > 0)
+        return { slug: card.slug, side: sideFor(card, "pos") };
+    if (sentiment < 0)
+        return { slug: card.slug, side: sideFor(card, "neg") };
+    return momentumPick(card);
+}
+/** Dispatch a named strategy. `news-reactive` uses `sentiment` (default 0). */
+export function pickFor(strategy, card, sentiment = 0) {
+    switch (strategy) {
+        case "momentum":
+            return momentumPick(card);
+        case "contrarian":
+            return contrarianPick(card);
+        case "news-reactive":
+            return newsReactivePick(card, sentiment);
+    }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "hunch-cup",
+  "version": "0.1.0",
+  "description": "One-line CLI + typed SDK to paper-trade the Hunch Cup tournament: claim 1,000 $pHUNCH, trade live markets with zero real-funds risk, run momentum/contrarian/news-reactive agents, and climb the public leaderboard.",
+  "keywords": [
+    "hunch",
+    "hunch-cup",
+    "prediction-markets",
+    "paper-trading",
+    "agents",
+    "mcp",
+    "phunch"
+  ],
+  "homepage": "https://www.playhunch.xyz/cup",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "hunch-cup": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "viem": ">=2"
+  },
+  "devDependencies": {
+    "@types/node": ">=20"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}