@vesper85/strategy-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Osiris AI
+
+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,448 @@
+# @osiris-ai/strategy-sdk
+
+SDK for writing and running trading strategies with Polymarket and Hyperliquid integrations.
+
+## Features
+
+- **TypeScript-first**: Full type safety with IntelliSense support
+- **Market Integrations**: Polymarket and Hyperliquid APIs
+- **Technical Analysis**: Built-in technical indicators (RSI, MACD, Bollinger Bands, etc.)
+- **State Management**: In-memory or Redis-backed persistent state
+- **Dual Execution Modes**: Tick-based (polling) or Event-based (real-time WebSocket)
+- **Flexible Logging**: Use built-in console logger or provide your own
+- **Transaction Signing**: Support for both Osiris Hub signing and private key signing (EVM & Solana)
+
+## Installation
+
+```bash
+npm install @osiris-ai/strategy-sdk
+# or
+pnpm add @osiris-ai/strategy-sdk
+# or
+yarn add @osiris-ai/strategy-sdk
+```
+
+## Quick Start
+
+### 1. Create a Strategy (Tick-Based)
+
+```typescript
+import type { OsirisContext, CodeStrategy } from '@osiris-ai/strategy-sdk';
+
+export default class MyStrategy implements CodeStrategy {
+    async shouldTrigger(osiris: OsirisContext): Promise<boolean> {
+        // Return true when you want to execute the strategy
+        return true;
+    }
+
+    async onTrigger(osiris: OsirisContext): Promise<void> {
+        // Your trading logic here
+        if (osiris.hyperliquid) {
+            const price = await osiris.hyperliquid.getPrice('BTC');
+            osiris.log(`Current BTC price: ${price}`);
+        }
+    }
+}
+```
+
+### 2. Run the Strategy
+
+```typescript
+import {
+    createOsirisContext,
+    createConsoleLogger,
+    runStrategy,
+    PrivateKeySigner,
+} from '@osiris-ai/strategy-sdk';
+import MyStrategy from './my-strategy';
+
+async function main() {
+    const logger = createConsoleLogger();
+
+    // Create signer
+    const signer = new PrivateKeySigner({
+        privateKey: process.env.PRIVATE_KEY!,
+    });
+
+    // Create context
+    const context = createOsirisContext({
+        strategyId: 'my-strategy',
+        market: 'hyperliquid', // or 'polymarket'
+        userAddress: signer.getAddress()!,
+        signer,
+    });
+
+    // Create strategy instance
+    const strategy = new MyStrategy();
+
+    // Run strategy once
+    await runStrategy(strategy, { logger }, context);
+}
+
+main();
+```
+
+## Execution Modes
+
+The SDK supports two mutually exclusive execution modes:
+
+### Tick-Based Execution (Polling)
+
+Runs your strategy at fixed intervals. Best for strategies that check conditions periodically.
+
+```typescript
+interface CodeStrategy {
+    shouldTrigger(osiris: OsirisContext): Promise<boolean>;
+    onTrigger(osiris: OsirisContext): Promise<void>;
+}
+```
+
+```typescript
+import { createStrategyEngine } from '@osiris-ai/strategy-sdk';
+
+const engine = createStrategyEngine(strategy, {
+    logger,
+    strategyId: 'my-strategy', // Optional, for logging
+    tickIntervalMs: 60000, // Run every 60 seconds
+}, context);
+
+engine.start();
+// engine.stop();
+```
+
+### Event-Based Execution (Real-time WebSocket)
+
+Reacts to real-time events from your WebSocket server. Best for reactive strategies (price alerts, arbitrage, etc.)
+
+```typescript
+interface CodeStrategy {
+    subscriptions: EventSubscription[];
+    onEvent(event: StrategyEvent, osiris: OsirisContext): Promise<void>;
+}
+```
+
+```typescript
+import { createEventRunner, type EventSubscription, type StrategyEvent } from '@osiris-ai/strategy-sdk';
+
+class PriceAlertStrategy implements CodeStrategy {
+    subscriptions: EventSubscription[] = [
+        {
+            type: 'price',
+            market: 'BTC-USD',
+            conditions: { priceChangePercent: 5 }
+        }
+    ];
+
+    async onEvent(event: StrategyEvent, osiris: OsirisContext): Promise<void> {
+        osiris.log(`Price changed: ${event.data.changePercent}%`);
+        // React to price change...
+    }
+}
+
+const runner = createEventRunner(strategy, {
+    logger,
+    eventSourceUrl: 'wss://your-event-server.com/ws',
+    strategyId: 'price-alert', // Optional
+}, context);
+
+runner.start();
+// runner.stop();
+```
+
+#### Event Types
+
+```typescript
+type EventType = 'price' | 'orderbook' | 'time' | 'trade' | 'fill' | 'liquidation' | 'custom';
+```
+
+#### Event Subscriptions
+
+```typescript
+interface EventSubscription {
+    type: EventType;
+    market?: string;
+    conditions?: {
+        priceAbove?: number;
+        priceBelow?: number;
+        priceChangePercent?: number;
+        spreadAbove?: number;
+        volumeAbove?: number;
+        cron?: string;
+        interval?: number;
+    };
+}
+```
+
+## API Reference
+
+### Types
+
+#### `CodeStrategy`
+
+Interface that all strategies must implement (choose one execution mode):
+
+```typescript
+interface CodeStrategy {
+    // Tick-based (optional if using event-based)
+    shouldTrigger?(osiris: OsirisContext): Promise<boolean>;
+    onTrigger?(osiris: OsirisContext): Promise<void>;
+    
+    // Event-based (optional if using tick-based)
+    subscriptions?: EventSubscription[];
+    onEvent?(event: StrategyEvent, osiris: OsirisContext): Promise<void>;
+}
+```
+
+#### `OsirisContext`
+
+The context object passed to your strategy methods:
+
+```typescript
+interface OsirisContext {
+    polymarket?: PolymarketAPI;      // Available when market='polymarket'
+    hyperliquid?: HyperliquidAPI;    // Available when market='hyperliquid'
+    ta: TechnicalAnalysisAPI;        // Technical analysis functions
+    state: OsirisState;              // State management
+    signer: SignerAPI;               // Transaction signer
+    log: (message: string, meta?: any) => void; // Logging function
+}
+```
+
+### State Management
+
+#### In Strategy
+
+```typescript
+// Get state
+const value = await osiris.state.get('myKey');
+
+// Set state
+await osiris.state.set('myKey', { count: 42 });
+```
+
+#### Redis State (for production)
+
+```typescript
+import { RedisStateManager } from '@osiris-ai/strategy-sdk';
+
+const stateManager = new RedisStateManager(
+    'redis://localhost:6379',
+    'strategy-id',
+    logger
+);
+
+await stateManager.connect();
+// ... use stateManager
+await stateManager.disconnect();
+```
+
+### Market APIs
+
+#### Polymarket Trading
+
+```typescript
+if (osiris.polymarket) {
+    // Initialize trading client (required before trading)
+    await osiris.polymarket.initializeTradingClient();
+    
+    // ============================================
+    // Convenience Trading Methods (Recommended)
+    // ============================================
+    
+    // Limit orders
+    await osiris.polymarket.buyLimit(tokenId, 0.65, 100);    // Buy 100 shares @ $0.65
+    await osiris.polymarket.sellLimit(tokenId, 0.70, 50);    // Sell 50 shares @ $0.70
+    
+    // Market orders (execute immediately)
+    await osiris.polymarket.buyMarket(tokenId, 100);         // Buy $100 worth
+    await osiris.polymarket.sellMarket(tokenId, 50);         // Sell 50 shares
+    
+    // ============================================
+    // Full Order Methods (More control)
+    // ============================================
+    
+    await osiris.polymarket.createLimitOrder({
+        tokenId: '0x...',
+        price: 0.65,
+        size: 100,
+        side: 'BUY',
+        feeRateBps: '0',
+    });
+    
+    await osiris.polymarket.createMarketOrder({
+        tokenId: '0x...',
+        amount: 100,
+        side: 'BUY',
+        slippageTolerance: 0.05,
+    });
+    
+    // Order management
+    const orders = await osiris.polymarket.getOpenOrders();
+    await osiris.polymarket.cancelOrder(orderId);
+    await osiris.polymarket.cancelAllOrders();
+    
+    // Market data
+    const market = await osiris.polymarket.getMarket('market-slug');
+    const markets = await osiris.polymarket.getMarkets({ active: true, limit: 50 });
+    const orderBook = await osiris.polymarket.getOrderBook(tokenId);
+}
+```
+
+#### Hyperliquid Trading
+
+```typescript
+if (osiris.hyperliquid) {
+    // Get price
+    const price = await osiris.hyperliquid.getPrice('BTC');
+
+    // Get position
+    const position = await osiris.hyperliquid.getPosition('BTC');
+
+    // Get all positions
+    const positions = await osiris.hyperliquid.getPositions();
+
+    // Get candle data
+    const candles = await osiris.hyperliquid.getCandleSnapshot(
+        'BTC', '1d', startTime, endTime
+    );
+
+    // Execute trades
+    await osiris.hyperliquid.buy('BTC', 0.1);
+    await osiris.hyperliquid.sell('BTC', 0.1);
+}
+```
+
+### Technical Analysis
+
+```typescript
+// Calculate RSI
+const rsi = osiris.ta.calculate('rsi_14', ohlcvData, { period: 14 });
+
+// Calculate MACD (returns [MACD, signal, histogram])
+const macd = osiris.ta.calculate('macd_12_26_9', ohlcvData, {
+    fastPeriod: 12,
+    slowPeriod: 26,
+    signalPeriod: 9
+});
+
+// Get specific component from multi-value indicator
+const macdSignal = osiris.ta.calculate('macd_12_26_9', ohlcvData, {
+    component: 'signal'
+});
+
+// Available indicators:
+// Single-value: rsi, sma, ema, atr, adx, obv, cci, mfi, vwap, williams_r, roc, psar, wma
+// Multi-value: macd, bollinger_bands, stochastic, stochastic_rsi, keltner_channels
+```
+
+### Signing Transactions
+
+#### Using Private Key Signer
+
+```typescript
+import { PrivateKeySigner, createOsirisContext } from '@osiris-ai/strategy-sdk';
+
+const signer = new PrivateKeySigner({
+    privateKey: process.env.PRIVATE_KEY!,
+});
+
+const address = signer.getAddress();
+
+const context = createOsirisContext({
+    strategyId: 'my-strategy',
+    market: 'polymarket',
+    userAddress: address!,
+    signer,
+});
+```
+
+#### Using Osiris Hub Signer
+
+```typescript
+import { OsirisSigner, createOsirisContext } from '@osiris-ai/strategy-sdk';
+
+const signer = new OsirisSigner({
+    hubBaseUrl: 'https://api.osirislabs.xyz/v1',
+    accessToken: process.env.OSIRIS_ACCESS_TOKEN!,
+    connectionId: process.env.WALLET_CONNECTION_ID!,
+});
+
+const context = createOsirisContext({
+    strategyId: 'my-strategy',
+    market: 'polymarket',
+    userAddress: '0x...',
+    signer,
+    polymarketOptions: {
+        useMcpForOrders: true,
+        mcpUrl: 'https://gateway.backend.osirislabs.xyz/@osiris/polymarket/mcp',
+        mcpAccessToken: process.env.MCP_ACCESS_TOKEN!,
+    },
+});
+```
+
+### Logging
+
+```typescript
+import { createConsoleLogger } from '@osiris-ai/strategy-sdk';
+
+const logger = createConsoleLogger();
+```
+
+## Examples
+
+See the `examples/` directory:
+
+- `example-rsi.ts` - RSI-based trading strategy (tick-based)
+- `example-polymarket.ts` - Polymarket arbitrage strategy (tick-based)
+- `example-event-strategy.ts` - Price alert strategy (event-based)
+- `example-usage.ts` - Complete usage examples
+- `example-signer.ts` - Signer usage examples
+
+## Strategy Patterns
+
+### Tick-Based Strategy Pattern
+
+```typescript
+class MyTickStrategy implements CodeStrategy {
+    async shouldTrigger(osiris: OsirisContext): Promise<boolean> {
+        // Called every tick - return true to execute
+        return true;
+    }
+
+    async onTrigger(osiris: OsirisContext): Promise<void> {
+        // Your trading logic
+    }
+}
+```
+
+### Event-Based Strategy Pattern
+
+```typescript
+class MyEventStrategy implements CodeStrategy {
+    subscriptions: EventSubscription[] = [
+        { type: 'price', market: 'BTC-USD', conditions: { priceChangePercent: 5 } }
+    ];
+
+    async onEvent(event: StrategyEvent, osiris: OsirisContext): Promise<void> {
+        // Triggered by real-time events
+        osiris.log(`Event: ${event.type} - ${JSON.stringify(event.data)}`);
+    }
+}
+```
+
+## Best Practices
+
+1. **State Management**: Use `osiris.state` for persistent data that should survive restarts
+2. **Error Handling**: Always wrap API calls in try-catch blocks
+3. **Rate Limiting**: Be mindful of API rate limits when making frequent calls
+4. **Testing**: Use `MemoryStateManager` for testing, `RedisStateManager` for production
+5. **Logging**: Use `osiris.log()` for strategy-specific logs
+6. **Execution Mode**: Choose tick-based for polling, event-based for real-time reactions
+
+## TypeScript Support
+
+The SDK is written in TypeScript and provides full type definitions. All types are exported.
+
+## License
+
+MIT

package/dist/clients/hyperliquid-client.d.ts

@@ -0,0 +1,68 @@
+import { type ClearinghouseState, type SpotMeta, type SpotClearinghouseState, type SpotMetaAndAssetCtxs, type Meta, type MetaAndAssetCtxs, type UserFunding, type UserNonFundingLedgerUpdates, type FundingHistory, type PredictedFundings, type PerpsAtOpenInterestCap, type PerpDexLimits, type AllMids, type UserOpenOrders, type FrontendOpenOrders, type UserFills, type UserRateLimit, type OrderStatus, type L2Book, type CandleSnapshot, type HistoricalOrder, type TwapSliceFill, type SubAccount, type VaultDetails, type VaultEquity, type UserRole, type Delegation, type DelegatorSummary, type DelegatorHistoryEntry, type DelegatorReward, type ValidatorSummary, type VaultSummary, type UserFees, type PortfolioPeriods, type PreTransferCheck, type Referral, type ExtraAgent, type LegalCheck, type TwapHistory, type MultiSigSigners, type BuilderFeeApproval, type UserOrderHistory } from "hyperliquid";
+import type { HyperliquidAPI } from "../types/osiris";
+import type { Logger } from "../utils/logger";
+export declare class HyperliquidClient implements HyperliquidAPI {
+    private logger;
+    private client;
+    private userAddress;
+    constructor(logger: Logger, userAddress?: string);
+    getPrice(ticker: string): Promise<number>;
+    getIndicator(ticker: string, indicator: string, params?: any): Promise<number>;
+    getSpotMeta(): Promise<SpotMeta>;
+    getSpotClearinghouseState(user: string): Promise<SpotClearinghouseState>;
+    getSpotMetaAndAssetCtxs(): Promise<SpotMetaAndAssetCtxs>;
+    getTokenDetails(tokenId: string): Promise<any>;
+    getSpotDeployState(user: string): Promise<any>;
+    getMeta(): Promise<Meta>;
+    getMetaAndAssetCtxs(): Promise<MetaAndAssetCtxs>;
+    getClearinghouseState(user: string): Promise<ClearinghouseState>;
+    getUserFunding(user: string, startTime: number, endTime?: number): Promise<UserFunding>;
+    getUserNonFundingLedgerUpdates(user: string, startTime: number, endTime?: number): Promise<UserNonFundingLedgerUpdates>;
+    getFundingHistory(coin: string, startTime: number, endTime?: number): Promise<FundingHistory>;
+    getPredictedFundings(): Promise<PredictedFundings>;
+    getPerpsAtOpenInterestCap(): Promise<PerpsAtOpenInterestCap>;
+    getPerpDexLimits(dex: string): Promise<PerpDexLimits>;
+    getAssetIndex(assetName: string): Promise<number | undefined>;
+    getInternalName(exchangeName: string): Promise<string | undefined>;
+    getAllAssets(): Promise<{
+        perp: string[];
+        spot: string[];
+    }>;
+    getAllMids(): Promise<AllMids>;
+    getUserOpenOrders(user: string): Promise<UserOpenOrders>;
+    getFrontendOpenOrders(user: string): Promise<FrontendOpenOrders>;
+    getUserFills(user: string): Promise<UserFills>;
+    getUserFillsByTime(user: string, startTime: number, endTime: number): Promise<UserFills>;
+    getUserRateLimit(user: string): Promise<UserRateLimit>;
+    getOrderStatus(user: string, oid: number | string): Promise<OrderStatus>;
+    getL2Book(coin: string): Promise<L2Book>;
+    getCandleSnapshot(coin: string, interval: string, startTime: number, endTime: number): Promise<CandleSnapshot>;
+    getMaxBuilderFee(user: string, builder: string): Promise<number>;
+    getHistoricalOrders(user: string): Promise<HistoricalOrder[]>;
+    getUserTwapSliceFills(user: string): Promise<TwapSliceFill[]>;
+    getSubAccounts(user: string): Promise<SubAccount[]>;
+    getVaultDetails(vaultAddress: string, user?: string): Promise<VaultDetails>;
+    getUserVaultEquities(user: string): Promise<VaultEquity[]>;
+    getUserRole(user: string): Promise<UserRole>;
+    getDelegations(user: string): Promise<Delegation[]>;
+    getDelegatorSummary(user: string): Promise<DelegatorSummary>;
+    getDelegatorHistory(user: string): Promise<DelegatorHistoryEntry[]>;
+    getDelegatorRewards(user: string): Promise<DelegatorReward[]>;
+    validatorSummaries(): Promise<ValidatorSummary[]>;
+    vaultSummaries(): Promise<VaultSummary[]>;
+    userFees(user: string): Promise<UserFees>;
+    portfolio(user: string): Promise<PortfolioPeriods>;
+    preTransferCheck(user: string, source: string): Promise<PreTransferCheck>;
+    referral(user: string): Promise<Referral>;
+    extraAgents(user: string): Promise<ExtraAgent[]>;
+    isVip(user: string): Promise<boolean>;
+    legalCheck(user: string): Promise<LegalCheck>;
+    userTwapSliceFillsByTime(user: string, startTime: number, endTime?: number): Promise<TwapSliceFill[]>;
+    twapHistory(user: string): Promise<TwapHistory[]>;
+    userToMultiSigSigners(user: string): Promise<MultiSigSigners | null>;
+    getBuilderFeeApproval(user: string, builderAddress: string): Promise<BuilderFeeApproval>;
+    getUserOrderHistory(user: string, startTime: number, endTime?: number): Promise<UserOrderHistory>;
+    getPosition(ticker: string): Promise<ClearinghouseState['assetPositions'][0] | null>;
+    getPositions(): Promise<ClearinghouseState['assetPositions']>;
+}
+//# sourceMappingURL=hyperliquid-client.d.ts.map

package/dist/clients/polymarket-client.d.ts

@@ -0,0 +1,157 @@
+import { type GammaMarket, type Event as GammaEvent, type Tag, type Team, type Sport, type Series, type Comment as GammaComment, type SearchResults, type PaginatedResponse, type MarketFilters, type EventFilters, type EventPaginationFilters, type PaginationParams, type SearchParams } from "polymarket-gamma";
+import type { PolymarketAPI, PolymarketClientOptions, PolymarketLimitOrderParams, PolymarketMarketOrderParams, PolymarketOrderResponse, PolymarketOpenOrder, PolymarketCancelResponse, PolymarketOrderBook, PolymarketApprovalResult, SignerAPI } from "../types/osiris";
+import type { Logger } from "../utils/logger";
+export declare class PolymarketClient implements PolymarketAPI {
+    private logger;
+    private signer;
+    private gammaClient;
+    private clobClient;
+    private wallet;
+    private provider;
+    private options;
+    private tradingInitialized;
+    private mcpInstance;
+    private isOsirisSigner;
+    private userAddress;
+    constructor(logger: Logger, signer: SignerAPI, userAddress: string, options?: PolymarketClientOptions);
+    initializeTradingClient(): Promise<void>;
+    isTradingClientInitialized(): boolean;
+    private getPrivateKeyFromSigner;
+    private ensureTradingClient;
+    private ensureMcpInstance;
+    /**
+     * Call an MCP tool with retry logic
+     */
+    private callMCPTool;
+    /**
+     * Execute a tool on an MCP client instance
+     */
+    private executeMCPTool;
+    /**
+     * Extract content from MCP tool response (ported from sozu-tg-bot)
+     */
+    private extractMCPContent;
+    /**
+     * Extract order details from MCP response (ported from sozu-tg-bot)
+     */
+    private extractOrderDetails;
+    /**
+     * Detect errors in MCP tool response (ported from sozu-tg-bot)
+     */
+    private detectMCPError;
+    private ensureWallet;
+    getUsdcAllowance(): Promise<bigint>;
+    approveUsdc(amount?: bigint): Promise<string>;
+    isCtfApprovedForAll(): Promise<boolean>;
+    approveCtf(): Promise<string>;
+    setupApprovals(options?: {
+        usdcAmount?: bigint;
+    }): Promise<PolymarketApprovalResult>;
+    /**
+     * Check token allowance via MCP tools
+     * @param tokenType - "USDC" for buy orders, "CONDITIONAL_TOKEN" for sell orders
+     * @returns true if sufficient allowance exists
+     */
+    private checkAllowanceViaMCP;
+    /**
+     * Approve tokens via MCP tools
+     * @param tokenType - "USDC" for buy orders, "CONDITIONAL_TOKEN" for sell orders
+     * @returns true if approval was successful
+     */
+    private approveTokensViaMCP;
+    /**
+     * Ensure token approval via MCP before placing orders
+     * @param side - Order side (BUY or SELL)
+     * @returns true if approval is ready
+     */
+    private ensureTokenApprovalViaMCP;
+    /**
+     * Setup approvals via MCP tools (for OsirisSigner mode)
+     */
+    private setupApprovalsViaMCP;
+    createLimitOrder(params: PolymarketLimitOrderParams): Promise<PolymarketOrderResponse>;
+    /**
+     * Create limit order via MCP tools (for OsirisSigner)
+     */
+    private createLimitOrderViaMCP;
+    createMarketOrder(params: PolymarketMarketOrderParams): Promise<PolymarketOrderResponse>;
+    /**
+     * Create market order via MCP tools (for OsirisSigner)
+     */
+    private createMarketOrderViaMCP;
+    getOpenOrders(): Promise<PolymarketOpenOrder[]>;
+    cancelOrder(orderId: string): Promise<PolymarketCancelResponse>;
+    cancelOrders(orderIds: string[]): Promise<PolymarketCancelResponse>;
+    cancelAllOrders(): Promise<PolymarketCancelResponse>;
+    getOrderBook(tokenId: string): Promise<PolymarketOrderBook>;
+    private ensureApprovals;
+    buy(tokenId: string, size: number): Promise<void>;
+    sell(tokenId: string, size: number): Promise<void>;
+    /**
+     * Place a limit buy order
+     */
+    buyLimit(tokenId: string, price: number, size: number): Promise<PolymarketOrderResponse>;
+    /**
+     * Place a limit sell order
+     */
+    sellLimit(tokenId: string, price: number, size: number): Promise<PolymarketOrderResponse>;
+    /**
+     * Place a market buy order
+     */
+    buyMarket(tokenId: string, amount: number, slippage?: number): Promise<PolymarketOrderResponse>;
+    /**
+     * Place a market sell order
+     */
+    sellMarket(tokenId: string, size: number, slippage?: number): Promise<PolymarketOrderResponse>;
+    getPrice(ticker: string): Promise<number>;
+    getIndicator(ticker: string, indicator: string, params?: any): Promise<number>;
+    search(params: SearchParams): Promise<SearchResults>;
+    getMarket(idOrSlug: string): Promise<GammaMarket>;
+    /**
+     * Get markets from Polymarket Gamma API with full filter support
+     * https://docs.polymarket.com/api-reference/markets/list-markets
+     */
+    getMarkets(filters?: MarketFilters & {
+        end_date_min?: string;
+        end_date_max?: string;
+        start_date_min?: string;
+        start_date_max?: string;
+        liquidity_num_min?: number;
+        liquidity_num_max?: number;
+        volume_num_min?: number;
+        volume_num_max?: number;
+        limit?: number;
+        offset?: number;
+        order?: string;
+        ascending?: boolean;
+        closed?: boolean;
+    }): Promise<GammaMarket[]>;
+    getMarketTags(marketId: string): Promise<Tag[]>;
+    getEvent(idOrSlug: string): Promise<GammaEvent>;
+    getEvents(filters?: EventFilters): Promise<GammaEvent[]>;
+    getEventTags(eventId: string): Promise<Tag[]>;
+    getEventsPaginated(filters?: EventPaginationFilters): Promise<PaginatedResponse<GammaEvent>>;
+    getTags(params?: PaginationParams): Promise<Tag[]>;
+    getTag(idOrSlug: string): Promise<Tag>;
+    getRelatedTags(idOrSlug: string): Promise<Tag[]>;
+    getRelatedTagsTags(idOrSlug: string): Promise<Tag[]>;
+    getTeams(params?: PaginationParams): Promise<Team[]>;
+    getSports(params?: PaginationParams): Promise<Sport[]>;
+    getSeries(params?: PaginationParams): Promise<Series[]>;
+    getSeriesById(seriesId: string): Promise<Series>;
+    getComments(params?: PaginationParams): Promise<GammaComment[]>;
+    getComment(commentId: string): Promise<GammaComment>;
+    getCommentsByUser(userAddress: string, params?: PaginationParams): Promise<GammaComment[]>;
+    private readonly DATA_API_BASE;
+    private fetchData;
+    getPositions(user: string, params?: any): Promise<any[]>;
+    getTrades(user: string, params?: any): Promise<any[]>;
+    getActivity(user: string, params?: any): Promise<any[]>;
+    getTopHolders(marketId: string): Promise<any[]>;
+    getPortfolioValue(user: string): Promise<number>;
+    getClosedPositions(user: string, params?: any): Promise<any[]>;
+    getTradedMarketsCount(user: string): Promise<number>;
+    getOpenInterest(marketId: string): Promise<number>;
+    getPosition(ticker: string): Promise<any | null>;
+}
+//# sourceMappingURL=polymarket-client.d.ts.map