@madgallery/rbs-pm-sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,904 @@
+import { WalletClient, Account } from 'viem';
+
+interface Market {
+    address: `0x${string}`;
+    question: string;
+    resolutionTime: Date;
+    oracle: `0x${string}`;
+    status: 'ACTIVE' | 'RESOLVED' | 'PAUSED';
+    resolved: boolean;
+    yesWins: boolean | null;
+    yesToken: `0x${string}`;
+    noToken: `0x${string}`;
+    yesPrice: number;
+    noPrice: number;
+    yesShares: bigint;
+    noShares: bigint;
+    totalVolume: bigint;
+    totalTrades: number;
+    category?: string;
+    tags?: string[];
+}
+interface MarketPrices {
+    yes: number;
+    no: number;
+    impliedProbability: {
+        yes: number;
+        no: number;
+    };
+}
+interface TradeQuote {
+    shares: bigint;
+    cost: bigint;
+    priceImpact: number;
+    averagePrice: number;
+}
+interface TradeResult {
+    txHash: `0x${string}`;
+    shares: bigint;
+    cost: bigint;
+    isYes: boolean;
+    isBuy: boolean;
+}
+interface Position {
+    yesShares: bigint;
+    noShares: bigint;
+    yesValue: bigint;
+    noValue: bigint;
+    totalValue: bigint;
+}
+interface MoltbookAgent {
+    id: string;
+    name: string;
+    karma: number;
+    owner: {
+        address: string;
+    };
+}
+interface AuthResult {
+    accessToken: string;
+    expiresAt: Date;
+    agent: {
+        id: string;
+        moltbookId: string;
+        moltbookName: string;
+        karma: number;
+        controllerAddress: string;
+    };
+}
+interface RBSPMConfig {
+    /** Private key for signing transactions */
+    privateKey?: `0x${string}`;
+    /** Moltbook API key for authentication */
+    moltbookApiKey?: string;
+    /** Custom RPC URL (defaults to Monad testnet) */
+    rpcUrl?: string;
+    /** API base URL (defaults to production) */
+    apiUrl?: string;
+}
+interface PremiumMarketData {
+    market: {
+        address: string;
+        question: string;
+        status: string;
+        resolved: boolean;
+        yesWins: boolean | null;
+        resolutionTime: string;
+    };
+    pricing: {
+        yesPrice: number;
+        noPrice: number;
+        impliedProbability: {
+            yes: number;
+            no: number;
+        };
+        spread: number;
+    };
+    liquidity: {
+        yesShares: string;
+        noShares: string;
+        totalCollateral: string;
+        liquidityParameter: string | null;
+    };
+    activity: {
+        totalVolume: number;
+        totalTrades: number;
+        uniqueTraders: number;
+        avgTradeSize: number;
+        recentTrades: Array<{
+            id: string;
+            trade_type: string;
+            outcome: string;
+            shares: string;
+            amount: string;
+            created_at: string;
+        }>;
+    };
+    fees: {
+        totalProtocolFees: string;
+        totalCreatorFees: string;
+    };
+}
+/** Parameters for creating a new market */
+interface MarketCreateParams {
+    /** Deployed contract address */
+    address: string;
+    /** Market question */
+    question: string;
+    /** Resolution time as Unix timestamp */
+    resolutionTime: number;
+    /** Oracle address that can resolve the market */
+    oracle: string;
+    /** YES token address (optional, read from contract if not provided) */
+    yesTokenAddress?: string;
+    /** NO token address (optional, read from contract if not provided) */
+    noTokenAddress?: string;
+    /** Initial liquidity amount in USDC */
+    initialLiquidity?: string;
+    /** Alpha parameter for LS-LMSR (e.g., "0.03" for 3%) */
+    alpha?: string;
+    /** Market category */
+    category?: string;
+    /** Market tags */
+    tags?: string[];
+}
+/** Result of market creation */
+interface MarketCreateResult {
+    success: boolean;
+    market: {
+        id: string;
+        address: string;
+        question: string;
+        status: string;
+    };
+    /** x402 payment amount in USDC base units */
+    paymentAmount: string;
+}
+/** x402 price configuration */
+interface X402Prices {
+    marketData: {
+        raw: string;
+        formatted: string;
+    };
+    createMarket: {
+        raw: string;
+        formatted: string;
+    };
+    agentTrade: {
+        raw: string;
+        formatted: string;
+    };
+}
+
+declare class RBSPMClient {
+    private publicClient;
+    private walletClient;
+    private account;
+    private accessToken;
+    private apiUrl;
+    private x402PaymentFetch;
+    constructor(config?: RBSPMConfig);
+    /**
+     * Initialize x402 client for automatic payment handling
+     */
+    private initX402Client;
+    /**
+     * Authenticate with Moltbook API key
+     */
+    authenticateWithMoltbook(apiKey: string): Promise<AuthResult>;
+    /**
+     * Check if x402 payments are available
+     */
+    hasPaymentCapability(): boolean;
+    /**
+     * Get the fetch function with x402 payment capability
+     */
+    getPaymentFetch(): typeof fetch;
+    /**
+     * Get all active markets (requires x402 payment - 0.0001 USDC)
+     */
+    getMarkets(): Promise<Market[]>;
+    /**
+     * Get premium market data (requires x402 payment - 0.0001 USDC)
+     */
+    getPremiumMarketData(marketAddress: `0x${string}`): Promise<PremiumMarketData>;
+    /**
+     * List a deployed market in the discovery index (requires 0.0001 USDC x402 payment)
+     *
+     * After deploying a market contract on-chain, call this method to make it
+     * discoverable by other agents. The listing fee (0.0001 USDC) is paid via x402.
+     *
+     * @example
+     * ```typescript
+     * // After deploying market contract...
+     * const result = await client.listMarket({
+     *   address: deployedMarketAddress,
+     *   question: 'Will ETH reach $10k in 2025?',
+     *   resolutionTime: 1735689600, // Unix timestamp
+     *   oracle: oracleAddress,
+     *   category: 'crypto',
+     *   tags: ['ethereum', 'price'],
+     * });
+     * console.log('Market listed! ID:', result.market.id);
+     * ```
+     */
+    listMarket(params: MarketCreateParams): Promise<MarketCreateResult>;
+    /**
+     * Alias for listMarket - for backwards compatibility
+     */
+    createMarket(params: MarketCreateParams): Promise<MarketCreateResult>;
+    /**
+     * Get encoded trade calldata (requires x402 payment - 0.0001 USDC)
+     *
+     * This endpoint returns the raw calldata for executing trades,
+     * useful for agents that want to build their own transactions.
+     *
+     * @example
+     * ```typescript
+     * const instructions = await client.getTradeInstructions({
+     *   marketAddress: '0x...',
+     *   direction: 'buy',
+     *   outcome: 'yes',
+     *   amount: '10', // 10 USDC
+     * });
+     *
+     * // Execute approval first (for buys)
+     * if (instructions.approval) {
+     *   await wallet.sendTransaction({
+     *     to: instructions.approval.to,
+     *     data: instructions.approval.data,
+     *   });
+     * }
+     *
+     * // Then execute the trade
+     * await wallet.sendTransaction({
+     *   to: instructions.trade.to,
+     *   data: instructions.trade.data,
+     * });
+     * ```
+     */
+    getTradeInstructions(params: {
+        marketAddress: `0x${string}`;
+        direction: 'buy' | 'sell';
+        outcome: 'yes' | 'no';
+        amount: string;
+        minOutput?: string;
+    }): Promise<{
+        approval?: {
+            to: string;
+            data: string;
+            description: string;
+        };
+        trade: {
+            to: string;
+            data: string;
+            description: string;
+        };
+        summary: {
+            direction: string;
+            outcome: string;
+            amount: string;
+            marketAddress: string;
+        };
+    }>;
+    /**
+     * Get current prices for a market (requires x402 payment - 0.0001 USDC)
+     */
+    getPrices(marketAddress: `0x${string}`): Promise<MarketPrices>;
+    /**
+     * Get quote for buying shares with USDC
+     */
+    getBuyQuote(marketAddress: `0x${string}`, isYes: boolean, usdcAmount: string): Promise<TradeQuote>;
+    /**
+     * Get quote for selling shares
+     */
+    getSellQuote(marketAddress: `0x${string}`, isYes: boolean, shares: bigint): Promise<{
+        payout: bigint;
+        priceImpact: number;
+    }>;
+    /**
+     * Check and approve USDC spending
+     */
+    private ensureUSDCAllowance;
+    /**
+     * Buy shares with USDC
+     *
+     * IMPORTANT: This method routes through x402-agent-trade endpoint to ensure
+     * all trades are tracked. Costs 0.0001 USDC for the API call + trade amount.
+     */
+    buy(marketAddress: `0x${string}`, isYes: boolean, usdcAmount: string, minShares?: bigint): Promise<TradeResult>;
+    /**
+     * Sell shares for USDC
+     *
+     * IMPORTANT: This method routes through x402-agent-trade endpoint to ensure
+     * all trades are tracked. Costs 0.0001 USDC for the API call.
+     */
+    sell(marketAddress: `0x${string}`, isYes: boolean, shares: bigint, minPayout?: bigint): Promise<TradeResult>;
+    /**
+     * Redeem winning shares after resolution
+     *
+     * IMPORTANT: Routes through x402-redeem endpoint for tracking (0.0001 USDC)
+     */
+    redeem(marketAddress: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Get user's position in a market (requires x402 payment - 0.0001 USDC)
+     */
+    getPosition(marketAddress: `0x${string}`, userAddress?: `0x${string}`): Promise<Position>;
+    /**
+     * Get USDC balance
+     */
+    getUSDCBalance(userAddress?: `0x${string}`): Promise<string>;
+    /**
+     * Get MON (native token) balance for gas
+     */
+    getMONBalance(userAddress?: `0x${string}`): Promise<string>;
+    /**
+     * Get full market information (requires x402 payment - 0.0001 USDC)
+     */
+    getMarketInfo(marketAddress: `0x${string}`): Promise<{
+        question: string;
+        resolutionTime: bigint;
+        oracle: `0x${string}`;
+        yesPrice: number;
+        noPrice: number;
+        yesProbability: number;
+        noProbability: number;
+        yesShares: bigint;
+        noShares: bigint;
+        totalCollateral: bigint;
+        liquidityParam: bigint;
+        resolved: boolean;
+        yesWins: boolean;
+        marketCreator: `0x${string}`;
+        initialized: boolean;
+        canResolve: boolean;
+    }>;
+    /**
+     * Get resolve calldata and execute (requires x402 payment - 0.0001 USDC)
+     *
+     * @example
+     * ```typescript
+     * // As the oracle, resolve the market
+     * const txHash = await client.resolve('0x...', true); // YES wins
+     * console.log('Market resolved:', txHash);
+     * ```
+     */
+    resolve(marketAddress: `0x${string}`, yesWins: boolean): Promise<`0x${string}`>;
+    /**
+     * Check if market can be resolved (requires x402 payment - 0.0001 USDC for market info)
+     */
+    canResolve(marketAddress: `0x${string}`): Promise<{
+        canResolve: boolean;
+        reason?: string;
+        resolutionTime: Date;
+        isOracle: boolean;
+    }>;
+    /**
+     * Get fee information and claim calldata (requires x402 payment - 0.0001 USDC)
+     */
+    getFeeInfo(marketAddress: `0x${string}`): Promise<{
+        pendingCreatorFees: bigint;
+        pendingCreatorFeesFormatted: string;
+        protocolFeesSent: bigint;
+        protocolFeesSentFormatted: string;
+        marketCreator: `0x${string}`;
+        isCreator: boolean;
+        transactions: Array<{
+            to: string;
+            data: string;
+            description: string;
+            type: string;
+        }>;
+    }>;
+    /**
+     * Claim accumulated creator fees (requires x402 payment - 0.0001 USDC)
+     *
+     * @example
+     * ```typescript
+     * const feeInfo = await client.getFeeInfo('0x...');
+     * console.log('Pending fees:', feeInfo.pendingCreatorFeesFormatted, 'USDC');
+     *
+     * if (feeInfo.pendingCreatorFees > 0n) {
+     *   const txHash = await client.claimCreatorFees('0x...');
+     *   console.log('Fees claimed:', txHash);
+     * }
+     * ```
+     */
+    claimCreatorFees(marketAddress: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Withdraw excess collateral after market resolution (requires x402 payment - 0.0001 USDC)
+     */
+    withdrawExcessCollateral(marketAddress: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Initialize a deployed market with initial liquidity
+     *
+     * IMPORTANT: Routes through x402-initialize endpoint for tracking (0.0001 USDC)
+     *
+     * @param marketAddress The deployed market contract address
+     * @param usdcAmount Initial liquidity in USDC (e.g., "10" for 10 USDC)
+     */
+    initializeMarket(marketAddress: `0x${string}`, usdcAmount: string): Promise<`0x${string}`>;
+    /**
+     * Get connected wallet address
+     */
+    getAddress(): `0x${string}` | null;
+    /**
+     * Format USDC amount for display
+     */
+    formatUSDC(amount: bigint): string;
+    /**
+     * Parse USDC amount from string
+     */
+    parseUSDC(amount: string): bigint;
+    /**
+     * Get x402 pricing info for all endpoints
+     */
+    getX402Prices(): {
+        markets: {
+            raw: "100";
+            formatted: string;
+            description: string;
+        };
+        marketData: {
+            raw: "100";
+            formatted: string;
+            description: string;
+        };
+        tradeInstructions: {
+            raw: "100";
+            formatted: string;
+            description: string;
+        };
+        createMarket: {
+            raw: "100";
+            formatted: string;
+            description: string;
+        };
+    };
+}
+
+declare const MONAD_TESTNET: {
+    readonly id: 10143;
+    readonly name: "Monad Testnet";
+    readonly rpcUrl: "https://testnet-rpc.monad.xyz";
+    readonly explorer: "https://testnet.monadexplorer.com";
+};
+declare const ADDRESSES: {
+    readonly PREDICTION_FACTORY: `0x${string}`;
+    readonly WMON: `0x${string}`;
+    readonly USDC: `0x${string}`;
+    readonly AGENT_REGISTRY: `0x${string}`;
+    readonly REPUTATION_REGISTRY: `0x${string}`;
+    readonly PROTOCOL_FEE_RECIPIENT: `0x${string}`;
+};
+declare const API_CONFIG: {
+    readonly base: "https://qkcytrdhdtemyphsswou.supabase.co";
+    readonly anonKey: "sb_publishable_mKTNqXht6ek37VkHAGWoUQ_TMzoC3wp";
+};
+declare const API_ENDPOINTS: {
+    readonly base: "https://qkcytrdhdtemyphsswou.supabase.co";
+    readonly x402Markets: "/functions/v1/x402-markets";
+    readonly x402Prices: "/functions/v1/x402-prices";
+    readonly x402MarketInfo: "/functions/v1/x402-market-info";
+    readonly x402Position: "/functions/v1/x402-position";
+    readonly x402MarketData: "/functions/v1/x402-market-data";
+    readonly x402AgentTrade: "/functions/v1/x402-agent-trade";
+    readonly x402Resolve: "/functions/v1/x402-resolve";
+    readonly x402ClaimFees: "/functions/v1/x402-claim-fees";
+    readonly x402Redeem: "/functions/v1/x402-redeem";
+    readonly x402Initialize: "/functions/v1/x402-initialize";
+    readonly x402CreateMarket: "/functions/v1/x402-create-market";
+    readonly authMoltbook: "/functions/v1/auth-moltbook";
+};
+declare const X402_CONFIG: {
+    readonly network: "eip155:10143";
+    readonly facilitator: "https://x402-facilitator.molandak.org";
+    readonly recipient: `0x${string}`;
+    readonly prices: {
+        readonly default: "100";
+        readonly markets: "100";
+        readonly prices: "100";
+        readonly marketInfo: "100";
+        readonly position: "100";
+        readonly marketData: "100";
+        readonly tradeInstructions: "100";
+        readonly resolve: "100";
+        readonly claimFees: "100";
+        readonly createMarket: "100";
+    };
+};
+declare const LSLMSR_DEPLOY_PARAMS: {
+    readonly collateral: `0x${string}`;
+    readonly decimals: 6;
+    readonly defaultAlpha: "30000000000000000";
+    readonly defaultMinLiquidity: "100000000000000000000";
+    readonly defaultInitialShares: "100000000000000000000";
+};
+declare const LSLMSR_ABI: readonly [{
+    readonly name: "getMarketInfo";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "_question";
+        readonly type: "string";
+    }, {
+        readonly name: "_resolutionTime";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_oracle";
+        readonly type: "address";
+    }, {
+        readonly name: "_yesPrice";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_noPrice";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_yesProbability";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_noProbability";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_yesShares";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_noShares";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_totalCollateral";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_liquidityParam";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_priceSum";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_resolved";
+        readonly type: "bool";
+    }, {
+        readonly name: "_yesWins";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "getCollateralInfo";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "decimals";
+        readonly type: "uint8";
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "getYesPrice";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "getNoPrice";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "getCostInCollateral";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "isYes";
+        readonly type: "bool";
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "cost";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "getPayoutForSellInCollateral";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "isYes";
+        readonly type: "bool";
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "payout";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "estimateSharesForPayment";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "isYes";
+        readonly type: "bool";
+    }, {
+        readonly name: "grossPayment";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "yesToken";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "noToken";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "collateralToken";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "collateralDecimals";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "buy";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "isYes";
+        readonly type: "bool";
+    }, {
+        readonly name: "collateralAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "minShares";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "sell";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "isYes";
+        readonly type: "bool";
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+    }, {
+        readonly name: "minPayout";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "redeem";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "resolve";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_yesWins";
+        readonly type: "bool";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "oracle";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "resolved";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "yesWins";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "resolutionTime";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "claimCreatorFees";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "withdrawExcessCollateral";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "getFeeInfo";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "pendingCreatorFees";
+        readonly type: "uint256";
+    }, {
+        readonly name: "protocolFeesSent";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "marketCreator";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "creatorFeesAccrued";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "initialize";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_initialLiquidity";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "initialized";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "SharesPurchased";
+    readonly inputs: readonly [{
+        readonly name: "buyer";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "isYes";
+        readonly type: "bool";
+        readonly indexed: false;
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "cost";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "SharesSold";
+    readonly inputs: readonly [{
+        readonly name: "seller";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "isYes";
+        readonly type: "bool";
+        readonly indexed: false;
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "payout";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}];
+declare const ERC20_ABI: readonly [{
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];
+
+/**
+ * Create a fetch wrapper that automatically handles x402 payments
+ */
+declare function createX402Fetch(walletClient: WalletClient, account: Account): (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Check if a wallet has enough USDC for x402 payments
+ */
+declare function checkX402Balance(publicClient: {
+    readContract: (args: unknown) => Promise<bigint>;
+}, address: `0x${string}`, requiredAmount?: string): Promise<{
+    sufficient: boolean;
+    balance: bigint;
+    required: bigint;
+}>;
+
+export { ADDRESSES, API_CONFIG, API_ENDPOINTS, type AuthResult, ERC20_ABI, LSLMSR_ABI, LSLMSR_DEPLOY_PARAMS, MONAD_TESTNET, type Market, type MarketCreateParams, type MarketCreateResult, type MarketPrices, type MoltbookAgent, type Position, type PremiumMarketData, RBSPMClient, type RBSPMConfig, type TradeQuote, type TradeResult, type X402Prices, X402_CONFIG, checkX402Balance, createX402Fetch, RBSPMClient as default };