import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

void main() async {
  final client = PolymarketClient.public();

  // Get active events
  final events = await client.gamma.events.listEvents(
    limit: 10,
    closed: false,
  );

  for (final event in events) {
    print('${event.title} - ${event.markets.length} markets');
  }

  // Get order book
  final book = await client.clob.orderbook.getOrderBook('token-id');
  print('Best bid: ${book.bestBid}, Best ask: ${book.bestAsk}');

  client.close();
}

import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

void main() async {
  final client = PolymarketClient.authenticated(
    credentials: ApiCredentials(
      apiKey: 'your-api-key',
      secret: 'your-secret',
      passphrase: 'your-passphrase',
    ),
    funder: '0xYourWalletAddress',
  );

  // Get your open orders
  final orders = await client.clob.orders.getOpenOrders();
  print('You have ${orders.length} open orders');

  // Get your positions
  final positions = await client.data.positions.getPositions(
    userAddress: '0xYourWalletAddress',
  );

  for (final pos in positions) {
    print('${pos.title}: ${pos.size} shares @ ${pos.avgPrice}');
  }

  client.close();
}

import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

void main() async {
  final client = PolymarketClient.public();

  await client.clobWebSocket.connect();

  // Subscribe to price changes
  client.clobWebSocket.subscribeToPriceChanges(['token-id-1', 'token-id-2'])
    .listen((msg) {
      for (final change in msg.priceChanges) {
        print('${change.assetId}: ${change.price}');
      }
    });

  // Subscribe to order book updates
  client.clobWebSocket.subscribeToOrderBook('token-id')
    .listen((book) {
      print('Best bid: ${book.bestBid}, Best ask: ${book.bestAsk}');
    });

  // Crypto prices via RTDS
  await client.rtdsWebSocket.connect(topics: [RtdsTopic.cryptoPrices]);
  client.rtdsWebSocket.cryptoPrices.listen((msg) {
    print('BTC: ${msg.getPrice('BTC')}, ETH: ${msg.getPrice('ETH')}');
  });
}

import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

void main() async {
  // Create trading-enabled client
  final client = PolymarketClient.withTrading(
    credentials: ApiCredentials(
      apiKey: 'your-api-key',
      secret: 'your-secret',
      passphrase: 'your-passphrase',
    ),
    walletAddress: '0xYourWalletAddress',
    privateKey: '0xYourPrivateKey',
  );

  // Place an order (builds, signs, submits in one call)
  final response = await client.placeOrder(
    tokenId: 'token-id',
    side: OrderSide.buy,
    size: 10.0,   // 10 shares
    price: 0.55,  // 55 cents
  );
  print('Order ID: ${response.orderId}');

  // Or build and sign manually for more control
  final signedOrder = client.buildSignedOrder(
    tokenId: 'token-id',
    side: OrderSide.sell,
    size: 5.0,
    price: 0.60,
    negRisk: false,  // Set true for negative risk markets
  );
  final result = await client.clob.orders.postOrder(
    signedOrder.toJson(),
    orderType: OrderType.gtc,
  );

  client.close();
}

import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

void main() {
  // Generate a new HD wallet
  final mnemonic = HdWallet.generateMnemonic(); // 12 words
  final mnemonic24 = HdWallet.generateMnemonic(wordCount: 24);
  print('Mnemonic: $mnemonic');

  // Validate a mnemonic
  final isValid = HdWallet.validateMnemonic(mnemonic);
  print('Valid: $isValid');

  // Derive wallet from mnemonic
  final wallet = HdWallet.deriveWallet(mnemonic);
  print('Address: ${wallet.address}');
  print('Private Key: ${wallet.privateKey}');

  // Derive multiple wallets (different indices)
  final wallet0 = HdWallet.deriveWallet(mnemonic, index: 0);
  final wallet1 = HdWallet.deriveWallet(mnemonic, index: 1);
  final wallet2 = HdWallet.deriveWallet(mnemonic, index: 2);
}

import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

void main() async {
  final client = PolymarketClient.withTrading(
    credentials: credentials,
    walletAddress: '0x...',
    privateKey: '0x...',
  );

  // Check balances
  final maticBalance = await client.polygon.getMaticBalance('0x...');
  final usdcBalance = await client.polygon.getUsdcBalance('0x...');
  print('MATIC: $maticBalance, USDC: $usdcBalance');

  // Check USDC allowance for trading
  final allowance = await client.polygon.getUsdcAllowance(
    owner: '0xYourAddress',
    spender: PolymarketConstants.exchangeAddress,
  );
  print('Allowance: $allowance');

  // Approve USDC for trading (if needed)
  final txHash = await client.polygon.approveUsdc(
    credentials: EthPrivateKey.fromHex('0x...'),
    spender: PolymarketConstants.exchangeAddress,
    amount: BigInt.from(1000000000), // 1000 USDC (6 decimals)
  );
  print('Approval TX: $txHash');

  // Wait for transaction confirmation
  final receipt = await client.polygon.waitForTransaction(txHash);
  print('Confirmed in block: ${receipt?.blockNumber}');

  client.close();
}

// Events
final events = await client.gamma.events.listEvents(limit: 100, closed: false);
final event = await client.gamma.events.getById(123);
final event = await client.gamma.events.getBySlug('event-slug');

// Convenience methods
final hotEvents = await client.gamma.events.getHotEvents();
final featuredEvents = await client.gamma.events.getFeaturedEvents();
final endingSoon = await client.gamma.events.getEndingSoon(within: Duration(days: 3));
final politicsEvents = await client.gamma.events.getByTagSlug(TagSlug.politics);

// Markets
final markets = await client.gamma.markets.listMarkets(active: true);
final market = await client.gamma.markets.getByConditionId('condition-id');
final topVolume = await client.gamma.markets.getTopByVolume(limit: 20);
final topLiquidity = await client.gamma.markets.getTopByLiquidity();

// Preset queries (60+ available)
final results = await client.gamma.search.search(query: SearchQuery.bitcoin);
final election = await client.gamma.search.search(query: SearchQuery.election);
final nfl = await client.gamma.search.search(query: SearchQuery.nfl);

// Custom queries
final custom = await client.gamma.search.search(
  query: SearchQuery.custom('my search'),
);

// Convenience methods
final btcResults = await client.gamma.search.searchBitcoin();
final electionResults = await client.gamma.search.searchElection();
final aiResults = await client.gamma.search.searchAI();

// Browse all presets by category
SearchQuery.cryptoPresets;    // [bitcoin, ethereum, solana, ...]
SearchQuery.politicsPresets;  // [election, trump, biden, ...]
SearchQuery.sportsPresets;    // [nfl, nba, mlb, ...]

// Tags
final tags = await client.gamma.tags.listTags(order: TagOrderBy.volume);
final related = await client.gamma.tags.getRelatedTags(tagId);

// Comments
final comments = await client.gamma.comments.listComments(
  parentEntityType: ParentEntityType.market,
  parentEntityId: 123,
  order: CommentOrderBy.createdAt,
);

// Profiles
final profile = await client.gamma.profiles.getByAddress('0x...');

// Leaderboard
final leaders = await client.gamma.leaderboard.getTopByProfit(limit: 10);

// Order Book
final book = await client.clob.orderbook.getOrderBook('token-id');
final books = await client.clob.orderbook.getOrderBooks(['token-1', 'token-2']);

// Pricing
final price = await client.clob.pricing.getPrice('token-id', OrderSide.buy);
final midpoint = await client.clob.pricing.getMidpoint('token-id');
final spread = await client.clob.pricing.getSpread('token-id');
final history = await client.clob.pricing.getPriceHistory(
  'token-id',
  interval: PriceHistoryInterval.hour1,
);

// Orders
final response = await client.clob.orders.postOrder(signedOrder);
final orders = await client.clob.orders.getOpenOrders();
await client.clob.orders.cancelOrder('order-id');
await client.clob.orders.cancelAllOrders();

// Trades
final trades = await client.clob.trades.getTrades(market: 'condition-id');

// Positions
final positions = await client.data.positions.getPositions(
  userAddress: '0x...',
  sortBy: SortBy.value,
  sortDirection: SortDirection.desc,
);
final closed = await client.data.positions.getClosedPositions(userAddress: '0x...');

// Trades
final trades = await client.data.trades.getUserTrades(userAddress: '0x...');
final marketTrades = await client.data.trades.getMarketTrades(conditionId: 'cond-id');

// Activity
final activity = await client.data.activity.getUserActivity(
  userAddress: '0x...',
  types: [ActivityType.trade, ActivityType.redeem],
);

// Holders
final holders = await client.data.holders.getTokenHolders(tokenId: 'token-id');

// Portfolio Value
final value = await client.data.value.getValue('0x...');
print('Total: ${value.totalValue}, PnL: ${value.totalPnl}');

// Leaderboard
final leaders = await client.data.leaderboard.getLeaderboard(
  window: LeaderboardWindow.day7,
  type: LeaderboardType.profit,
);

// CLOB WebSocket
await client.clobWebSocket.connect();

// Market data (public)
client.clobWebSocket.subscribeToMarket(['token-id']);
client.clobWebSocket.bookUpdates.listen((book) => print(book));
client.clobWebSocket.priceChanges.listen((price) => print(price));
client.clobWebSocket.lastTradePrices.listen((trade) => print(trade));

// User data (requires auth)
client.clobWebSocket.subscribeToUser(['token-id']);
client.clobWebSocket.userOrders.listen((order) => print(order));
client.clobWebSocket.userTrades.listen((trade) => print(trade));

// RTDS WebSocket (crypto prices, comments)
await client.rtdsWebSocket.connect(topics: [RtdsTopic.cryptoPrices, RtdsTopic.comments]);
client.rtdsWebSocket.cryptoPrices.listen((msg) => print(msg));
client.rtdsWebSocket.comments.listen((comment) => print(comment));

// Using presets (compile-time safe)
final events = await client.gamma.events.getByTagSlug(TagSlug.crypto);
final markets = await client.gamma.markets.listMarkets(tagSlug: TagSlug.nfl);

// Custom tags (for user-created tags)
final custom = await client.gamma.tags.getBySlug(TagSlug.custom('my-custom-tag'));

// Get TagSlug from Tag model
final tag = await client.gamma.tags.getById(123);
final slug = tag.slugEnum;  // TagSlug (preset or custom)
final preset = tag.slugPreset;  // TagSlug? (only if matches a preset)

import 'package:polybrainz_polymarket/polybrainz_polymarket.dart';

// Detect from a single event
final result = CategoryDetector.detectFromEvent(event);
print(result.category);       // MarketCategory.politics
print(result.subcategories);  // [PoliticsSubcategory.usPresidential]
print(result.tagSlugs);       // ['politics', 'us-presidential', 'trump']

// Extension methods on lists
final markets = await client.gamma.markets.listMarkets(limit: 100);
final categories = markets.detectCategories();
final unique = markets.uniqueCategories;  // Set<MarketCategory>

// Group by category
final grouped = markets.groupByCategory();
for (final entry in grouped.entries) {
  print('${entry.key.label}: ${entry.value.length} markets');
}

// Filter by category using TagSlug (130+ presets)
final cryptoMarkets = await client.gamma.markets.getByTagSlug(TagSlug.crypto);
final nflEvents = await client.gamma.events.listEvents(
  tagSlug: TagSlug.nfl,
);

final client = PolymarketClient.authenticated(
  credentials: ApiCredentials(
    apiKey: 'your-api-key',
    secret: 'your-secret',
    passphrase: 'your-passphrase',
  ),
  funder: '0xYourWalletAddress',
);

final client = PolymarketClient.withPrivateKey(
  privateKey: '0xYourPrivateKey',
  walletAddress: '0xYourWalletAddress',
);

// Create or derive API key using EIP-712 L1 auth
await client.clob.auth?.createOrDeriveApiKey();

// Now the client has credentials and can trade
final orders = await client.clob.orders.getOpenOrders();

A market has ONE condition ID but TWO token IDs.

Some markets support "negative risk" where Yes + No tokens can be merged/split for capital efficiency. Check the negRisk field on markets.