context-markets-react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Context
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+<p align="center">
+  <img src="https://mainnet.contextcdn.com/ced823d63df9dff0390d9ad0a4e1ad3905dd199a6c50758c18a5c92a203adbd7" alt="Context" width="100%" />
+</p>
+
+<h1 align="center">Context React</h1>
+<p align="center">React hooks for <a href="https://context.markets">Context Markets</a> — built on <code>context-markets</code> and TanStack Query.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/context-markets-react"><img src="https://img.shields.io/npm/v/context-markets-react" alt="npm" /></a>
+  <a href="https://github.com/contextwtf/context-react/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License: MIT" /></a>
+  <a href="https://discord.gg/RVmzZsAyM4"><img src="https://img.shields.io/badge/Discord-Join-7289da" alt="Discord" /></a>
+</p>
+
+## Install
+
+```bash
+npm install context-markets-react context-markets @tanstack/react-query wagmi viem
+# or
+yarn add context-markets-react context-markets @tanstack/react-query wagmi viem
+# or
+pnpm add context-markets-react context-markets @tanstack/react-query wagmi viem
+```
+
+## Quick Start
+
+### 1. Wrap your app with providers
+
+```tsx
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+import { WagmiProvider } from "wagmi"
+import { ContextProvider } from "context-markets-react"
+import { wagmiConfig } from "./wagmi"
+
+const queryClient = new QueryClient()
+
+function App({ children }: { children: React.ReactNode }) {
+  return (
+    <WagmiProvider config={wagmiConfig}>
+      <QueryClientProvider client={queryClient}>
+        <ContextProvider apiKey={process.env.NEXT_PUBLIC_CONTEXT_API_KEY!}>
+          {children}
+        </ContextProvider>
+      </QueryClientProvider>
+    </WagmiProvider>
+  )
+}
+```
+
+### 2. Use hooks
+
+```tsx
+import { useMarkets, useQuotes } from "context-markets-react"
+
+function MarketList() {
+  const { data, isLoading } = useMarkets({ status: "active", sortBy: "trending" })
+
+  if (isLoading) return <div>Loading...</div>
+
+  return (
+    <ul>
+      {data?.markets.map((m) => (
+        <li key={m.id}>{m.question}</li>
+      ))}
+    </ul>
+  )
+}
+```
+
+## Available Hooks
+
+**Markets** — `useMarkets` · `useSearchMarkets` · `useMarket` · `useOrderbook` · `useQuotes` · `usePriceHistory` · `useMarketActivity` · `useSimulateTrade` · `useOracle` · `useLatestOracleQuote`
+
+**Orders** — `useOrders` · `useOrder` · `useCreateOrder` · `useCreateMarketOrder` · `useCancelOrder` · `useCancelReplace`
+
+**Portfolio** — `usePortfolio` · `usePositions` · `useBalance` · `useClaimable` · `usePortfolioStats`
+
+**Account** — `useAccountStatus` · `useAccountSetup` · `useDeposit` · `useWithdraw`
+
+**Questions** — `useSubmitQuestion` · `useSubmitAndWait` · `useCreateMarket` · `useAgentSubmit` · `useAgentSubmitAndWait`
+
+**Utilities** — `ContextProvider` · `useContextClient` · `contextKeys` · `ContextWalletError`
+
+## Peer Dependencies
+
+`react` >= 18 · `@tanstack/react-query` >= 5 · `wagmi` >= 2 · `viem` >= 2 · `context-markets` >= 0.4
+
+## Documentation
+
+- **[React SDK Guide](https://docs.context.markets/agents/react-sdk)** — setup, providers, and first component
+- **[Hooks Reference](https://docs.context.markets/agents/react-sdk/hooks-reference)** — full list of hooks and parameters
+- **[Best Practices](https://docs.context.markets/agents/react-sdk/best-practices)** — patterns, error handling, and tips
+
+## Ecosystem
+
+| Package | Description |
+|---------|-------------|
+| **[context-markets](https://github.com/contextwtf/context-sdk)** | TypeScript SDK for trading |
+| **[context-markets-react](https://github.com/contextwtf/context-react)** | React hooks for market data and trading |
+| **[@contextwtf/mcp](https://github.com/contextwtf/context-mcp)** | MCP server for AI agents |
+| **[@contextwtf/cli](https://github.com/contextwtf/context-cli)** | CLI for trading from the terminal |
+| **[context-skills](https://github.com/contextwtf/context-skills)** | AI agent skill files |
+| **[context-plugin](https://github.com/contextwtf/context-plugin)** | Claude Code plugin |
+
+## License
+
+MIT — see [LICENSE](./LICENSE) for details.

package/dist/index.d.ts

@@ -0,0 +1,321 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import * as context_markets from 'context-markets';
+import { ContextClient, Balance, ClaimableResponse, GetPortfolioParams, Portfolio, PortfolioStats, GetPositionsParams, PositionList, OracleQuoteLatest, Market, GetActivityParams, ActivityResponse, SearchMarketsParams, MarketList, GetOrderbookParams, Orderbook, GetPriceHistoryParams, PriceHistory, Quotes, MarketSearchParams, MarketSearchResult, SimulateTradeParams, SimulateResult, GaslessOperatorResult, WalletSetupResult, WalletStatus, GaslessDepositResult, Order, GetOrdersParams, OrderList, CancelResult, CancelReplaceResult, PlaceOrderRequest, CreateOrderResult, PlaceMarketOrderRequest, SubmitQuestionResult, AgentSubmitMarketDraft, QuestionSubmission, SubmitAndWaitOptions, CreateMarketResult } from 'context-markets';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { Address, Hex } from 'viem';
+
+interface ContextProviderProps {
+    apiKey: string;
+    rpcUrl?: string;
+    baseUrl?: string;
+    children: ReactNode;
+}
+declare function ContextProvider({ apiKey, rpcUrl, baseUrl, children, }: ContextProviderProps): react_jsx_runtime.JSX.Element;
+declare function useContextClient(): ContextClient;
+
+declare const contextKeys: {
+    readonly markets: {
+        readonly all: readonly ["context", "markets"];
+        readonly list: (params?: Record<string, unknown>) => readonly ["context", "markets", "list", Record<string, unknown>] | readonly ["context", "markets", "list"];
+        readonly search: (q: string, params?: Record<string, unknown>) => readonly ["context", "markets", "search", string, Record<string, unknown>] | readonly ["context", "markets", "search", string];
+        readonly get: (id: string) => readonly ["context", "markets", "get", string];
+        readonly orderbook: (id: string, params?: Record<string, unknown>) => readonly ["context", "markets", "orderbook", string, Record<string, unknown>] | readonly ["context", "markets", "orderbook", string];
+        readonly quotes: (id: string) => readonly ["context", "markets", "quotes", string];
+        readonly priceHistory: (id: string, params?: Record<string, unknown>) => readonly ["context", "markets", "priceHistory", string, Record<string, unknown>] | readonly ["context", "markets", "priceHistory", string];
+        readonly activity: (id: string, params?: Record<string, unknown>) => readonly ["context", "markets", "activity", string, Record<string, unknown>] | readonly ["context", "markets", "activity", string];
+        readonly simulate: (params: Record<string, unknown>) => readonly ["context", "markets", "simulate", Record<string, unknown>];
+        readonly oracle: (id: string) => readonly ["context", "markets", "oracle", string];
+        readonly latestOracleQuote: (id: string) => readonly ["context", "markets", "latestOracleQuote", string];
+    };
+    readonly orders: {
+        readonly all: readonly ["context", "orders"];
+        readonly list: (params?: Record<string, unknown>) => readonly ["context", "orders", "list", Record<string, unknown>] | readonly ["context", "orders", "list"];
+        readonly get: (id: string) => readonly ["context", "orders", "get", string];
+    };
+    readonly portfolio: {
+        readonly all: readonly ["context", "portfolio"];
+        readonly get: (address?: string, params?: Record<string, unknown>) => readonly ["context", "portfolio", "get", string, ...Record<string, unknown>[]] | readonly ["context", "portfolio", "get"];
+        readonly balance: (address?: string) => readonly ["context", "portfolio", "balance", string] | readonly ["context", "portfolio", "balance"];
+        readonly claimable: (address?: string) => readonly ["context", "portfolio", "claimable", string] | readonly ["context", "portfolio", "claimable"];
+        readonly stats: (address?: string) => readonly ["context", "portfolio", "stats", string] | readonly ["context", "portfolio", "stats"];
+        readonly positions: (address?: string, params?: Record<string, unknown>) => readonly ["context", "portfolio", "positions", string, ...Record<string, unknown>[]] | readonly ["context", "portfolio", "positions"];
+    };
+    readonly account: {
+        readonly all: readonly ["context", "account"];
+        readonly status: () => readonly ["context", "account", "status"];
+    };
+};
+
+declare class ContextWalletError extends Error {
+    name: string;
+    constructor(hookName: string);
+}
+
+declare function usePortfolio(address?: Address, params?: GetPortfolioParams, options?: Omit<UseQueryOptions<Portfolio>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    portfolio: context_markets.ApiComponents["schemas"]["Position"][];
+    marketIds: string[];
+    cursor: string | null;
+}, Error>;
+declare function useBalance(address?: Address, options?: Omit<UseQueryOptions<Balance>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    address: string;
+    usdc: {
+        tokenAddress: string;
+        balance: string;
+        settlementBalance: string;
+        walletBalance: string;
+    };
+    outcomeTokens: context_markets.ApiComponents["schemas"]["OutcomeTokenBalance"][];
+}, Error>;
+declare function useClaimable(address?: Address, options?: Omit<UseQueryOptions<ClaimableResponse>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    positions: context_markets.ApiComponents["schemas"]["ClaimablePosition"][];
+    markets: context_markets.ApiComponents["schemas"]["ClaimableMarket"][];
+    totalClaimable: string;
+}, Error>;
+declare function usePortfolioStats(address?: Address, options?: Omit<UseQueryOptions<PortfolioStats>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    currentPortfolioValue: string;
+    currentPortfolioPercentChange: number;
+    predictionsPlaced: number;
+    totalPlaced: string;
+    allTimeWinLoss: string;
+    allTimeReturnPct: number;
+}, Error>;
+declare function usePositions(address?: Address, params?: GetPositionsParams, options?: Omit<UseQueryOptions<PositionList>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    positions: context_markets.ApiComponents["schemas"]["PortfolioPosition"][];
+    cursor: string | null;
+}, Error>;
+
+declare function useMarkets(params?: SearchMarketsParams, options?: Omit<UseQueryOptions<MarketList>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    markets: context_markets.ApiComponents["schemas"]["Market"][];
+    cursor: string | null;
+}, Error>;
+declare function useSearchMarkets(params: MarketSearchParams, options?: Omit<UseQueryOptions<MarketSearchResult>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MarketSearchResult, Error>;
+declare function useMarket(marketId: string, options?: Omit<UseQueryOptions<Market>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    id: string;
+    oracle: string;
+    question: string;
+    questionSubmissionId?: string | null;
+    shortQuestion: string;
+    outcomeTokens: string[];
+    outcomePrices: context_markets.ApiComponents["schemas"]["OutcomePrice"][];
+    creator: string;
+    creatorProfile: {
+        username: string | null;
+        avatarUrl: string | null;
+    } | null;
+    blockTime: string;
+    chainId: string;
+    txHash: string;
+    volume: string;
+    volume24h: string;
+    participantCount: number;
+    executableAt: string | null;
+    proposedAt: string | null;
+    resolvedAt: string | null;
+    payoutPcts: number[] | null;
+    resolutionStatus: "none" | "pending" | "resolved";
+    metadata: context_markets.ApiComponents["schemas"]["MarketMetadata"];
+    resolutionCriteria: string;
+    deadline: string;
+    status: "active" | "pending" | "resolved" | "closed";
+    createdAt: string;
+    outcome: number | null;
+    contractAddress: string;
+}, Error>;
+declare function useOrderbook(marketId: string, params?: GetOrderbookParams, options?: Omit<UseQueryOptions<Orderbook>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    marketId: string;
+    bids: {
+        price: number;
+        size: number;
+    }[];
+    asks: {
+        price: number;
+        size: number;
+    }[];
+    timestamp: string;
+}, Error>;
+declare function useQuotes(marketId: string, options?: Omit<UseQueryOptions<Quotes>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    marketId: string;
+    yes: {
+        bid: number | null;
+        ask: number | null;
+        last: number | null;
+    };
+    no: {
+        bid: number | null;
+        ask: number | null;
+        last: number | null;
+    };
+    spread: number | null;
+    timestamp: string;
+}, Error>;
+declare function usePriceHistory(marketId: string, params?: GetPriceHistoryParams, options?: Omit<UseQueryOptions<PriceHistory>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    prices: {
+        time: number;
+        price: number;
+    }[];
+    startTime: number;
+    endTime: number;
+    interval: number;
+}, Error>;
+declare function useMarketActivity(marketId: string, params?: GetActivityParams, options?: Omit<UseQueryOptions<ActivityResponse>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    marketId?: string;
+    activity: context_markets.ApiComponents["schemas"]["ActivityItem"][];
+    pagination: context_markets.ApiComponents["schemas"]["Pagination"];
+}, Error>;
+declare function useSimulateTrade(marketId: string, params: SimulateTradeParams, options?: Omit<UseQueryOptions<SimulateResult>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    marketId: string;
+    side: "yes" | "no";
+    amount: number;
+    amountType: "usd" | "contracts";
+    estimatedContracts: number;
+    estimatedAvgPrice: number;
+    estimatedSlippage: number;
+    warnings: context_markets.ApiComponents["schemas"]["SimulateWarning"][];
+}, Error>;
+declare function useOracle(marketId: string, options?: Omit<UseQueryOptions<any>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<any, Error>;
+declare function useLatestOracleQuote(marketId: string, options?: Omit<UseQueryOptions<OracleQuoteLatest>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    quote: context_markets.ApiComponents["schemas"]["OracleQuote"] & unknown;
+}, Error>;
+
+declare function useAccountStatus(options?: Omit<UseQueryOptions<WalletStatus>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<WalletStatus, Error>;
+declare function useAccountSetup(options?: Omit<UseMutationOptions<GaslessOperatorResult | WalletSetupResult, Error, void>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    success: true;
+    txHash: string;
+    user: string;
+    operator: string;
+    relayer: string;
+} | WalletSetupResult, Error, void, unknown>;
+declare function useDeposit(options?: Omit<UseMutationOptions<GaslessDepositResult | Hex, Error, number>, "mutationFn">): _tanstack_react_query.UseMutationResult<`0x${string}` | {
+    success: true;
+    txHash: string;
+    user: string;
+    token: string;
+    amount: string;
+    relayer: string;
+}, Error, number, unknown>;
+declare function useWithdraw(options?: Omit<UseMutationOptions<Hex, Error, number>, "mutationFn">): _tanstack_react_query.UseMutationResult<`0x${string}`, Error, number, unknown>;
+
+declare function useOrders(params?: GetOrdersParams, options?: Omit<UseQueryOptions<OrderList>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    orders: context_markets.ApiComponents["schemas"]["OrderWithAvgFillPrice"][];
+    markets: {
+        [key: string]: context_markets.ApiComponents["schemas"]["OrderMarketInfo"];
+    };
+    cursor: string | null;
+}, Error>;
+declare function useOrder(orderId: string, options?: Omit<UseQueryOptions<Order>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<{
+    marketId: string;
+    trader: string;
+    nonce: string;
+    side: 0 | 1;
+    price: string;
+    size: string;
+    filledSize: string;
+    remainingSize: string;
+    percentFilled: number;
+    insertedAt: string;
+    type: "limit" | "market";
+    status: "open" | "filled" | "cancelled" | "expired" | "voided";
+    voidedAt: string | null;
+    voidReason: "UNFILLED_MARKET_ORDER" | "UNDER_COLLATERALIZED" | "MISSING_OPERATOR_APPROVAL" | "BELOW_MIN_FILL_SIZE" | "INVALID_SIGNATURE" | "MARKET_RESOLVED" | "ADMIN_VOID" | null;
+    outcomeIndex: number;
+}, Error>;
+
+declare function useCreateOrder(options?: Omit<UseMutationOptions<CreateOrderResult, Error, PlaceOrderRequest>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    success: true;
+    order: context_markets.ApiComponents["schemas"]["Order"];
+}, Error, PlaceOrderRequest, unknown>;
+declare function useCreateMarketOrder(options?: Omit<UseMutationOptions<CreateOrderResult, Error, PlaceMarketOrderRequest>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    success: true;
+    order: context_markets.ApiComponents["schemas"]["Order"];
+}, Error, PlaceMarketOrderRequest, unknown>;
+declare function useCancelOrder(options?: Omit<UseMutationOptions<CancelResult, Error, Hex>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    success: boolean;
+    alreadyCancelled: boolean;
+}, Error, `0x${string}`, unknown>;
+declare function useCancelReplace(options?: Omit<UseMutationOptions<CancelReplaceResult, Error, {
+    cancelNonce: Hex;
+    newOrder: PlaceOrderRequest;
+}>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    cancel: context_markets.ApiComponents["schemas"]["CancelDetail"];
+    create: context_markets.ApiComponents["schemas"]["OrderCreated"];
+}, Error, {
+    cancelNonce: Hex;
+    newOrder: PlaceOrderRequest;
+}, unknown>;
+
+declare function useSubmitQuestion(options?: Omit<UseMutationOptions<SubmitQuestionResult, Error, string>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    submissionId: string;
+    questions: unknown[];
+    accounts: {
+        [key: string]: unknown;
+    };
+    qualityExplanation: string | null;
+    refuseToResolve: boolean;
+    status: string;
+    statusUpdates: unknown[];
+    pollUrl: string;
+}, Error, string, unknown>;
+interface SubmitAndWaitInput {
+    question: string;
+    options?: SubmitAndWaitOptions;
+}
+declare function useSubmitAndWait(options?: Omit<UseMutationOptions<QuestionSubmission, Error, SubmitAndWaitInput>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    questions: context_markets.ApiComponents["schemas"]["SubmissionQuestion"][];
+    accounts: {
+        [key: string]: context_markets.ApiComponents["schemas"]["SubmissionAccount"];
+    };
+    qualityExplanation: string | null;
+    refuseToResolve: boolean;
+    similarMarkets?: context_markets.ApiComponents["schemas"]["SimilarMarket"][];
+    rejectionReasons?: context_markets.ApiComponents["schemas"]["RejectionReason"][];
+    appliedChanges?: string[];
+    submissionId?: string;
+    status: string;
+    statusUpdates: {
+        tool: string;
+        status: string;
+        timestamp: string;
+    }[];
+}, Error, SubmitAndWaitInput, unknown>;
+declare function useCreateMarket(options?: Omit<UseMutationOptions<CreateMarketResult, Error, string>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    marketId: string;
+    txHash: string;
+}, Error, string, unknown>;
+declare function useAgentSubmit(options?: Omit<UseMutationOptions<SubmitQuestionResult, Error, AgentSubmitMarketDraft>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    submissionId: string;
+    questions: unknown[];
+    accounts: {
+        [key: string]: unknown;
+    };
+    qualityExplanation: string | null;
+    refuseToResolve: boolean;
+    status: string;
+    statusUpdates: unknown[];
+    pollUrl: string;
+}, Error, AgentSubmitMarketDraft, unknown>;
+interface AgentSubmitAndWaitInput {
+    draft: AgentSubmitMarketDraft;
+    options?: SubmitAndWaitOptions;
+}
+declare function useAgentSubmitAndWait(options?: Omit<UseMutationOptions<QuestionSubmission, Error, AgentSubmitAndWaitInput>, "mutationFn">): _tanstack_react_query.UseMutationResult<{
+    questions: context_markets.ApiComponents["schemas"]["SubmissionQuestion"][];
+    accounts: {
+        [key: string]: context_markets.ApiComponents["schemas"]["SubmissionAccount"];
+    };
+    qualityExplanation: string | null;
+    refuseToResolve: boolean;
+    similarMarkets?: context_markets.ApiComponents["schemas"]["SimilarMarket"][];
+    rejectionReasons?: context_markets.ApiComponents["schemas"]["RejectionReason"][];
+    appliedChanges?: string[];
+    submissionId?: string;
+    status: string;
+    statusUpdates: {
+        tool: string;
+        status: string;
+        timestamp: string;
+    }[];
+}, Error, AgentSubmitAndWaitInput, unknown>;
+
+export { ContextProvider, ContextWalletError, contextKeys, useAccountSetup, useAccountStatus, useAgentSubmit, useAgentSubmitAndWait, useBalance, useCancelOrder, useCancelReplace, useClaimable, useContextClient, useCreateMarket, useCreateMarketOrder, useCreateOrder, useDeposit, useLatestOracleQuote, useMarket, useMarketActivity, useMarkets, useOracle, useOrder, useOrderbook, useOrders, usePortfolio, usePortfolioStats, usePositions, usePriceHistory, useQuotes, useSearchMarkets, useSimulateTrade, useSubmitAndWait, useSubmitQuestion, useWithdraw };

package/dist/index.js

@@ -0,0 +1,459 @@
+// src/provider.tsx
+import {
+  createContext,
+  useContext,
+  useMemo
+} from "react";
+import { ContextClient } from "context-markets";
+import { useWalletClient, useAccount } from "wagmi";
+import { jsx } from "react/jsx-runtime";
+var ContextClientContext = createContext(null);
+function ContextProvider({
+  apiKey,
+  rpcUrl,
+  baseUrl,
+  children
+}) {
+  const { data: walletClient } = useWalletClient();
+  const { address } = useAccount();
+  const client = useMemo(() => {
+    return new ContextClient({
+      apiKey,
+      rpcUrl,
+      baseUrl,
+      ...walletClient ? { signer: { walletClient } } : {}
+    });
+  }, [apiKey, rpcUrl, baseUrl, walletClient, address]);
+  return /* @__PURE__ */ jsx(ContextClientContext.Provider, { value: client, children });
+}
+function useContextClient() {
+  const client = useContext(ContextClientContext);
+  if (!client) {
+    throw new Error(
+      "useContextClient must be used within a <ContextProvider>"
+    );
+  }
+  return client;
+}
+
+// src/query-keys.ts
+var PREFIX = "context";
+var contextKeys = {
+  markets: {
+    all: [PREFIX, "markets"],
+    list: (params) => params ? [PREFIX, "markets", "list", params] : [PREFIX, "markets", "list"],
+    search: (q, params) => params ? [PREFIX, "markets", "search", q, params] : [PREFIX, "markets", "search", q],
+    get: (id) => [PREFIX, "markets", "get", id],
+    orderbook: (id, params) => params ? [PREFIX, "markets", "orderbook", id, params] : [PREFIX, "markets", "orderbook", id],
+    quotes: (id) => [PREFIX, "markets", "quotes", id],
+    priceHistory: (id, params) => params ? [PREFIX, "markets", "priceHistory", id, params] : [PREFIX, "markets", "priceHistory", id],
+    activity: (id, params) => params ? [PREFIX, "markets", "activity", id, params] : [PREFIX, "markets", "activity", id],
+    simulate: (params) => [PREFIX, "markets", "simulate", params],
+    oracle: (id) => [PREFIX, "markets", "oracle", id],
+    latestOracleQuote: (id) => [PREFIX, "markets", "latestOracleQuote", id]
+  },
+  orders: {
+    all: [PREFIX, "orders"],
+    list: (params) => params ? [PREFIX, "orders", "list", params] : [PREFIX, "orders", "list"],
+    get: (id) => [PREFIX, "orders", "get", id]
+  },
+  portfolio: {
+    all: [PREFIX, "portfolio"],
+    get: (address, params) => address ? [PREFIX, "portfolio", "get", address, ...params ? [params] : []] : [PREFIX, "portfolio", "get"],
+    balance: (address) => address ? [PREFIX, "portfolio", "balance", address] : [PREFIX, "portfolio", "balance"],
+    claimable: (address) => address ? [PREFIX, "portfolio", "claimable", address] : [PREFIX, "portfolio", "claimable"],
+    stats: (address) => address ? [PREFIX, "portfolio", "stats", address] : [PREFIX, "portfolio", "stats"],
+    positions: (address, params) => address ? [PREFIX, "portfolio", "positions", address, ...params ? [params] : []] : [PREFIX, "portfolio", "positions"]
+  },
+  account: {
+    all: [PREFIX, "account"],
+    status: () => [PREFIX, "account", "status"]
+  }
+};
+
+// src/errors.ts
+var ContextWalletError = class extends Error {
+  constructor(hookName) {
+    super(
+      `Wallet not connected. Connect a wallet before calling ${hookName}().`
+    );
+    this.name = "ContextWalletError";
+  }
+};
+
+// src/hooks/usePortfolio.ts
+import { useQuery } from "@tanstack/react-query";
+function usePortfolio(address, params, options) {
+  const client = useContextClient();
+  return useQuery({
+    queryKey: contextKeys.portfolio.get(address, params),
+    queryFn: () => client.portfolio.get(address, params),
+    ...options
+  });
+}
+function useBalance(address, options) {
+  const client = useContextClient();
+  return useQuery({
+    queryKey: contextKeys.portfolio.balance(address),
+    queryFn: () => client.portfolio.balance(address),
+    ...options
+  });
+}
+function useClaimable(address, options) {
+  const client = useContextClient();
+  return useQuery({
+    queryKey: contextKeys.portfolio.claimable(address),
+    queryFn: () => client.portfolio.claimable(address),
+    ...options
+  });
+}
+function usePortfolioStats(address, options) {
+  const client = useContextClient();
+  return useQuery({
+    queryKey: contextKeys.portfolio.stats(address),
+    queryFn: () => client.portfolio.stats(address),
+    ...options
+  });
+}
+function usePositions(address, params, options) {
+  const client = useContextClient();
+  return useQuery({
+    queryKey: contextKeys.portfolio.positions(address, params),
+    queryFn: () => client.portfolio.positions(address, params),
+    ...options
+  });
+}
+
+// src/hooks/useMarkets.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useMarkets(params, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.list(params),
+    queryFn: () => client.markets.list(params),
+    ...options
+  });
+}
+function useSearchMarkets(params, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.search(params.q, params),
+    queryFn: () => client.markets.search(params),
+    enabled: !!params.q,
+    ...options
+  });
+}
+function useMarket(marketId, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.get(marketId),
+    queryFn: () => client.markets.get(marketId),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function useOrderbook(marketId, params, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.orderbook(marketId, params),
+    queryFn: () => client.markets.orderbook(marketId, params),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function useQuotes(marketId, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.quotes(marketId),
+    queryFn: () => client.markets.quotes(marketId),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function usePriceHistory(marketId, params, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.priceHistory(marketId, params),
+    queryFn: () => client.markets.priceHistory(marketId, params),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function useMarketActivity(marketId, params, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.activity(marketId, params),
+    queryFn: () => client.markets.activity(marketId, params),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function useSimulateTrade(marketId, params, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.simulate({ marketId, ...params }),
+    queryFn: () => client.markets.simulate(marketId, params),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function useOracle(marketId, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.oracle(marketId),
+    queryFn: () => client.markets.oracle(marketId),
+    enabled: !!marketId,
+    ...options
+  });
+}
+function useLatestOracleQuote(marketId, options) {
+  const client = useContextClient();
+  return useQuery2({
+    queryKey: contextKeys.markets.latestOracleQuote(marketId),
+    queryFn: () => client.markets.latestOracleQuote(marketId),
+    enabled: !!marketId,
+    ...options
+  });
+}
+
+// src/hooks/useAccount.ts
+import {
+  useQuery as useQuery3,
+  useMutation,
+  useQueryClient
+} from "@tanstack/react-query";
+function useAccountStatus(options) {
+  const client = useContextClient();
+  return useQuery3({
+    queryKey: contextKeys.account.status(),
+    queryFn: () => client.account.status(),
+    ...options
+  });
+}
+function useAccountSetup(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      try {
+        return await client.account.gaslessSetup();
+      } catch {
+        return await client.account.setup();
+      }
+    },
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.account.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useDeposit(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (amount) => {
+      try {
+        return await client.account.gaslessDeposit(amount);
+      } catch {
+        return await client.account.deposit(amount);
+      }
+    },
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.account.all });
+      queryClient.invalidateQueries({ queryKey: contextKeys.portfolio.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useWithdraw(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (amount) => client.account.withdraw(amount),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.account.all });
+      queryClient.invalidateQueries({ queryKey: contextKeys.portfolio.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+
+// src/hooks/useOrders.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+function useOrders(params, options) {
+  const client = useContextClient();
+  return useQuery4({
+    queryKey: contextKeys.orders.list(params),
+    queryFn: () => client.orders.list(params),
+    ...options
+  });
+}
+function useOrder(orderId, options) {
+  const client = useContextClient();
+  return useQuery4({
+    queryKey: contextKeys.orders.get(orderId),
+    queryFn: () => client.orders.get(orderId),
+    enabled: !!orderId,
+    ...options
+  });
+}
+
+// src/hooks/useOrderMutations.ts
+import { useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useCreateOrder(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (req) => client.orders.create(req),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.orders.all });
+      queryClient.invalidateQueries({ queryKey: contextKeys.markets.orderbook(args[1].marketId) });
+      queryClient.invalidateQueries({ queryKey: contextKeys.portfolio.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useCreateMarketOrder(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (req) => client.orders.createMarket(req),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.orders.all });
+      queryClient.invalidateQueries({ queryKey: contextKeys.markets.orderbook(args[1].marketId) });
+      queryClient.invalidateQueries({ queryKey: contextKeys.portfolio.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useCancelOrder(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (nonce) => client.orders.cancel(nonce),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.orders.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useCancelReplace(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: ({ cancelNonce, newOrder }) => client.orders.cancelReplace(cancelNonce, newOrder),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.orders.all });
+      queryClient.invalidateQueries({ queryKey: contextKeys.portfolio.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+
+// src/hooks/useQuestions.ts
+import { useMutation as useMutation3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useSubmitQuestion(options) {
+  const client = useContextClient();
+  return useMutation3({
+    mutationFn: (question) => client.questions.submit(question),
+    retry: false,
+    ...options
+  });
+}
+function useSubmitAndWait(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (input) => client.questions.submitAndWait(input.question, input.options),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.markets.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useCreateMarket(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (questionId) => client.markets.create(questionId),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.markets.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useAgentSubmit(options) {
+  const client = useContextClient();
+  return useMutation3({
+    mutationFn: (draft) => client.questions.agentSubmit(draft),
+    retry: false,
+    ...options
+  });
+}
+function useAgentSubmitAndWait(options) {
+  const client = useContextClient();
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (input) => client.questions.agentSubmitAndWait(input.draft, input.options),
+    retry: false,
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: contextKeys.markets.all });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+export {
+  ContextProvider,
+  ContextWalletError,
+  contextKeys,
+  useAccountSetup,
+  useAccountStatus,
+  useAgentSubmit,
+  useAgentSubmitAndWait,
+  useBalance,
+  useCancelOrder,
+  useCancelReplace,
+  useClaimable,
+  useContextClient,
+  useCreateMarket,
+  useCreateMarketOrder,
+  useCreateOrder,
+  useDeposit,
+  useLatestOracleQuote,
+  useMarket,
+  useMarketActivity,
+  useMarkets,
+  useOracle,
+  useOrder,
+  useOrderbook,
+  useOrders,
+  usePortfolio,
+  usePortfolioStats,
+  usePositions,
+  usePriceHistory,
+  useQuotes,
+  useSearchMarkets,
+  useSimulateTrade,
+  useSubmitAndWait,
+  useSubmitQuestion,
+  useWithdraw
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "context-markets-react",
+  "version": "0.1.0",
+  "description": "React hooks for Context Markets — built on context-markets and TanStack Query",
+  "license": "MIT",
+  "author": "Context",
+  "homepage": "https://docs.context.markets/agents/react-sdk",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/contextwtf/context-react.git"
+  },
+  "bugs": {
+    "url": "https://github.com/contextwtf/context-react/issues"
+  },
+  "keywords": [
+    "prediction-markets",
+    "context",
+    "react",
+    "hooks",
+    "wagmi",
+    "web3",
+    "tanstack-query"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "context-markets": ">=0.4.0",
+    "@tanstack/react-query": ">=5.0.0",
+    "react": ">=18.0.0",
+    "viem": ">=2.0.0",
+    "wagmi": ">=2.0.0"
+  },
+  "devDependencies": {
+    "context-markets": "^0.4.0",
+    "@tanstack/react-query": "^5.0.0",
+    "@testing-library/react": "^16.0.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "jsdom": "^25.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "viem": "^2.23.0",
+    "vitest": "^3.0.0",
+    "wagmi": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}