@slvr-labs/sdk 0.1.0

package/examples/expected-value-strategy.ts

@@ -0,0 +1,255 @@
+/**
+ * Example: Expected-value grid-mining bot
+ *
+ * This bot only bets when the round is **+EV** — i.e. the expected value of
+ * mining SLVR (plus the jackpot term) exceeds the ETH you bleed to the protocol
+ * fee. It uses the SDK's built-in grid-mining calculator (`computeGridMiningEv` /
+ * `sdk.estimateRoundEv`) and the SDK's SLVR price reader (`sdk.price`), so the
+ * math matches the protocol's own edge calculator.
+ *
+ * How the decision works (see the docs on `computeGridMiningEv` for the full
+ * model):
+ *   - SLVR mined/round ≈ (stake / pot) * emissionPerRound
+ *   - ETH bleed/round   = feeFraction * stake        (you get the rest of the pot back pro-rata)
+ *   - net EV/round      = slvrValue - bleed + jackpotEV
+ * Because both terms scale with your stake, the edge depends on **pot vs SLVR
+ * price**, not on bet size: mining is profitable while the pot is *below* the
+ * break-even pot. This bot bets when net EV per round clears a threshold.
+ *
+ * When it bets, it spreads the stake across all 25 squares in proportion to the
+ * current pot — the coverage the EV model assumes, so you hold a `stake/pot`
+ * slice of whichever square wins. (Tilting toward the least-allocated squares —
+ * see `least-allocated-strategy.ts` — would raise SLVR yield *above* this
+ * estimate, so treating this EV as a floor is conservative.)
+ *
+ * Run: set PRIVATE_KEY and `ts-node expected-value-strategy.ts` (or import the
+ * class). To adapt into your own project, change the `../src` import to
+ * `@slvr-labs/sdk`.
+ */
+
+import { createPublicClient, createWalletClient, http, parseEther, formatEther } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { SlvrSDK, robinhoodChain, deployments, GRID_SIZE, type GridMiningEv } from '../src';
+
+export interface ExpectedValueBotOptions {
+  /** ETH to commit per round. Default: 0.1 ETH. */
+  stakeEth?: number;
+  /** Minimum net EV (in ETH per round) required to bet. Default: 0 (bet on any +EV round). */
+  minNetEth?: number;
+  /** Value SLVR net of the 10% refining fee (cashing out) vs at full price (holding). Default: false (hold). */
+  cashOut?: boolean;
+  /** ETH currently in the jackpot pool, to include the jackpot term. Default: 0. */
+  jackpotPool?: number;
+  /** Jackpot odds (1-in-N). Default: the protocol default (625). */
+  jackpotOdds?: number;
+  /**
+   * ETH/USD price override, for logging values in USD. If omitted, the bot uses
+   * the SDK's Chainlink feed (`sdk.ethUsd`) — which is wired for Robinhood Chain,
+   * so USD figures show automatically. Set this only to override the feed or on a
+   * chain that lacks one.
+   */
+  ethUsd?: number;
+  /** How often to check, in milliseconds. Default: 5000. */
+  checkInterval?: number;
+}
+
+/**
+ * A bot that mines the grid only when the expected value is positive.
+ */
+export class ExpectedValueBot {
+  private sdk: SlvrSDK;
+  private stakeEth: number;
+  private minNetEth: number;
+  private cashOut: boolean;
+  private jackpotPool: number;
+  private jackpotOdds: number | undefined;
+  private ethUsd: number | undefined;
+  private checkInterval: number;
+  private isRunning = false;
+  private intervalId?: ReturnType<typeof setInterval>;
+  private lastBetRound?: bigint;
+
+  constructor(sdk: SlvrSDK, options: ExpectedValueBotOptions = {}) {
+    this.sdk = sdk;
+    this.stakeEth = options.stakeEth ?? 0.1;
+    this.minNetEth = options.minNetEth ?? 0;
+    this.cashOut = options.cashOut ?? false;
+    this.jackpotPool = options.jackpotPool ?? 0;
+    this.jackpotOdds = options.jackpotOdds;
+    this.ethUsd = options.ethUsd;
+    this.checkInterval = options.checkInterval ?? 5000;
+  }
+
+  /** Evaluate the current round once: log the EV breakdown and bet if it clears the threshold. */
+  async checkOnce(): Promise<GridMiningEv | null> {
+    const roundId = await this.sdk.lottery.currentRoundId();
+
+    // SLVR price in both ETH and USD (USD needs an ETH/USD source — the SDK's
+    // Chainlink feed if configured, else the `ethUsd` option; otherwise null).
+    const price = await this.sdk.getSlvrPrice({ ethUsd: this.ethUsd });
+    console.log(
+      `SLVR price: ${price.eth.toExponential(4)} ETH` +
+        (price.usd !== null ? ` · $${price.usd.toFixed(4)}` : ' · (USD unavailable — no ETH/USD source)')
+    );
+
+    // Compute the expected value for this round (pulls pot, emission and SLVR price on-chain).
+    const ev = await this.sdk.estimateRoundEv({
+      stake: this.stakeEth,
+      roundId,
+      cashOut: this.cashOut,
+      jackpotPool: this.jackpotPool,
+      jackpotOdds: this.jackpotOdds,
+      slvrPriceEth: price.eth, // reuse the price we just read
+    });
+
+    // Derive the ETH/USD we ended up using, to also show net EV in USD.
+    const ethUsd = price.usd !== null ? price.usd / price.eth : null;
+    const netUsd = ethUsd !== null ? ` (${ev.netEth * ethUsd >= 0 ? '+' : ''}$${(ev.netEth * ethUsd).toFixed(4)})` : '';
+
+    console.log(
+      `Round ${roundId}: share ${(ev.share * 100).toFixed(2)}% · ` +
+        `mine ${ev.slvrMined.toFixed(4)} SLVR (${ev.slvrValueEth.toFixed(6)} ETH) · ` +
+        `bleed ${ev.ethBleed.toFixed(6)} ETH · jackpot +${ev.jackpotEvEth.toFixed(6)} ETH · ` +
+        `NET ${ev.netEth >= 0 ? '+' : ''}${ev.netEth.toFixed(6)} ETH/round${netUsd} ` +
+        `(edge ${(ev.edgeRatio * 100).toFixed(2)}%, break-even pot ${ev.breakEvenPot.toFixed(4)} ETH)`
+    );
+
+    if (this.lastBetRound === roundId) {
+      console.log('  already bet this round — skipping');
+      return ev;
+    }
+
+    if (ev.netEth < this.minNetEth) {
+      console.log(
+        `  skip: net EV ${ev.netEth.toFixed(6)} < threshold ${this.minNetEth} ETH ` +
+          `(pot above break-even — wait for it to shrink or SLVR to rise)`
+      );
+      return ev;
+    }
+
+    if (!(await this.sdk.lottery.roundOpen(roundId))) {
+      console.log('  skip: round is not open for betting');
+      return ev;
+    }
+
+    await this.placeGridBet(roundId);
+    this.lastBetRound = roundId;
+    return ev;
+  }
+
+  /**
+   * Spread the stake across all {@link GRID_SIZE} squares in proportion to the
+   * current pot (with a floor so every square is covered and we always hold the
+   * winner). This is the coverage the grid-mining EV model assumes.
+   */
+  private async placeGridBet(roundId: bigint): Promise<void> {
+    const stakeWei = parseEther(this.stakeEth.toString());
+
+    const squaresData = await this.sdk.lottery.getRoundSquares(roundId);
+    const totals: bigint[] = Array.from(
+      { length: GRID_SIZE },
+      (_, i) => squaresData.find((s) => s.square === i)?.total ?? 0n
+    );
+    const sumTotals = totals.reduce((a, b) => a + b, 0n);
+
+    // Floor keeps empty squares covered so we never miss the winning square.
+    const floor = sumTotals / BigInt(GRID_SIZE) + 1n;
+    const weights = totals.map((t) => t + floor);
+    const sumWeights = weights.reduce((a, b) => a + b, 0n);
+
+    const amounts = weights.map((w) => (stakeWei * w) / sumWeights);
+    // Push any rounding dust onto the first square so the amounts sum to exactly stakeWei.
+    const allocated = amounts.reduce((a, b) => a + b, 0n);
+    amounts[0] = (amounts[0] ?? 0n) + (stakeWei - allocated);
+
+    const squares = Array.from({ length: GRID_SIZE }, (_, i) => i);
+
+    console.log(`  betting ${formatEther(stakeWei)} ETH across all ${GRID_SIZE} squares…`);
+    const txHash = await this.sdk.lottery.bet({ roundId, squares, amounts });
+    console.log(`  ✅ bet placed: ${txHash}`);
+  }
+
+  /** Start the polling loop. */
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      console.log('Bot is already running');
+      return;
+    }
+    if (!this.sdk.getWalletClient()) {
+      throw new Error('Wallet client required for expected-value betting');
+    }
+
+    this.isRunning = true;
+    console.log('📈 Expected-value bot started');
+    console.log(
+      `Stake ${this.stakeEth} ETH/round · bet when net EV ≥ ${this.minNetEth} ETH · ` +
+        `mode ${this.cashOut ? 'cash-out (−10% refine)' : 'hold'}`
+    );
+
+    const tick = async () => {
+      try {
+        await this.checkOnce();
+      } catch (err) {
+        console.error('  error during check:', err instanceof Error ? err.message : err);
+      }
+    };
+
+    await tick();
+    this.intervalId = setInterval(tick, this.checkInterval);
+  }
+
+  /** Stop the polling loop. */
+  stop(): void {
+    if (this.intervalId) clearInterval(this.intervalId);
+    this.isRunning = false;
+    console.log('🛑 Expected-value bot stopped');
+  }
+}
+
+/**
+ * Runnable entry point: builds a wallet-backed SDK on Robinhood Chain (using the
+ * shipped `deployments` + `robinhoodChain`) and starts the bot.
+ */
+export async function exampleExpectedValueBot(): Promise<void> {
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error('PRIVATE_KEY environment variable is required');
+  }
+
+  const account = privateKeyToAccount(privateKey as `0x${string}`);
+  const publicClient = createPublicClient({ chain: robinhoodChain, transport: http() });
+  const walletClient = createWalletClient({ chain: robinhoodChain, transport: http(), account });
+
+  // deployments.robinhood.addresses includes slvrEthPair, so sdk.price is available.
+  const sdk = new SlvrSDK({
+    publicClient,
+    walletClient,
+    addresses: deployments.robinhood.addresses,
+  });
+
+  const bot = new ExpectedValueBot(sdk, {
+    stakeEth: 0.1, // commit 0.1 ETH per +EV round
+    minNetEth: 0, // bet on any positive-EV round
+    cashOut: false, // value mined SLVR at full price (holding/staking it)
+    // USD comes from the SDK's Chainlink ETH/USD feed automatically on Robinhood
+    // Chain. Set ETH_USD to override it (e.g. `ETH_USD=1815 ts-node …`).
+    ethUsd: process.env.ETH_USD ? Number(process.env.ETH_USD) : undefined,
+    checkInterval: 5000,
+  });
+
+  await bot.start();
+
+  process.on('SIGINT', () => {
+    console.log('\nReceived SIGINT, stopping bot…');
+    bot.stop();
+    process.exit(0);
+  });
+}
+
+// Run directly: `PRIVATE_KEY=0x... ts-node expected-value-strategy.ts`
+if (require.main === module) {
+  exampleExpectedValueBot().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/examples/fixed-squares-strategy.ts

@@ -0,0 +1,176 @@
+/**
+ * Example: Fixed Squares Strategy
+ * 
+ * This strategy bets on a fixed set of squares every round
+ * when the total wager is below the threshold.
+ * 
+ * Perfect for users who want to consistently bet on specific squares.
+ */
+
+import { BettingStrategy } from './strategy-base';
+import { parseEther } from 'viem';
+import { SlvrSDK } from '../src';
+
+/**
+ * Configuration for fixed squares strategy
+ */
+export interface FixedSquaresConfig {
+  /** Squares to bet on (0-24) */
+  squares: number[];
+  /** Amount to bet per square (in wei) */
+  amountPerSquare: bigint;
+  /** Optional: different amount for each square (overrides amountPerSquare) */
+  amounts?: bigint[];
+  /** Threshold in wei - only bet when round total wager is below this */
+  threshold?: bigint;
+  /** How often to check rounds (in milliseconds) */
+  checkInterval?: number;
+}
+
+/**
+ * Strategy that bets on fixed squares every round
+ */
+export class FixedSquaresStrategy extends BettingStrategy {
+  private squares: number[];
+  private amountPerSquare: bigint;
+  private amounts?: bigint[];
+
+  constructor(sdk: SlvrSDK, config: FixedSquaresConfig) {
+    super(sdk, {
+      threshold: config.threshold,
+      checkInterval: config.checkInterval,
+    });
+
+    // Validate squares
+    if (!config.squares || config.squares.length === 0) {
+      throw new Error('At least one square must be specified');
+    }
+
+    for (const square of config.squares) {
+      if (square < 0 || square >= 25) {
+        throw new Error(`Invalid square: ${square}. Must be 0-24`);
+      }
+    }
+
+    // Check for duplicates
+    const unique = new Set(config.squares);
+    if (unique.size !== config.squares.length) {
+      throw new Error('Duplicate squares not allowed');
+    }
+
+    this.squares = config.squares;
+    this.amountPerSquare = config.amountPerSquare;
+    this.amounts = config.amounts;
+
+    // Validate amounts array if provided
+    if (this.amounts) {
+      if (this.amounts.length !== this.squares.length) {
+        throw new Error('Amounts array length must match squares array length');
+      }
+      for (const amount of this.amounts) {
+        if (amount <= 0n) {
+          throw new Error('All amounts must be greater than 0');
+        }
+      }
+    } else if (this.amountPerSquare <= 0n) {
+      throw new Error('Amount per square must be greater than 0');
+    }
+  }
+
+  /**
+   * Always bet on the fixed squares
+   */
+  protected async selectSquares(): Promise<number[]> {
+    return this.squares;
+  }
+
+  /**
+   * Use configured amounts
+   */
+  protected async calculateAmounts(): Promise<bigint[]> {
+    if (this.amounts) {
+      return this.amounts;
+    }
+    return this.squares.map(() => this.amountPerSquare);
+  }
+
+  /**
+   * Log configuration
+   */
+  protected logConfig(): void {
+    super.logConfig();
+    console.log(`   Squares: ${this.squares.join(', ')}`);
+    const total = this.amounts
+      ? this.amounts.reduce((sum, amt) => sum + amt, 0n)
+      : this.amountPerSquare * BigInt(this.squares.length);
+    console.log(`   Amount per square: ${SlvrSDK.formatToken(this.amountPerSquare)} ETH`);
+    console.log(`   Total bet per round: ${SlvrSDK.formatToken(total)} ETH`);
+  }
+}
+
+/**
+ * Example usage
+ */
+export async function exampleFixedSquaresStrategy() {
+  const { createPublicClient, createWalletClient, http } = await import('viem');
+  const { defineChain } = await import('viem');
+  const { privateKeyToAccount } = await import('viem/accounts');
+  const { SlvrSDK } = await import('../src');
+  const { CONTRACTS, ROBINHOOD_CHAIN } = await import('./constants');
+
+  // Create clients
+  const robinhood = defineChain(ROBINHOOD_CHAIN);
+  const publicClient = createPublicClient({
+    chain: robinhood,
+    transport: http(),
+  });
+
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error('PRIVATE_KEY environment variable is required');
+  }
+
+  const account = privateKeyToAccount(privateKey as `0x${string}`);
+  const walletClient = createWalletClient({
+    chain: robinhood,
+    transport: http(),
+    account,
+  });
+
+  // Initialize SDK
+  const sdk = new SlvrSDK({
+    publicClient,
+    walletClient,
+    addresses: {
+      lottery: CONTRACTS.LOTTERY,
+      staking: CONTRACTS.STAKING,
+      token: CONTRACTS.TOKEN,
+      autoCommit: CONTRACTS.AUTO_COMMIT !== '0x...' ? CONTRACTS.AUTO_COMMIT : undefined,
+    },
+  });
+
+  // Create strategy: bet on squares 0, 5, 10, 15, 20 every round
+  const strategy = new FixedSquaresStrategy(sdk, {
+    squares: [0, 5, 10, 15, 20], // Bet on these 5 squares
+    amountPerSquare: parseEther('1'), // 1 ETH per square
+    threshold: parseEther('100'), // Only bet when round has < 100 ETH
+    checkInterval: 5000, // Check every 5 seconds
+  });
+
+  // Start the strategy
+  await strategy.start();
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\nReceived SIGINT, stopping strategy...');
+    strategy.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    console.log('\nReceived SIGTERM, stopping strategy...');
+    strategy.stop();
+    process.exit(0);
+  });
+}
+

package/examples/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Example exports
+ * 
+ * Import and use these examples to understand how to use the Slvr SDK
+ */
+
+// Base strategy class for creating custom strategies
+export { BettingStrategy, StrategyConfig, BetDecision } from './strategy-base';
+
+// Pre-built strategies
+export { AutomatedBettingBot, exampleAutomatedBetting } from './automated-betting';
+export { LeastAllocatedStrategy, exampleLeastAllocatedStrategy } from './least-allocated-strategy';
+export { CombinedBettingBot, exampleCombinedStrategy } from './combined-strategy';
+export { ExpectedValueBot, exampleExpectedValueBot } from './expected-value-strategy';
+export type { ExpectedValueBotOptions } from './expected-value-strategy';
+export { FixedSquaresStrategy, exampleFixedSquaresStrategy, FixedSquaresConfig } from './fixed-squares-strategy';
+
+// Custom strategy examples
+export {
+  LeastAllocatedCustomStrategy,
+  RandomSquaresStrategy,
+  MostBettorsStrategy,
+  WeightedAllocationStrategy,
+  ConditionalStrategy,
+} from './custom-strategy-example';
+
+// Utilities
+export { simpleExample } from './simple-example';
+export { CONTRACTS, ROBINHOOD_CHAIN } from './constants';
+

package/examples/least-allocated-strategy.ts

@@ -0,0 +1,224 @@
+/**
+ * Example: Betting strategy that targets squares with least allocation
+ * 
+ * This example shows how to:
+ * 1. Get all squares and their current allocations
+ * 2. Identify squares with the least funds
+ * 3. Distribute bets across these squares
+ */
+
+import { SlvrSDK } from '../src';
+import { parseEther } from 'viem';
+
+/**
+ * Strategy that bets on squares with the least allocation
+ */
+export class LeastAllocatedStrategy {
+  private sdk: SlvrSDK;
+
+  constructor(sdk: SlvrSDK) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Get squares sorted by allocation (least to most)
+   */
+  async getSquaresByAllocation(roundId: bigint): Promise<
+    Array<{ square: number; total: bigint; bettors: bigint; percentage: number }>
+  > {
+    const squares = await this.sdk.lottery.getRoundSquares(roundId);
+    
+    // Calculate total across all squares
+    const totalAllocation = squares.reduce((sum, sq) => sum + sq.total, 0n);
+    
+    // Add percentage and sort by total (ascending)
+    const withPercentage = squares
+      .map(({ square, total, bettors }) => ({
+        square,
+        total,
+        bettors,
+        percentage: totalAllocation > 0n 
+          ? Number((total * 10000n) / totalAllocation) / 100 
+          : 0,
+      }))
+      .sort((a, b) => {
+        if (a.total < b.total) return -1;
+        if (a.total > b.total) return 1;
+        return 0;
+      });
+
+    return withPercentage;
+  }
+
+  /**
+   * Get the N squares with least allocation
+   */
+  async getLeastAllocatedSquares(
+    roundId: bigint,
+    count: number = 5
+  ): Promise<number[]> {
+    const sorted = await this.getSquaresByAllocation(roundId);
+    return sorted.slice(0, count).map(({ square }) => square);
+  }
+
+  /**
+   * Calculate bet amounts for least allocated squares
+   * Distributes total bet amount evenly across selected squares
+   */
+  calculateBetAmounts(
+    totalAmount: bigint,
+    squareCount: number
+  ): bigint[] {
+    const amountPerSquare = totalAmount / BigInt(squareCount);
+    const remainder = totalAmount % BigInt(squareCount);
+    
+    const amounts = Array(squareCount).fill(amountPerSquare);
+    
+    // Add remainder to first square to ensure exact total
+    if (remainder > 0n) {
+      amounts[0] += remainder;
+    }
+    
+    return amounts;
+  }
+
+  /**
+   * Place a bet on least allocated squares
+   */
+  async betOnLeastAllocated(
+    roundId: bigint,
+    totalBetAmount: bigint,
+    squareCount: number = 5
+  ): Promise<`0x${string}`> {
+    if (!this.sdk.getWalletClient()) {
+      throw new Error('Wallet client required for betting');
+    }
+
+    // Get squares with least allocation
+    const squares = await this.getLeastAllocatedSquares(roundId, squareCount);
+    
+    if (squares.length === 0) {
+      throw new Error('No squares available');
+    }
+
+    // Calculate amounts
+    const amounts = this.calculateBetAmounts(totalBetAmount, squares.length);
+
+    console.log(`🎯 Betting on ${squares.length} least allocated squares:`);
+    squares.forEach((square, i) => {
+      console.log(`  Square ${square}: ${SlvrSDK.formatToken(amounts[i])} ETH`);
+    });
+    console.log(`💰 Total: ${SlvrSDK.formatToken(totalBetAmount)} ETH`);
+
+    // Place the bet
+    return await this.sdk.lottery.bet({
+      roundId,
+      squares,
+      amounts,
+    });
+  }
+
+  /**
+   * Get detailed analysis of square allocations
+   */
+  async analyzeRound(roundId: bigint): Promise<{
+    roundId: bigint;
+    totalAllocation: bigint;
+    squares: Array<{
+      square: number;
+      total: bigint;
+      bettors: bigint;
+      percentage: number;
+      rank: number;
+    }>;
+    leastAllocated: number[];
+    mostAllocated: number[];
+  }> {
+    const sorted = await this.getSquaresByAllocation(roundId);
+    const totalAllocation = sorted.reduce((sum, sq) => sum + sq.total, 0n);
+
+    return {
+      roundId,
+      totalAllocation,
+      squares: sorted.map((sq, index) => ({
+        ...sq,
+        rank: index + 1,
+      })),
+      leastAllocated: sorted.slice(0, 5).map(({ square }) => square),
+      mostAllocated: sorted.slice(-5).reverse().map(({ square }) => square),
+    };
+  }
+}
+
+/**
+ * Example usage
+ * 
+ * Set PRIVATE_KEY environment variable to enable betting
+ */
+export async function exampleLeastAllocatedStrategy() {
+  const { createPublicClient, createWalletClient, http } = await import('viem');
+  const { defineChain } = await import('viem');
+  const { privateKeyToAccount } = await import('viem/accounts');
+  const { parseEther } = await import('viem');
+  const { SlvrSDK } = await import('../src');
+  const { CONTRACTS, ROBINHOOD_CHAIN } = await import('./constants');
+
+  // Create clients
+  const robinhood = defineChain(ROBINHOOD_CHAIN);
+  const publicClient = createPublicClient({
+    chain: robinhood,
+    transport: http(),
+  });
+
+  const privateKey = process.env.PRIVATE_KEY;
+  let walletClient: ReturnType<typeof createWalletClient> | undefined;
+  
+  if (privateKey) {
+    const account = privateKeyToAccount(privateKey as `0x${string}`);
+    walletClient = createWalletClient({
+      chain: robinhood,
+      transport: http(),
+      account,
+    });
+  }
+
+  // Initialize SDK
+  const sdk = new SlvrSDK({
+    publicClient,
+    walletClient,
+    addresses: {
+      lottery: CONTRACTS.LOTTERY,
+      staking: CONTRACTS.STAKING,
+      token: CONTRACTS.TOKEN,
+      autoCommit: CONTRACTS.AUTO_COMMIT !== '0x...' ? CONTRACTS.AUTO_COMMIT : undefined,
+    },
+  });
+
+  const strategy = new LeastAllocatedStrategy(sdk);
+  const roundId = await sdk.lottery.currentRoundId();
+
+  // Analyze the round
+  const analysis = await strategy.analyzeRound(roundId);
+  console.log('Round Analysis:', {
+    totalAllocation: SlvrSDK.formatToken(analysis.totalAllocation),
+    leastAllocated: analysis.leastAllocated,
+    mostAllocated: analysis.mostAllocated,
+  });
+
+  // Get squares with least allocation
+  const leastAllocated = await strategy.getLeastAllocatedSquares(roundId, 5);
+  console.log('Least allocated squares:', leastAllocated);
+
+  // Place bet on these squares (if wallet client is available)
+  if (walletClient) {
+    const txHash = await strategy.betOnLeastAllocated(
+      roundId,
+      parseEther('5'), // 5 ETH total
+      5 // Bet on 5 squares
+    );
+    console.log('Bet placed:', txHash);
+  } else {
+    console.log('Cannot place bet - set PRIVATE_KEY environment variable');
+  }
+}
+