@slvr-labs/sdk 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,3035 @@
+// src/index.ts
+import { formatEther } from "viem";
+
+// src/contracts/lottery.ts
+import { parseAbi as parseAbi2 } from "viem";
+
+// src/errors.ts
+import { BaseError, ContractFunctionRevertedError } from "viem";
+var SlvrSDKError = class _SlvrSDKError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SlvrSDKError";
+    Object.setPrototypeOf(this, _SlvrSDKError.prototype);
+  }
+};
+var WalletClientRequiredError = class _WalletClientRequiredError extends SlvrSDKError {
+  constructor(operation) {
+    super(`Wallet client required for ${operation}`, "WALLET_CLIENT_REQUIRED");
+    this.name = "WalletClientRequiredError";
+    Object.setPrototypeOf(this, _WalletClientRequiredError.prototype);
+  }
+};
+var ContractCallError = class _ContractCallError extends SlvrSDKError {
+  constructor(message, cause) {
+    super(message, "CONTRACT_CALL_ERROR");
+    this.cause = cause;
+    this.name = "ContractCallError";
+    Object.setPrototypeOf(this, _ContractCallError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends SlvrSDKError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR");
+    this.field = field;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var TransactionError = class _TransactionError extends SlvrSDKError {
+  constructor(message, txHash, cause) {
+    super(message, "TRANSACTION_ERROR");
+    this.txHash = txHash;
+    this.cause = cause;
+    this.name = "TransactionError";
+    Object.setPrototypeOf(this, _TransactionError.prototype);
+  }
+};
+var REVERT_HINTS = {
+  InsufficientValue: "msg.value did not cover the bet total (+ the one-time account-opening deposit for a new account).",
+  RoundNotOpen: "betting is closed for this round.",
+  NotResolved: "the round is not resolved yet.",
+  ResolveRequested: "the round is already being resolved; betting is closed.",
+  BadClaim: "nothing to claim \u2014 no winning bet on this round, or already claimed.",
+  NoAccount: "no miner account for this address yet (place a bet first to open one).",
+  BadAmount: "a zero or invalid amount.",
+  BadSquare: "a square index outside 0\u201324.",
+  DupSquare: "the same square appears twice in one bet.",
+  BadArrays: "squares and amounts arrays have mismatched lengths.",
+  ValueNotSum: "msg.value does not equal the sum of the bet amounts.",
+  MustSumTo100Percent: "allocation percentages must sum to 100%.",
+  NotAuthorized: "caller is not authorized (not the user or an approved delegate).",
+  NotCurrentRound: "that round is not the current one.",
+  CannotDelegateToSelf: "you cannot delegate to your own address.",
+  RandomnessNotSettled: "randomness for this round has not settled yet.",
+  TransferFailed: "an ETH/token transfer failed.",
+  JackpotNotSet: "no jackpot is configured for this round."
+};
+var SlvrRevertError = class _SlvrRevertError extends SlvrSDKError {
+  constructor(errorName, message, args, cause) {
+    super(message, "CONTRACT_REVERT");
+    this.errorName = errorName;
+    this.args = args;
+    this.cause = cause;
+    this.name = "SlvrRevertError";
+    Object.setPrototypeOf(this, _SlvrRevertError.prototype);
+  }
+};
+function decodeSlvrRevert(err) {
+  if (!(err instanceof BaseError)) return null;
+  const revert = err.walk((e) => e instanceof ContractFunctionRevertedError);
+  if (!revert) return null;
+  const data = revert.data;
+  const name = data?.errorName;
+  const hint = name ? REVERT_HINTS[name] : void 0;
+  const message = name ? `Reverted: ${name}${hint ? ` \u2014 ${hint}` : ""}` : revert.shortMessage || err.shortMessage || "contract reverted";
+  return new SlvrRevertError(name, message, data?.args, err);
+}
+
+// src/utils.ts
+import { isAddress, getAddress } from "viem";
+function validateAddress(address, fieldName = "address") {
+  if (!isAddress(address)) {
+    throw new ValidationError(`Invalid ${fieldName}: ${address}`, fieldName);
+  }
+  return getAddress(address);
+}
+function validateAmount(amount, fieldName = "amount") {
+  if (amount < 0n) {
+    throw new ValidationError(`${fieldName} must be non-negative`, fieldName);
+  }
+  if (amount === 0n) {
+    throw new ValidationError(`${fieldName} must be greater than zero`, fieldName);
+  }
+}
+function validateSquares(squares, gridSize = 25) {
+  if (squares.length === 0) {
+    throw new ValidationError("At least one square must be provided", "squares");
+  }
+  for (const square of squares) {
+    if (!Number.isInteger(square) || square < 0 || square >= gridSize) {
+      throw new ValidationError(
+        `Invalid square index: ${square}. Must be between 0 and ${gridSize - 1}`,
+        "squares"
+      );
+    }
+  }
+}
+function validateArrayLengths(arrays, fieldNames) {
+  if (arrays.length < 2) {
+    return;
+  }
+  const firstLength = arrays[0]?.length ?? 0;
+  for (let i = 1; i < arrays.length; i++) {
+    const currentArray = arrays[i];
+    const currentFieldName = fieldNames[i];
+    if (!currentArray || currentArray.length !== firstLength) {
+      throw new ValidationError(
+        `Array length mismatch: ${fieldNames[0]} has ${firstLength} items, but ${currentFieldName ?? `array ${i}`} has ${currentArray?.length ?? 0} items`,
+        currentFieldName
+      );
+    }
+  }
+}
+function validateBps(bps, fieldName = "bps") {
+  if (!Number.isInteger(bps) || bps < 0 || bps > 1e4) {
+    throw new ValidationError(
+      `${fieldName} must be an integer between 0 and 10000 (got ${bps})`,
+      fieldName
+    );
+  }
+}
+function validateBpsSum(bpsArray, fieldName = "bpsAlloc") {
+  const sum = bpsArray.reduce((acc, bps) => acc + bps, 0);
+  if (sum !== 1e4) {
+    throw new ValidationError(
+      `${fieldName} must sum to 10000 (got ${sum})`,
+      fieldName
+    );
+  }
+}
+async function waitForTransactionReceipt(publicClient, hash, timeout = 12e4) {
+  if (!publicClient.waitForTransactionReceipt) {
+    throw new Error("Public client does not support waitForTransactionReceipt");
+  }
+  return await publicClient.waitForTransactionReceipt({ hash, timeout });
+}
+
+// src/events.ts
+import { parseAbi, decodeEventLog } from "viem";
+var SlvrGridLotteryEvents = parseAbi([
+  "event BetPlaced(uint256 indexed roundId, address indexed beneficiary, uint256 total, uint8[] squares)",
+  "event Claimed(uint256 indexed roundId, address indexed user, uint256 nativeOut, uint256 slvrOut, uint256 refinedOut, uint256 refiningFee)",
+  "event RoundResolved(uint256 indexed roundId, uint8 winningSquare, bool jackpotHit, bool singleMinerRound, address indexed singleMinerWinner, uint256 winnerTotal, uint256 potForWinners, uint256 slvrForWinners, uint256 totalUnclaimedSlvr)",
+  "event RandomnessRequested(uint256 indexed roundId, bytes32 randomnessId)"
+]);
+var SlvrStakingEvents = parseAbi([
+  "event Staked(uint256 indexed tokenId, address indexed user, uint256 weight)",
+  "event Unstaked(uint256 indexed tokenId, address indexed user, uint256 weight)",
+  "event RewardClaimed(uint256 indexed tokenId, address indexed user, uint256 amount)",
+  "event RewardDistributed(uint256 amount)",
+  "event Checkpoint(uint256 indexed tokenId, uint256 oldWeight, uint256 newWeight)",
+  "event RewardsSettledOnBurn(uint256 indexed tokenId, address indexed owner, uint256 amount)",
+  "event PendingRewardsClaimed(address indexed user, uint256 amount)"
+]);
+var SlvrTokenEvents = parseAbi([
+  "event Transfer(address indexed from, address indexed to, uint256 value)",
+  "event Approval(address indexed owner, address indexed spender, uint256 value)"
+]);
+var SlvrAutoCommitEvents = parseAbi([
+  "event PlanConfigured(address indexed user, uint256 nextRoundId, uint32 plays, uint256 amountPerPlay, bool autoClaim)",
+  "event PlanDisabled(address indexed user)",
+  "event PlanCancelled(address indexed user, uint256 refundAmount)",
+  "event Deposited(address indexed user, uint256 amount)",
+  "event Withdrawn(address indexed user, uint256 amount, address to)",
+  "event RoundExecuted(address indexed user, uint256 indexed roundId, uint32 playsRemaining)",
+  "event Claimed(address indexed user, uint256 indexed roundId, uint256 nativeAmount, uint256 addedToBalance)",
+  "event BalanceUpdated(address indexed user, uint256 newBalance, uint256 amountAdded)",
+  "event ExecutorFeePaid(address indexed user, address indexed executor, uint256 fee, uint256 gasUsed)"
+]);
+function decodeEvent(abi, log) {
+  try {
+    const decoded = decodeEventLog({
+      abi,
+      data: log.data,
+      topics: log.topics
+    });
+    return decoded;
+  } catch {
+    return null;
+  }
+}
+function decodeEvents(abi, logs, eventName) {
+  const decoded = [];
+  for (const log of logs) {
+    try {
+      const decodedEvent = decodeEvent(abi, log);
+      if (decodedEvent) {
+        if (!eventName || decodedEvent.eventName === eventName) {
+          decoded.push(decodedEvent);
+        }
+      }
+    } catch {
+    }
+  }
+  return decoded;
+}
+
+// src/contracts/lottery.ts
+var _SlvrGridLottery = class _SlvrGridLottery {
+  constructor(publicClient, walletClient, address) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.address = address;
+  }
+  /**
+   * Update the wallet client
+   * @param walletClient New wallet client
+   */
+  setWalletClient(walletClient) {
+    this.walletClient = walletClient;
+  }
+  /**
+   * Get the current round ID
+   */
+  async currentRoundId() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "currentRoundId"
+    });
+  }
+  /**
+   * Get round start time
+   */
+  async roundStart(roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "roundStart",
+      args: [roundId]
+    });
+  }
+  /**
+   * Get round end time
+   */
+  async roundEnd(roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "roundEnd",
+      args: [roundId]
+    });
+  }
+  /**
+   * Check if round is open for betting
+   */
+  async roundOpen(roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "roundOpen",
+      args: [roundId]
+    });
+  }
+  /**
+   * Get the betting cutoff timestamp (unix seconds) for a round.
+   *
+   * Bets are only accepted until this time, which can be earlier than
+   * {@link roundEnd}. Bots deciding whether they can still bet should gate on
+   * this rather than on `roundEnd`.
+   */
+  async bettingEnd(roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "bettingEnd",
+      args: [roundId]
+    });
+  }
+  /**
+   * Estimate the reward an account would receive for a round, in wei.
+   *
+   * Thin pass-through to the contract's `getExpectedReward`. Useful for sizing
+   * bets or deciding whether a claim is worth the gas.
+   */
+  async getExpectedReward(account, roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getExpectedReward",
+      args: [account, roundId]
+    });
+  }
+  /**
+   * Get the latest resolved round ID (type(uint256).max sentinel when none resolved yet)
+   */
+  async latestResolvedRoundId() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "latestResolvedRoundId"
+    });
+  }
+  /**
+   * Get full round information
+   */
+  async getRound(roundId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getRound",
+      args: [roundId]
+    });
+    return {
+      roundId,
+      requestedAt: result[0],
+      resolved: result[1],
+      randomnessId: result[2],
+      randomnessValue: result[3],
+      winningSquare: Number(result[4]),
+      jackpotHit: result[5],
+      singleMinerRound: result[6],
+      singleMinerWinner: result[7],
+      totalWager: result[8],
+      fee: result[9],
+      winnerTotal: result[10],
+      potForWinners: result[11],
+      slvrForWinners: result[12],
+      payoutMulWad: result[13],
+      slvrMulWad: result[14],
+      totalUnclaimedSlvr: result[15]
+    };
+  }
+  /**
+   * Get a compact, batched snapshot of a round's live state — the fields a bot
+   * checks every tick — in one shot. Defaults to the current round.
+   *
+   * `secondsUntilBettingClose` is computed from the chain's `block.timestamp`
+   * (not the local clock), so it's accurate even if your device clock drifts.
+   * With a multicall-batching client the reads collapse into ~2 RPC calls.
+   */
+  async getRoundState(roundId) {
+    const id = roundId ?? await this.currentRoundId();
+    const [round, open, bettingEnd, roundEnd, block] = await Promise.all([
+      this.getRound(id),
+      this.roundOpen(id),
+      this.bettingEnd(id),
+      this.roundEnd(id),
+      this.publicClient.getBlock()
+    ]);
+    const secondsLeft = Number(bettingEnd - block.timestamp);
+    return {
+      roundId: id,
+      open,
+      resolved: round.resolved,
+      bettingEnd,
+      roundEnd,
+      totalWager: round.totalWager,
+      winningSquare: round.winningSquare,
+      secondsUntilBettingClose: secondsLeft > 0 ? secondsLeft : 0
+    };
+  }
+  /**
+   * Get the jackpot contract address for a round (zero address if no jackpot is
+   * set). Read that contract's `jackpotPool()` for the pool balance — or use the
+   * SDK helper `getJackpotPool(roundId)`.
+   */
+  async getRoundJackpot(roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getRoundJackpot",
+      args: [roundId]
+    });
+  }
+  /**
+   * Get total amount bet on a square for a round
+   */
+  async getTotalOnSquare(roundId, square) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getTotalOnSquare",
+      args: [roundId, square]
+    });
+  }
+  /**
+   * Get number of bettors on a square for a round
+   */
+  async getBettorsOnSquare(roundId, square) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getBettorsOnSquare",
+      args: [roundId, square]
+    });
+  }
+  /**
+   * Get a user's bet amount on a square for a round
+   */
+  async getUserBet(roundId, square, bettor) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getUserBet",
+      args: [roundId, square, bettor]
+    });
+  }
+  /**
+   * Check if a user has claimed rewards for a round
+   */
+  async getHasClaimed(roundId, user) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getHasClaimed",
+      args: [roundId, user]
+    });
+  }
+  /**
+   * Get miner state for an account
+   */
+  async getMinerState(account) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getMinerState",
+      args: [account]
+    });
+    return {
+      rewardsSlvr: result[0],
+      refinedAccrued: result[1],
+      indexSnapshot: result[2],
+      hasAccount: result[3]
+    };
+  }
+  /**
+   * Check if an account exists
+   */
+  async hasAccount(account) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getHasAccount",
+      args: [account]
+    });
+  }
+  /**
+   * Get carry-over winner native pool (when no winners)
+   */
+  async carryWinnerNativePool() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "carryWinnerNativePool"
+    });
+  }
+  /**
+   * Get staker rewards that failed to distribute (owed)
+   */
+  async carryStakerNativeOwed() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "carryStakerNativeOwed"
+    });
+  }
+  /**
+   * Get jackpot funds that failed to add (owed)
+   */
+  async carryJackpotNativeOwed() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "carryJackpotNativeOwed"
+    });
+  }
+  /**
+   * Get carry-over SLVR pool
+   */
+  async carrySlvrPool() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "carrySlvrPool"
+    });
+  }
+  /**
+   * Get the configured SLVR-per-round value.
+   *
+   * NOTE: This is no longer the authoritative emission number. Emission is hub-gated: the amount
+   * actually minted each round is bounded by the game's streamed emission budget on SlvrHub
+   * (see SlvrHub.pendingEmission / mintReward). Treat this only as the requested/target value.
+   */
+  async slvrPerRound() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "slvrPerRound"
+    });
+  }
+  /**
+   * Get protocol fee in basis points
+   */
+  async protocolFeeBps() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "protocolFeeBps"
+    });
+  }
+  /**
+   * Get grid size (should be 25)
+   */
+  async grid() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "GRID"
+    });
+  }
+  /**
+   * Get account deposit amount
+   */
+  async accountDeposit() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "ACCOUNT_DEPOSIT"
+    });
+  }
+  /**
+   * Place a bet on the current round
+   * Note: The contract will automatically handle account deposit for new accounts.
+   * If the beneficiary is a new account, ensure msg.value >= ACCOUNT_DEPOSIT + total bet amount.
+   * @param params Bet parameters
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async bet(params) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("betting");
+    }
+    const { roundId, squares, amounts, beneficiary, overrides } = params;
+    if (roundId < 0n) {
+      throw new ContractCallError("Round ID must be non-negative");
+    }
+    validateSquares(squares);
+    validateArrayLengths([squares, amounts], ["squares", "amounts"]);
+    for (const amount of amounts) {
+      validateAmount(amount, "bet amount");
+    }
+    const totalAmount = amounts.reduce((sum, amt) => sum + amt, 0n);
+    try {
+      const beneficiaryAddress = beneficiary ? validateAddress(beneficiary, "beneficiary") : this.walletClient.account.address;
+      const hasAccount_ = await this.hasAccount(beneficiaryAddress);
+      const accountDeposit_ = hasAccount_ ? 0n : await this.accountDeposit();
+      const totalValue = totalAmount + accountDeposit_;
+      const req = beneficiary ? { functionName: "betFor", args: [roundId, beneficiaryAddress, squares, amounts] } : { functionName: "bet", args: [roundId, squares, amounts] };
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrGridLottery.ABI,
+        functionName: req.functionName,
+        args: req.args,
+        value: totalValue,
+        account: this.walletClient.account,
+        chain: null,
+        ...overrides ?? {}
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      const revert = decodeSlvrRevert(error);
+      if (revert) throw revert;
+      throw new ContractCallError(`Failed to place bet: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Preflight a bet with `eth_call` (no transaction sent). Resolves if the bet
+   * would succeed; otherwise throws a {@link SlvrRevertError} with the decoded
+   * custom error (e.g. `RoundNotOpen`, `InsufficientValue`). Catch reverts before
+   * spending gas.
+   */
+  async simulateBet(params) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("simulating a bet");
+    }
+    const { roundId, squares, amounts, beneficiary } = params;
+    validateSquares(squares);
+    validateArrayLengths([squares, amounts], ["squares", "amounts"]);
+    const totalAmount = amounts.reduce((sum, amt) => sum + amt, 0n);
+    const beneficiaryAddress = beneficiary ? validateAddress(beneficiary, "beneficiary") : this.walletClient.account.address;
+    const hasAccount_ = await this.hasAccount(beneficiaryAddress);
+    const value = totalAmount + (hasAccount_ ? 0n : await this.accountDeposit());
+    const req = beneficiary ? { functionName: "betFor", args: [roundId, beneficiaryAddress, squares, amounts] } : { functionName: "bet", args: [roundId, squares, amounts] };
+    try {
+      await this.publicClient.simulateContract({
+        address: this.address,
+        abi: _SlvrGridLottery.ABI,
+        functionName: req.functionName,
+        args: req.args,
+        value,
+        account: this.walletClient.account
+      });
+    } catch (error) {
+      throw decodeSlvrRevert(error) ?? error;
+    }
+  }
+  /**
+   * Claim rewards for a round
+   * @param params Claim parameters
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async claim(params) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("claiming");
+    }
+    if (params.roundId < 0n) {
+      throw new ContractCallError("Round ID must be non-negative");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrGridLottery.ABI,
+        functionName: "claim",
+        args: [params.roundId],
+        account: this.walletClient.account,
+        chain: null,
+        ...params.overrides ?? {}
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      const revert = decodeSlvrRevert(error);
+      if (revert) throw revert;
+      throw new ContractCallError(`Failed to claim rewards: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Advanced claim function covering all claim variants
+   * Handles: user vs delegate, native/SLVR recipients, bypassFee, ethOnly
+   * @param params Advanced claim parameters
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async claimAdvanced(params) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("claiming");
+    }
+    if (params.roundId < 0n) {
+      throw new ContractCallError("Round ID must be non-negative");
+    }
+    const user = validateAddress(params.user, "user");
+    const recipientNative = params.recipientNative ? validateAddress(params.recipientNative, "recipientNative") : "0x0000000000000000000000000000000000000000";
+    const recipientSlvr = params.recipientSlvr ? validateAddress(params.recipientSlvr, "recipientSlvr") : "0x0000000000000000000000000000000000000000";
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrGridLottery.ABI,
+        functionName: "claimAdvanced",
+        args: [{
+          user,
+          roundId: params.roundId,
+          recipientNative,
+          recipientSlvr,
+          bypassFee: params.bypassFee || false,
+          ethOnly: params.ethOnly || false
+        }],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to claim rewards: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Batch claim rewards for multiple rounds
+   * Note: This sends multiple transactions sequentially. For better UX, consider
+   * using a multicall contract or batching in your application layer.
+   * @param roundIds Array of round IDs to claim
+   * @param user User address to claim for (defaults to wallet client account)
+   * @param options Optional configuration
+   * @param options.waitForReceipt Whether to wait for each transaction receipt (default: false)
+   * @returns Array of transaction hashes
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async batchClaim(roundIds, user, options) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("batch claiming");
+    }
+    if (roundIds.length === 0) {
+      throw new ContractCallError("No rounds to claim");
+    }
+    const claimUser = user ? validateAddress(user, "user") : this.walletClient.account.address;
+    const hashes = [];
+    for (const roundId of roundIds) {
+      if (roundId < 0n) {
+        throw new ContractCallError(`Invalid round ID: ${roundId}`);
+      }
+      try {
+        const hash = await this.claimAdvanced({
+          user: claimUser,
+          roundId
+        });
+        hashes.push(hash);
+        if (options?.waitForReceipt) {
+          await waitForTransactionReceipt(this.publicClient, hash);
+        }
+      } catch (error) {
+        throw new ContractCallError(
+          `Failed to claim round ${roundId}: ${error instanceof Error ? error.message : String(error)}`,
+          error
+        );
+      }
+    }
+    return hashes;
+  }
+  /**
+   * Approve a delegate to claim rewards on your behalf
+   */
+  async approveDelegate(delegate) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("approving delegate");
+    }
+    const delegateAddress = validateAddress(delegate, "delegate");
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "approveDelegate",
+      args: [delegateAddress],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Revoke a delegate's approval to claim on your behalf
+   */
+  async revokeDelegate(delegate) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("revoking delegate");
+    }
+    const delegateAddress = validateAddress(delegate, "delegate");
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "revokeDelegate",
+      args: [delegateAddress],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Check if a delegate is approved for a user
+   */
+  async getDelegate(user, delegate) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "getDelegate",
+      args: [user, delegate]
+    });
+  }
+  /**
+   * Donate SLVR tokens directly to the jackpot pool.
+   * Note: caller must have approved the lottery to spend `amount` of SLVR beforehand.
+   */
+  async donateSlvrToJackpot(amount) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("donating to jackpot");
+    }
+    validateAmount(amount, "donation amount");
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "donateSlvrToJackpot",
+      args: [amount],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Add ETH (native) tokens to the jackpot pool
+   * @param value Amount of native ETH to deposit
+   */
+  async addEthToJackpot(value) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("adding ETH to jackpot");
+    }
+    validateAmount(value, "jackpot amount");
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "addEthToJackpot",
+      value,
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Withdraw your accumulated mined SLVR (the "refine and cash out" path).
+   *
+   * Settles your miner accrual (auto-checkpoints) and transfers your SLVR out,
+   * net of the refining fee. This is the function a mining bot wants to realize
+   * SLVR rewards outside of a specific round claim. Reverts if you have nothing to
+   * withdraw. The exact `(totalPayout, refiningFee)` are in the emitted `Claimed`
+   * event; this returns the transaction hash.
+   */
+  async withdrawUnrefinedSlvr() {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("withdrawing unrefined SLVR");
+    }
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "withdrawUnrefinedSlvr",
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Force on-chain settlement of a miner's refined-reward accrual (lazy
+   * "checkpoint"). Permissionless — you can checkpoint any account.
+   *
+   * This only updates accounting (rolls index growth into `refinedAccrued`); it
+   * moves no tokens. You rarely need it: `claim` and {@link withdrawUnrefinedSlvr}
+   * both checkpoint internally, and the up-to-date figure can be derived off-chain
+   * from {@link getMinerState}. Use it when you want state settled without a
+   * claim/withdraw — e.g. to make a subsequent `getMinerState` read exact.
+   */
+  async checkpoint(account) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("checkpointing");
+    }
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrGridLottery.ABI,
+      functionName: "checkpoint",
+      args: [account],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Get all square data for a round
+   */
+  async getRoundSquares(roundId) {
+    const gridSize = await this.grid();
+    const squares = Array.from({ length: gridSize }, (_, i) => i);
+    try {
+      const contracts = squares.flatMap((sq) => [
+        { address: this.address, abi: _SlvrGridLottery.ABI, functionName: "getTotalOnSquare", args: [roundId, sq] },
+        { address: this.address, abi: _SlvrGridLottery.ABI, functionName: "getBettorsOnSquare", args: [roundId, sq] }
+      ]);
+      const res = await this.publicClient.multicall({
+        contracts,
+        allowFailure: false
+      });
+      return squares.map((square, i) => ({ square, total: res[i * 2], bettors: res[i * 2 + 1] }));
+    } catch {
+      const [totals, bettors] = await Promise.all([
+        Promise.all(squares.map((sq) => this.getTotalOnSquare(roundId, sq))),
+        Promise.all(squares.map((sq) => this.getBettorsOnSquare(roundId, sq)))
+      ]);
+      return squares.map((square, i) => ({ square, total: totals[i], bettors: bettors[i] }));
+    }
+  }
+  /**
+   * Get user's bets for a round
+   */
+  async getUserBets(roundId, user) {
+    const gridSize = await this.grid();
+    const squares = Array.from({ length: gridSize }, (_, i) => i);
+    let bets;
+    try {
+      const contracts = squares.map((sq) => ({
+        address: this.address,
+        abi: _SlvrGridLottery.ABI,
+        functionName: "getUserBet",
+        args: [roundId, sq, user]
+      }));
+      bets = await this.publicClient.multicall({ contracts, allowFailure: false });
+    } catch {
+      bets = await Promise.all(squares.map((sq) => this.getUserBet(roundId, sq, user)));
+    }
+    return squares.map((square, i) => ({ square, amount: bets[i] })).filter((bet) => bet.amount > 0n);
+  }
+  // ---------------------------------------------------------------------------
+  // Reactive helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Wait until a round is resolved, resolving with its final {@link RoundInfo}.
+   * Polls `getRound` on an interval — handy for "bet, then claim once it settles".
+   *
+   * @param opts.pollIntervalMs how often to check (default 4000)
+   * @param opts.timeoutMs give up after this long (default: wait indefinitely)
+   * @throws {Error} if `timeoutMs` elapses before resolution
+   */
+  async waitForResolution(roundId, opts = {}) {
+    const interval = opts.pollIntervalMs ?? 4e3;
+    const deadline = opts.timeoutMs !== void 0 ? Date.now() + opts.timeoutMs : Infinity;
+    for (; ; ) {
+      const round = await this.getRound(roundId);
+      if (round.resolved) return round;
+      if (Date.now() >= deadline) throw new Error(`round ${roundId} not resolved within ${opts.timeoutMs}ms`);
+      await new Promise((r) => setTimeout(r, interval));
+    }
+  }
+  /**
+   * Subscribe to `RoundResolved` events. Returns an unsubscribe function.
+   *
+   * @example
+   * ```typescript
+   * const stop = sdk.lottery.watchRoundResolved((e) => {
+   *   console.log(`round ${e.roundId} won by square ${e.winningSquare}`);
+   * });
+   * // later: stop();
+   * ```
+   */
+  watchRoundResolved(onResolved, opts = {}) {
+    return this.publicClient.watchContractEvent({
+      address: this.address,
+      abi: SlvrGridLotteryEvents,
+      eventName: "RoundResolved",
+      onLogs: (logs) => {
+        for (const log of logs) onResolved(log.args);
+      },
+      onError: opts.onError,
+      poll: true
+    });
+  }
+  /**
+   * Subscribe to `BetPlaced` events (optionally for one round). Returns an
+   * unsubscribe function. Useful for reacting to pot changes in real time.
+   */
+  watchBets(onBet, opts = {}) {
+    return this.publicClient.watchContractEvent({
+      address: this.address,
+      abi: SlvrGridLotteryEvents,
+      eventName: "BetPlaced",
+      args: opts.roundId !== void 0 ? { roundId: opts.roundId } : void 0,
+      onLogs: (logs) => {
+        for (const log of logs) onBet(log.args);
+      },
+      onError: opts.onError,
+      poll: true
+    });
+  }
+};
+// ABI for SlvrGridLottery contract
+_SlvrGridLottery.ABI = parseAbi2([
+  // View functions
+  "function currentRoundId() view returns (uint256)",
+  "function roundStart(uint256 roundId) view returns (uint256)",
+  "function roundEnd(uint256 roundId) view returns (uint256)",
+  "function roundOpen(uint256 roundId) view returns (bool)",
+  // Betting cutoff for a round. This is the timestamp bets stop being accepted,
+  // which can be earlier than roundEnd() — gate bots on this, not roundEnd.
+  "function bettingEnd(uint256 roundId) view returns (uint256)",
+  "function getExpectedReward(address account, uint256 roundId) view returns (uint256)",
+  "function latestResolvedRoundId() view returns (uint256)",
+  // getRound returns a flat 16-value tuple (no wrapping struct)
+  "function getRound(uint256 roundId) view returns (uint64 requestedAt, bool resolved, bytes32 randomnessId, uint256 randomnessValue, uint8 winningSquare, bool jackpotHit, bool singleMinerRound, address singleMinerWinner, uint256 totalWager, uint256 fee, uint256 winnerTotal, uint256 potForWinners, uint256 slvrForWinners, uint256 payoutMulWad, uint256 slvrMulWad, uint256 totalUnclaimedSlvr)",
+  "function getTotalOnSquare(uint256 roundId, uint8 square) view returns (uint256)",
+  "function getBettorsOnSquare(uint256 roundId, uint8 square) view returns (uint256)",
+  "function getUserBet(uint256 roundId, uint8 square, address bettor) view returns (uint256)",
+  "function getHasClaimed(uint256 roundId, address user) view returns (bool)",
+  "function getMinerState(address account) view returns (uint256 rewardsSlvr, uint256 refinedAccrued, uint256 indexSnapshot, bool hasAccount)",
+  "function getHasAccount(address account) view returns (bool)",
+  "function getDelegate(address user, address delegate) view returns (bool)",
+  "function carryWinnerNativePool() view returns (uint256)",
+  "function carryStakerNativeOwed() view returns (uint256)",
+  "function carryJackpotNativeOwed() view returns (uint256)",
+  "function carrySlvrPool() view returns (uint256)",
+  // NOTE: slvrPerRound() still exists as a public var but is NO LONGER the authoritative
+  // emission number. Emission is hub-gated (see SlvrHub.pendingEmission / mintReward), so the
+  // amount actually minted per round is bounded by the game's streamed emission budget.
+  "function slvrPerRound() view returns (uint256)",
+  "function protocolFeeBps() view returns (uint16)",
+  "function GRID() view returns (uint8)",
+  "function ACCOUNT_DEPOSIT() view returns (uint256)",
+  // Write functions
+  "function bet(uint256 roundId, uint8[] squares, uint256[] amounts) payable",
+  "function betFor(uint256 roundId, address beneficiary, uint8[] squares, uint256[] amounts) payable",
+  "function claim(uint256 roundId)",
+  "function claimAdvanced((address user, uint256 roundId, address recipientNative, address recipientSlvr, bool bypassFee, bool ethOnly) params)",
+  "function approveDelegate(address delegate)",
+  "function revokeDelegate(address delegate)",
+  "function donateSlvrToJackpot(uint256 amount)",
+  "function addEthToJackpot() payable",
+  "function checkpoint(address account)",
+  "function withdrawUnrefinedSlvr() returns (uint256 totalPayout, uint256 refiningFee)",
+  "function getRoundJackpot(uint256 roundId) view returns (address)",
+  // Custom errors — so viem can decode reverts (see decodeSlvrRevert / simulateBet)
+  "error InsufficientValue()",
+  "error RoundNotOpen()",
+  "error NotResolved()",
+  "error ResolveRequested()",
+  "error BadClaim()",
+  "error NoAccount()",
+  "error BadAmount()",
+  "error BadSquare()",
+  "error DupSquare()",
+  "error BadArrays()",
+  "error ValueNotSum()",
+  "error MustSumTo100Percent()",
+  "error NotAuthorized()",
+  "error NotCurrentRound()",
+  "error CannotDelegateToSelf()",
+  "error RandomnessNotSettled()",
+  "error TransferFailed()",
+  "error JackpotNotSet()"
+]);
+var SlvrGridLottery = _SlvrGridLottery;
+
+// src/contracts/staking.ts
+import { parseAbi as parseAbi3 } from "viem";
+var _SlvrStaking = class _SlvrStaking {
+  constructor(publicClient, walletClient, address) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.address = address;
+  }
+  /**
+   * Update the wallet client
+   * @param walletClient New wallet client
+   */
+  setWalletClient(walletClient) {
+    this.walletClient = walletClient;
+  }
+  // ---------------------------------------------------------------------------
+  // Views
+  // ---------------------------------------------------------------------------
+  /**
+   * Get claimable rewards for a staked veNFT tokenId
+   */
+  async getStakerRewards(tokenId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "getStakerRewards",
+      args: [tokenId]
+    });
+  }
+  /**
+   * Get the total tracked weight across all staked tokens
+   */
+  async getTotalWeight() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "getTotalWeight"
+    });
+  }
+  /**
+   * Get the accumulated reward per unit of weight (1e18 precision)
+   */
+  async rewardPerWeightStored() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "rewardPerWeightStored"
+    });
+  }
+  /**
+   * Get the last rewardPerWeightStored snapshot recorded for a tokenId
+   */
+  async rewardPerWeightPaid(tokenId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "rewardPerWeightPaid",
+      args: [tokenId]
+    });
+  }
+  /**
+   * Get the tracked weight (balance) for a staked tokenId
+   */
+  async balance(tokenId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "balance",
+      args: [tokenId]
+    });
+  }
+  /**
+   * Get the accrued (checkpointed) claimable rewards stored for a tokenId
+   */
+  async rewards(tokenId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "rewards",
+      args: [tokenId]
+    });
+  }
+  /**
+   * Get the total tracked weight (public storage var)
+   */
+  async totalWeight() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "totalWeight"
+    });
+  }
+  /**
+   * Get unallocated rewards (distributed while no weight was staked)
+   */
+  async unallocated() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "unallocated"
+    });
+  }
+  /**
+   * Get the last distributed round ID (type(uint256).max sentinel when none)
+   */
+  async lastDistributedRoundId() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "lastDistributedRoundId"
+    });
+  }
+  /**
+   * Get the lottery address authorized to distribute rewards
+   */
+  async lottery() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "LOTTERY"
+    });
+  }
+  /**
+   * Get complete staking info for a staked veNFT tokenId
+   */
+  async getStakingInfo(tokenId) {
+    const [totalWeight_, balance_, rewards_, rewardPerWeightStored_] = await Promise.all([
+      this.totalWeight(),
+      this.balance(tokenId),
+      this.getStakerRewards(tokenId),
+      this.rewardPerWeightStored()
+    ]);
+    return {
+      totalWeight: totalWeight_,
+      balance: balance_,
+      rewards: rewards_,
+      rewardPerWeightStored: rewardPerWeightStored_
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Writes
+  // ---------------------------------------------------------------------------
+  /**
+   * Stake a vote-escrow NFT by tokenId
+   * @param tokenId The veNFT token ID to stake
+   * @returns Transaction hash
+   */
+  async stake(tokenId) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("staking");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrStaking.ABI,
+        functionName: "stake",
+        args: [tokenId],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to stake: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Unstake a vote-escrow NFT by tokenId
+   * @param tokenId The veNFT token ID to unstake
+   * @returns Transaction hash
+   */
+  async unstake(tokenId) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("unstaking");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrStaking.ABI,
+        functionName: "unstake",
+        args: [tokenId],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to unstake: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Claim staker rewards for a tokenId
+   * @param tokenId The veNFT token ID to claim rewards for
+   * @returns Transaction hash
+   */
+  async claimStakerRewards(tokenId) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("claiming rewards");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrStaking.ABI,
+        functionName: "claimStakerRewards",
+        args: [tokenId],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to claim rewards: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Checkpoint a token's reward accounting
+   * @param tokenId The veNFT token ID to checkpoint
+   * @returns Transaction hash
+   */
+  async checkpoint(tokenId) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("checkpointing");
+    }
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "checkpoint",
+      args: [tokenId],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Poke a token to refresh its tracked weight
+   * @param tokenId The veNFT token ID to poke
+   * @returns Transaction hash
+   */
+  async poke(tokenId) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("poking");
+    }
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "poke",
+      args: [tokenId],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+  /**
+   * Poke many tokens to refresh their tracked weight in one call
+   * @param tokenIds The veNFT token IDs to poke
+   * @returns Transaction hash
+   */
+  async pokeMany(tokenIds) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("poking");
+    }
+    return await this.walletClient.writeContract({
+      address: this.address,
+      abi: _SlvrStaking.ABI,
+      functionName: "pokeMany",
+      args: [tokenIds],
+      account: this.walletClient.account,
+      chain: null
+    });
+  }
+};
+_SlvrStaking.ABI = parseAbi3([
+  // View functions
+  "function getStakerRewards(uint256 tokenId) view returns (uint256)",
+  "function getTotalWeight() view returns (uint256)",
+  "function rewardPerWeightStored() view returns (uint256)",
+  "function rewardPerWeightPaid(uint256 tokenId) view returns (uint256)",
+  "function balance(uint256 tokenId) view returns (uint256)",
+  "function rewards(uint256 tokenId) view returns (uint256)",
+  "function totalWeight() view returns (uint256)",
+  "function unallocated() view returns (uint256)",
+  "function lastDistributedRoundId() view returns (uint256)",
+  "function LOTTERY() view returns (address)",
+  // Write functions
+  "function stake(uint256 tokenId)",
+  "function unstake(uint256 tokenId)",
+  "function claimStakerRewards(uint256 tokenId)",
+  "function checkpoint(uint256 tokenId)",
+  "function poke(uint256 tokenId)",
+  "function pokeMany(uint256[] tokenIds)"
+]);
+var SlvrStaking = _SlvrStaking;
+
+// src/contracts/token.ts
+import { parseAbi as parseAbi4 } from "viem";
+var _SlvrToken = class _SlvrToken {
+  constructor(publicClient, walletClient, address) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.address = address;
+  }
+  /**
+   * Update the wallet client
+   * @param walletClient New wallet client
+   */
+  setWalletClient(walletClient) {
+    this.walletClient = walletClient;
+  }
+  /**
+   * Get total supply
+   */
+  async totalSupply() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "totalSupply"
+    });
+  }
+  /**
+   * Get balance of an account
+   */
+  async balanceOf(account) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "balanceOf",
+      args: [account]
+    });
+  }
+  /**
+   * Get allowance
+   */
+  async allowance(owner, spender) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "allowance",
+      args: [owner, spender]
+    });
+  }
+  /**
+   * Get token name
+   */
+  async name() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "name"
+    });
+  }
+  /**
+   * Get token symbol
+   */
+  async symbol() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "symbol"
+    });
+  }
+  /**
+   * Get token decimals
+   */
+  async decimals() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "decimals"
+    });
+  }
+  /**
+   * Get maximum supply
+   */
+  async maxSupply() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrToken.ABI,
+      functionName: "MAX_SUPPLY"
+    });
+  }
+  /**
+   * Transfer tokens
+   * @param to Recipient address
+   * @param amount Amount to transfer
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async transfer(to, amount) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("transferring");
+    }
+    const recipient = validateAddress(to, "recipient");
+    validateAmount(amount, "transfer amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrToken.ABI,
+        functionName: "transfer",
+        args: [recipient, amount],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to transfer: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Approve spender
+   * @param spender Address to approve
+   * @param amount Amount to approve
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async approve(spender, amount) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("approving");
+    }
+    const spenderAddress = validateAddress(spender, "spender");
+    validateAmount(amount, "approval amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrToken.ABI,
+        functionName: "approve",
+        args: [spenderAddress, amount],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to approve: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Transfer from (requires approval)
+   * @param from Sender address
+   * @param to Recipient address
+   * @param amount Amount to transfer
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async transferFrom(from, to, amount) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("transferFrom");
+    }
+    const fromAddress = validateAddress(from, "from");
+    const toAddress = validateAddress(to, "to");
+    validateAmount(amount, "transfer amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrToken.ABI,
+        functionName: "transferFrom",
+        args: [fromAddress, toAddress, amount],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to transferFrom: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Burn tokens
+   * @param amount Amount to burn
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if amount is invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async burn(amount) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("burning");
+    }
+    validateAmount(amount, "burn amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrToken.ABI,
+        functionName: "burn",
+        args: [amount],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to burn: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Burn tokens from account
+   * @param account Account to burn from
+   * @param amount Amount to burn
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async burnFrom(account, amount) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("burnFrom");
+    }
+    const accountAddress = validateAddress(account, "account");
+    validateAmount(amount, "burn amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrToken.ABI,
+        functionName: "burnFrom",
+        args: [accountAddress, amount],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to burnFrom: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+};
+_SlvrToken.ABI = parseAbi4([
+  // ERC20 standard functions
+  "function totalSupply() view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+  // SlvrToken specific
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function MAX_SUPPLY() view returns (uint256)",
+  "function burn(uint256 amount)",
+  "function burnFrom(address account, uint256 amount)"
+]);
+var SlvrToken = _SlvrToken;
+
+// src/contracts/autoCommit.ts
+import { parseAbi as parseAbi5 } from "viem";
+var _SlvrAutoCommit = class _SlvrAutoCommit {
+  constructor(publicClient, walletClient, address) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.address = address;
+  }
+  /**
+   * Update the wallet client
+   * @param walletClient New wallet client
+   */
+  setWalletClient(walletClient) {
+    this.walletClient = walletClient;
+  }
+  /**
+   * Get plan information for a user
+   */
+  async planInfo(user) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "planInfo",
+      args: [user]
+    });
+    return {
+      enabled: result[0],
+      nextRoundId: result[1],
+      playsRemaining: Number(result[2]),
+      amountPerPlay: result[3],
+      balance: result[4],
+      autoClaim: result[5],
+      squares: result[6].map((s) => Number(s)),
+      bpsAlloc: result[7].map((b) => Number(b)),
+      planStartRoundId: result[8]
+    };
+  }
+  /**
+   * Check whether a plan is ready to execute, and if not, why
+   */
+  async needsExecution(user) {
+    const [ready, reason] = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "needsExecution",
+      args: [user]
+    });
+    return { ready, reason };
+  }
+  /**
+   * Check whether a specific round has already been executed for a user
+   */
+  async executedRound(user, roundId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "executedRounds",
+      args: [user, roundId]
+    });
+  }
+  /**
+   * Get lottery contract address
+   */
+  async lottery() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "LOTTERY"
+    });
+  }
+  /**
+   * Get the sentinel plays value meaning "unlimited plays"
+   */
+  async unlimitedPlays() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "UNLIMITED_PLAYS"
+    });
+  }
+  /**
+   * Get max plays per execution
+   */
+  async maxPlaysPerExecution() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "MAX_PLAYS_PER_EXECUTION"
+    });
+  }
+  /**
+   * Get max claim rounds accepted per execution
+   */
+  async maxClaimsPerExecution() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "MAX_CLAIMS_PER_EXECUTION"
+    });
+  }
+  /**
+   * Get the current cap on the executor fee reimbursed per execution
+   * (owner-tunable within the contract's hard ceiling)
+   */
+  async maxFeePerExecution() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "maxFeePerExecution"
+    });
+  }
+  /**
+   * Get the current executor-fee premium in basis points
+   * (owner-tunable within the contract's hard ceiling)
+   */
+  async feePremiumBps() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrAutoCommit.ABI,
+      functionName: "feePremiumBps"
+    });
+  }
+  /**
+   * Deposit native tokens to auto-commit plan
+   * @param value Amount to deposit
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if amount is invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async deposit(value) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("depositing");
+    }
+    validateAmount(value, "deposit amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "deposit",
+        value,
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to deposit: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Withdraw from auto-commit plan
+   * @param amount Amount to withdraw
+   * @param to Recipient address
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async withdraw(amount, to) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("withdrawing");
+    }
+    validateAmount(amount, "withdraw amount");
+    const recipient = validateAddress(to, "recipient");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "withdraw",
+        args: [amount, recipient],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to withdraw: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Configure auto-commit plan
+   * @param plays Number of plays (UNLIMITED_PLAYS = 4294967295 for unlimited;
+   *              forced to unlimited on-chain when autoClaim is true)
+   * @param amountPerPlay Amount per play
+   * @param squares Square indices to bet on
+   * @param bpsAlloc Basis points allocation for each square (must sum to 10000)
+   * @param autoClaim Whether the keeper should claim winnings back into the plan balance
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async configurePlan(plays, amountPerPlay, squares, bpsAlloc, autoClaim) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("configuring plan");
+    }
+    this.validatePlanConfig(plays, amountPerPlay, squares, bpsAlloc);
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "configurePlan",
+        args: [plays, amountPerPlay, squares, bpsAlloc, autoClaim],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to configure plan: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Configure auto-commit plan and deposit funds in a single transaction
+   * @param plays Number of plays (see configurePlan)
+   * @param amountPerPlay Amount per play
+   * @param squares Square indices to bet on
+   * @param bpsAlloc Basis points allocation for each square (must sum to 10000)
+   * @param autoClaim Whether the keeper should claim winnings back into the plan balance
+   * @param value Amount to deposit
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async configurePlanAndDeposit(plays, amountPerPlay, squares, bpsAlloc, autoClaim, value) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("configuring plan");
+    }
+    this.validatePlanConfig(plays, amountPerPlay, squares, bpsAlloc);
+    validateAmount(value, "deposit amount");
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "configurePlanAndDeposit",
+        args: [plays, amountPerPlay, squares, bpsAlloc, autoClaim],
+        value,
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to configure plan: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Disable auto-commit plan
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ContractCallError if contract call fails
+   */
+  async disablePlan() {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("disabling plan");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "disablePlan",
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to disable plan: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Cancel the plan and refund the entire remaining balance to the caller
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ContractCallError if contract call fails
+   */
+  async cancelPlan() {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("cancelling plan");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "cancelPlan",
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to cancel plan: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Execute auto-commit plan for a user (anyone can call).
+   * The caller is reimbursed metered gas + premium from the user's plan balance.
+   * @param user User address
+   * @param maxPlays Maximum number of plays to execute
+   * @param claimRounds Winning round ids to claim into the plan balance before
+   *        betting (discovered off-chain; non-claimable entries are no-ops)
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async executeFor(user, maxPlays, claimRounds = []) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("executing plan");
+    }
+    const userAddress = validateAddress(user, "user");
+    if (!Number.isInteger(maxPlays) || maxPlays <= 0) {
+      throw new ContractCallError("maxPlays must be a positive integer");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "executeFor",
+        args: [userAddress, maxPlays, claimRounds],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to execute plan: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  /**
+   * Claim winning rounds into a user's plan balance without betting (anyone can
+   * call). Useful when the plan balance is too low to bet until winnings land.
+   * @param user User address
+   * @param claimRounds Winning round ids to claim (discovered off-chain)
+   * @returns Transaction hash
+   * @throws WalletClientRequiredError if wallet client is not available
+   * @throws ValidationError if inputs are invalid
+   * @throws ContractCallError if contract call fails
+   */
+  async claimFor(user, claimRounds) {
+    if (!this.walletClient) {
+      throw new WalletClientRequiredError("claiming");
+    }
+    const userAddress = validateAddress(user, "user");
+    if (claimRounds.length === 0) {
+      throw new ContractCallError("claimRounds must not be empty");
+    }
+    try {
+      return await this.walletClient.writeContract({
+        address: this.address,
+        abi: _SlvrAutoCommit.ABI,
+        functionName: "claimFor",
+        args: [userAddress, claimRounds],
+        account: this.walletClient.account,
+        chain: null
+      });
+    } catch (error) {
+      if (error instanceof WalletClientRequiredError || error instanceof ContractCallError) {
+        throw error;
+      }
+      throw new ContractCallError(`Failed to claim: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+  }
+  validatePlanConfig(plays, amountPerPlay, squares, bpsAlloc) {
+    if (!Number.isInteger(plays) || plays <= 0) {
+      throw new ContractCallError("Plays must be a positive integer");
+    }
+    validateAmount(amountPerPlay, "amountPerPlay");
+    validateSquares(squares);
+    validateArrayLengths([squares, bpsAlloc], ["squares", "bpsAlloc"]);
+    validateBpsSum(bpsAlloc, "bpsAlloc");
+  }
+};
+_SlvrAutoCommit.ABI = parseAbi5([
+  // View functions
+  "function planInfo(address user) view returns (bool enabled, uint256 nextRoundId, uint32 playsRemaining, uint256 amountPerPlay, uint256 balance, bool autoClaim, uint8[] squares, uint16[] bpsAlloc, uint256 planStartRoundId)",
+  "function needsExecution(address user) view returns (bool ready, string reason)",
+  "function executedRounds(address user, uint256 roundId) view returns (bool)",
+  "function LOTTERY() view returns (address)",
+  "function UNLIMITED_PLAYS() view returns (uint32)",
+  "function MAX_PLAYS_PER_EXECUTION() view returns (uint32)",
+  "function MAX_CLAIMS_PER_EXECUTION() view returns (uint256)",
+  "function maxFeePerExecution() view returns (uint256)",
+  "function feePremiumBps() view returns (uint16)",
+  // Write functions
+  "function deposit() payable",
+  "function withdraw(uint256 amount, address to)",
+  "function configurePlan(uint32 plays, uint256 amountPerPlay, uint8[] squares, uint16[] bpsAlloc, bool autoClaim)",
+  "function configurePlanAndDeposit(uint32 plays, uint256 amountPerPlay, uint8[] squares, uint16[] bpsAlloc, bool autoClaim) payable",
+  "function disablePlan()",
+  "function cancelPlan()",
+  "function executeFor(address user, uint32 maxPlays, uint256[] claimRounds)",
+  "function claimFor(address user, uint256[] claimRounds) returns (uint256 claimed)"
+]);
+var SlvrAutoCommit = _SlvrAutoCommit;
+
+// src/contracts/hub.ts
+import { parseAbi as parseAbi6 } from "viem";
+var _SlvrHub = class _SlvrHub {
+  constructor(publicClient, _walletClient, address) {
+    this.publicClient = publicClient;
+    this.address = address;
+  }
+  // Read-only module; kept for a uniform module interface.
+  setWalletClient(_walletClient) {
+  }
+  // ---------------------------------------------------------------------------
+  // Views
+  // ---------------------------------------------------------------------------
+  /**
+   * Accrued-but-unminted SLVR emission currently available to a game (its bucket + streamed since
+   * last accrual, hard-capped at one maxAccrualSeconds window of the game's effective rate).
+   */
+  async pendingEmission(gameId) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "pendingEmission",
+      args: [gameId]
+    });
+  }
+  /**
+   * Base SLVR/sec emission rate across the whole active game set
+   */
+  async emissionRatePerSec() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "emissionRatePerSec"
+    });
+  }
+  /**
+   * Soft-cap target supply (0 => use token MAX_SUPPLY)
+   */
+  async targetSupply() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "targetSupply"
+    });
+  }
+  /**
+   * Idle-forfeiture window: cap on dt per accrual (seconds)
+   */
+  async maxAccrualSeconds() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "maxAccrualSeconds"
+    });
+  }
+  /**
+   * Address of the shared veNFT staking contract
+   */
+  async staking() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "staking"
+    });
+  }
+  /**
+   * Address of the shared jackpot contract
+   */
+  async jackpot() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "jackpot"
+    });
+  }
+  /**
+   * Hub-owned sequential counter used to feed the staking contract's round numbering
+   */
+  async stakerSeq() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "stakerSeq"
+    });
+  }
+  /**
+   * Native staker rewards received but not yet flushed to the staking stream
+   */
+  async pendingStakerRewards() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrHub.ABI,
+      functionName: "pendingStakerRewards"
+    });
+  }
+};
+_SlvrHub.ABI = parseAbi6([
+  // View functions
+  "function pendingEmission(uint256 gameId) view returns (uint256)",
+  "function emissionRatePerSec() view returns (uint256)",
+  "function targetSupply() view returns (uint256)",
+  "function maxAccrualSeconds() view returns (uint256)",
+  "function staking() view returns (address)",
+  "function jackpot() view returns (address)",
+  "function stakerSeq() view returns (uint256)",
+  "function pendingStakerRewards() view returns (uint256)"
+]);
+var SlvrHub = _SlvrHub;
+
+// src/contracts/registry.ts
+import { parseAbi as parseAbi7 } from "viem";
+var _SlvrGameRegistry = class _SlvrGameRegistry {
+  constructor(publicClient, _walletClient, address) {
+    this.publicClient = publicClient;
+    this.address = address;
+  }
+  /** Read-only contract: no wallet client needed. Kept for a consistent SDK surface. */
+  setWalletClient(_walletClient) {
+  }
+  /**
+   * Registry id for a game address (0 if not registered; ids are 1-based)
+   */
+  async gameIdOf(game) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "gameIdOf",
+      args: [game]
+    });
+  }
+  /**
+   * Full record for a game id
+   */
+  async gameInfo(gameId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "gameInfo",
+      args: [gameId]
+    });
+    return {
+      game: result.game,
+      gameType: result.gameType,
+      status: result.status,
+      tier: result.tier,
+      emissionWeight: Number(result.emissionWeight),
+      maxWeightBps: Number(result.maxWeightBps),
+      exists: result.exists
+    };
+  }
+  /**
+   * Is this address a registered, Active game?
+   */
+  async isActive(game) {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "isActive",
+      args: [game]
+    });
+  }
+  /**
+   * Status enum for a game id
+   */
+  async statusOf(gameId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "statusOf",
+      args: [gameId]
+    });
+    return result;
+  }
+  /**
+   * Tier enum for a game id
+   */
+  async tierOf(gameId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "tierOf",
+      args: [gameId]
+    });
+    return result;
+  }
+  /**
+   * Emission weight (relative share of the global stream) for a game id
+   */
+  async weightOf(gameId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "weightOf",
+      args: [gameId]
+    });
+    return BigInt(result);
+  }
+  /**
+   * Max realized-fraction ceiling (bps of 10000) for a game id
+   */
+  async maxWeightBpsOf(gameId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "maxWeightBpsOf",
+      args: [gameId]
+    });
+    return Number(result);
+  }
+  /**
+   * Sum of emissionWeight across all Active games (denominator for the split)
+   */
+  async totalActiveWeight() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "totalActiveWeight"
+    });
+  }
+  /**
+   * Number of registered games
+   */
+  async gameCount() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrGameRegistry.ABI,
+      functionName: "gameCount"
+    });
+  }
+};
+_SlvrGameRegistry.ABI = parseAbi7([
+  "function gameIdOf(address game) view returns (uint256)",
+  "function gameInfo(uint256 gameId) view returns ((address game, bytes32 gameType, uint8 status, uint8 tier, uint32 emissionWeight, uint16 maxWeightBps, bool exists))",
+  "function isActive(address game) view returns (bool)",
+  "function statusOf(uint256 gameId) view returns (uint8)",
+  "function tierOf(uint256 gameId) view returns (uint8)",
+  "function weightOf(uint256 gameId) view returns (uint32)",
+  "function maxWeightBpsOf(uint256 gameId) view returns (uint16)",
+  "function totalActiveWeight() view returns (uint256)",
+  "function gameCount() view returns (uint256)"
+]);
+var SlvrGameRegistry = _SlvrGameRegistry;
+
+// src/contracts/jackpot.ts
+import { parseAbi as parseAbi8 } from "viem";
+var _SlvrJackpot = class _SlvrJackpot {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(publicClient, _walletClient, address) {
+    this.publicClient = publicClient;
+    this.address = address;
+  }
+  /** Read-only contract: no wallet client needed. Kept for a consistent SDK surface. */
+  setWalletClient(_walletClient) {
+  }
+  /**
+   * Native (ETH) jackpot pool balance
+   */
+  async jackpotPool() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrJackpot.ABI,
+      functionName: "jackpotPool"
+    });
+  }
+  /**
+   * SLVR jackpot pool balance
+   */
+  async jackpotSlvrPool() {
+    return await this.publicClient.readContract({
+      address: this.address,
+      abi: _SlvrJackpot.ABI,
+      functionName: "jackpotSlvrPool"
+    });
+  }
+};
+_SlvrJackpot.ABI = parseAbi8([
+  "function jackpotPool() view returns (uint256)",
+  "function jackpotSlvrPool() view returns (uint256)"
+]);
+var SlvrJackpot = _SlvrJackpot;
+
+// src/price.ts
+import { parseAbi as parseAbi9 } from "viem";
+var _SlvrPrice = class _SlvrPrice {
+  constructor(publicClient, pairAddress, slvrTokenAddress) {
+    this.publicClient = publicClient;
+    this.pairAddress = pairAddress;
+    this.slvrTokenAddress = slvrTokenAddress;
+  }
+  /** Read the pair reserves and resolve which side is SLVR. */
+  async getReserves() {
+    const [reserves, token0] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.pairAddress,
+        abi: _SlvrPrice.PAIR_ABI,
+        functionName: "getReserves"
+      }),
+      this.publicClient.readContract({
+        address: this.pairAddress,
+        abi: _SlvrPrice.PAIR_ABI,
+        functionName: "token0"
+      })
+    ]);
+    const token0IsSlvr = token0.toLowerCase() === this.slvrTokenAddress.toLowerCase();
+    const slvrReserve = token0IsSlvr ? reserves[0] : reserves[1];
+    const ethReserve = token0IsSlvr ? reserves[1] : reserves[0];
+    return { slvrReserve, ethReserve, token0IsSlvr };
+  }
+  /**
+   * SLVR price in ETH (ETH per SLVR), as a floating-point number.
+   * @throws {Error} if the pair has no SLVR liquidity (zero reserve).
+   */
+  async getPriceInEth() {
+    const { slvrReserve, ethReserve } = await this.getReserves();
+    if (slvrReserve === 0n) {
+      throw new Error("SLVR/ETH pair has zero SLVR reserve; cannot price");
+    }
+    return Number(ethReserve) / Number(slvrReserve);
+  }
+  /**
+   * SLVR price in ETH as a WAD (1e18-scaled `bigint`), for callers that want to
+   * stay in integer math: `priceWad = ethReserve * 1e18 / slvrReserve`.
+   * @throws {Error} if the pair has no SLVR liquidity (zero reserve).
+   */
+  async getPriceInEthWad() {
+    const { slvrReserve, ethReserve } = await this.getReserves();
+    if (slvrReserve === 0n) {
+      throw new Error("SLVR/ETH pair has zero SLVR reserve; cannot price");
+    }
+    return ethReserve * 10n ** 18n / slvrReserve;
+  }
+};
+_SlvrPrice.PAIR_ABI = parseAbi9([
+  "function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)",
+  "function token0() view returns (address)"
+]);
+var SlvrPrice = _SlvrPrice;
+
+// src/oracle.ts
+import { parseAbi as parseAbi10 } from "viem";
+var _ChainlinkPriceFeed = class _ChainlinkPriceFeed {
+  /**
+   * @param publicClient viem public client
+   * @param feedAddress the aggregator address
+   * @param opts.maxStalenessSec if set, {@link getPrice} throws when the feed's
+   *   `updatedAt` is older than this many seconds (checked against the local
+   *   clock). Off by default — enable it only where the local clock is trusted.
+   */
+  constructor(publicClient, feedAddress, opts) {
+    this.publicClient = publicClient;
+    this.feedAddress = feedAddress;
+    this.maxStalenessSec = opts?.maxStalenessSec;
+  }
+  /** Raw `latestRoundData` answer plus the feed's decimals. */
+  async getRoundData() {
+    const [decimals, roundData] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.feedAddress,
+        abi: _ChainlinkPriceFeed.ABI,
+        functionName: "decimals"
+      }),
+      this.publicClient.readContract({
+        address: this.feedAddress,
+        abi: _ChainlinkPriceFeed.ABI,
+        functionName: "latestRoundData"
+      })
+    ]);
+    return { answer: roundData[1], decimals, updatedAt: roundData[3] };
+  }
+  /**
+   * The feed price as a floating-point number (`answer / 10 ** decimals`).
+   * @throws {Error} if the answer is non-positive, or (when `maxStalenessSec` is
+   *   set) if the feed is stale.
+   */
+  async getPrice() {
+    const { answer, decimals, updatedAt } = await this.getRoundData();
+    if (answer <= 0n) {
+      throw new Error(`Chainlink feed ${this.feedAddress} returned a non-positive answer`);
+    }
+    if (this.maxStalenessSec !== void 0) {
+      const nowSec = Math.floor(Date.now() / 1e3);
+      const age = nowSec - Number(updatedAt);
+      if (age > this.maxStalenessSec) {
+        throw new Error(
+          `Chainlink feed ${this.feedAddress} is stale: ${age}s old (max ${this.maxStalenessSec}s)`
+        );
+      }
+    }
+    return Number(answer) / 10 ** decimals;
+  }
+};
+_ChainlinkPriceFeed.ABI = parseAbi10([
+  "function decimals() view returns (uint8)",
+  "function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)"
+]);
+var ChainlinkPriceFeed = _ChainlinkPriceFeed;
+
+// src/ev.ts
+var GRID_SIZE = 25;
+var SINGLE_SQUARE_WIN_PROBABILITY = 1 / GRID_SIZE;
+var PROTOCOL_FEE_BPS = 1e3;
+var REFINING_FEE_BPS = 1e3;
+var JACKPOT_ODDS = 625;
+function computeGridMiningEv(input) {
+  const {
+    stake,
+    pot,
+    emissionPerRound,
+    slvrPriceEth,
+    feeBps = PROTOCOL_FEE_BPS,
+    cashOut = false,
+    refineFeeBps = REFINING_FEE_BPS,
+    jackpotPool = 0,
+    jackpotOdds = JACKPOT_ODDS
+  } = input;
+  if (!(stake > 0)) throw new Error(`stake must be positive (got ${stake})`);
+  if (!(pot > 0)) throw new Error(`pot must be positive (got ${pot})`);
+  const feeFraction = feeBps / 1e4;
+  const realize = cashOut ? 1 - refineFeeBps / 1e4 : 1;
+  const share = stake / pot;
+  const ethBleed = feeFraction * stake;
+  const slvrMined = share * emissionPerRound;
+  const slvrValueEth = slvrMined * slvrPriceEth * realize;
+  const jackpotEvEth = jackpotOdds > 0 && Number.isFinite(jackpotOdds) ? 1 / jackpotOdds * share * jackpotPool : 0;
+  const netEthNoJackpot = slvrValueEth - ethBleed;
+  const netEth = netEthNoJackpot + jackpotEvEth;
+  const perShareEthReward = emissionPerRound * slvrPriceEth * realize + (jackpotOdds > 0 && Number.isFinite(jackpotOdds) ? jackpotPool / jackpotOdds : 0);
+  const breakEvenPot = feeFraction > 0 ? perShareEthReward / feeFraction : Infinity;
+  const slvrRewardDenom = share * emissionPerRound * realize;
+  const breakEvenSlvrPriceEth = slvrRewardDenom > 0 ? (ethBleed - jackpotEvEth) / slvrRewardDenom : Infinity;
+  return {
+    share,
+    ethBleed,
+    slvrMined,
+    slvrValueEth,
+    jackpotEvEth,
+    netEthNoJackpot,
+    netEth,
+    edgeRatio: netEth / stake,
+    breakEvenPot,
+    breakEvenSlvrPriceEth,
+    profitable: netEth > 0
+  };
+}
+
+// src/connect.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  defineChain as defineChain2,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/deployments.ts
+import { defineChain } from "viem";
+var robinhood = {
+  chainId: 4663,
+  name: "Robinhood Chain",
+  rpcUrl: "https://rpc.mainnet.chain.robinhood.com",
+  blockExplorer: "https://robinhoodchain.blockscout.com/",
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cmre158qbffn101xe929tflsk/subgraphs/slvr-robinhood/1.2.0/gn",
+  addresses: {
+    lottery: "0x284Eb4016305Fa7FbC162Fb68F27227271001c7f",
+    staking: "0xaF68598eBd245DC3cB92FF16E9Ba1814DD137200",
+    token: "0x791229E3EbD6CFdC3D8157f48722684173C29aD9",
+    autoCommit: "0x314c8D5755468224AC60c36FB5494F0D7D5Abb3B",
+    voteEscrow: "0xd9b8FBD61033145c5496132153CE675756313B71",
+    slvrEthPair: "0xe365b92239097Ed3322131411DbE15a5c4068eff",
+    // Chainlink ETH/USD feed (standard AggregatorV3 proxy; "ETH / USD", 8 decimals).
+    // Verified on-chain. There is also an SVR proxy at
+    // 0x5058aDee53b04e374d8bEDbAD634Bc4778F50b22 with identical price data — that
+    // one is for protocols integrating Chainlink SVR (OEV recapture); for plain
+    // price reads the standard proxy below is the right choice.
+    chainlinkEthUsd: "0x78F3556b67E17Df817D51Ef5a990cDaF09E8d3A9",
+    // Multicall3 at its canonical cross-chain address (verified deployed on Robinhood Chain).
+    multicall3: "0xcA11bde05977b3631167028862bE2a173976CA11"
+  }
+};
+var deployments = {
+  robinhood
+};
+var robinhoodChain = defineChain({
+  id: robinhood.chainId,
+  name: robinhood.name,
+  nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+  rpcUrls: { default: { http: [robinhood.rpcUrl] } },
+  blockExplorers: {
+    default: { name: "Blockscout", url: "https://robinhoodchain.blockscout.com" }
+  },
+  // Registering Multicall3 lets viem batch reads: the SDK's multi-square reads
+  // become one RPC call, and clients created with `batch: { multicall: true }`
+  // auto-batch every concurrent read.
+  contracts: {
+    multicall3: { address: robinhood.addresses.multicall3 }
+  }
+});
+
+// src/connect.ts
+function chainFromDeployment(deployment) {
+  if (deployment.chainId === robinhood.chainId) return robinhoodChain;
+  return defineChain2({
+    id: deployment.chainId,
+    name: deployment.name,
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [deployment.rpcUrl] } },
+    ...deployment.blockExplorer ? { blockExplorers: { default: { name: "Explorer", url: deployment.blockExplorer } } } : {},
+    ...deployment.addresses.multicall3 ? { contracts: { multicall3: { address: deployment.addresses.multicall3 } } } : {}
+  });
+}
+function createSlvrClients(opts = {}) {
+  const deployment = opts.deployment ?? robinhood;
+  const chain = chainFromDeployment(deployment);
+  const transport = opts.transport ?? http(opts.rpcUrl ?? deployment.rpcUrl, { timeout: 2e4, retryCount: 3 });
+  const publicClient = createPublicClient({
+    chain,
+    transport,
+    batch: { multicall: opts.batchMulticall ?? true },
+    ...opts.pollingInterval ? { pollingInterval: opts.pollingInterval } : {}
+  });
+  const account = opts.account ?? (opts.privateKey ? privateKeyToAccount(opts.privateKey) : void 0);
+  const walletClient = account ? createWalletClient({ chain, transport, account }) : void 0;
+  return { chain, publicClient, walletClient };
+}
+
+// src/types.ts
+var GameStatus = /* @__PURE__ */ ((GameStatus2) => {
+  GameStatus2[GameStatus2["Pending"] = 0] = "Pending";
+  GameStatus2[GameStatus2["Active"] = 1] = "Active";
+  GameStatus2[GameStatus2["Paused"] = 2] = "Paused";
+  GameStatus2[GameStatus2["Retired"] = 3] = "Retired";
+  return GameStatus2;
+})(GameStatus || {});
+var GameTier = /* @__PURE__ */ ((GameTier2) => {
+  GameTier2[GameTier2["Core"] = 0] = "Core";
+  GameTier2[GameTier2["Community"] = 1] = "Community";
+  GameTier2[GameTier2["Experimental"] = 2] = "Experimental";
+  return GameTier2;
+})(GameTier || {});
+
+// src/transaction.ts
+async function estimateGas(publicClient, address, abi, functionName, args, value, account) {
+  try {
+    const estimateParams = {
+      address,
+      abi,
+      functionName,
+      args
+    };
+    if (value !== void 0) {
+      estimateParams.value = value;
+    }
+    if (account !== void 0) {
+      estimateParams.account = account;
+    }
+    const gas = await publicClient.estimateContractGas(estimateParams);
+    return gas;
+  } catch (error) {
+    throw new TransactionError(
+      `Failed to estimate gas for ${functionName}: ${error instanceof Error ? error.message : String(error)}`,
+      void 0,
+      error
+    );
+  }
+}
+async function waitForReceipt(publicClient, hash, timeout = 12e4) {
+  try {
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash,
+      timeout
+    });
+    if (receipt && typeof receipt === "object" && "status" in receipt) {
+      if (receipt.status === "reverted") {
+        throw new TransactionError(
+          `Transaction reverted: ${hash}`,
+          hash
+        );
+      }
+    }
+    return receipt;
+  } catch (error) {
+    if (error instanceof TransactionError) {
+      throw error;
+    }
+    throw new TransactionError(
+      `Failed to wait for transaction receipt: ${error instanceof Error ? error.message : String(error)}`,
+      hash,
+      error
+    );
+  }
+}
+async function executeTransaction(walletClient, publicClient, address, abi, functionName, args, options = {}) {
+  const {
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    waitForReceipt: waitForReceipt_,
+    receiptTimeout,
+    value
+  } = options;
+  const writeParams = {
+    address,
+    abi,
+    functionName,
+    args,
+    account: walletClient.account,
+    chain: null,
+    ...value !== void 0 && { value },
+    ...gas !== void 0 && { gas },
+    ...gasPrice !== void 0 && { gasPrice },
+    ...maxFeePerGas !== void 0 && { maxFeePerGas },
+    ...maxPriorityFeePerGas !== void 0 && { maxPriorityFeePerGas }
+  };
+  try {
+    const hash = await walletClient.writeContract(writeParams);
+    if (waitForReceipt_) {
+      return await waitForReceipt(publicClient, hash, receiptTimeout);
+    }
+    return hash;
+  } catch (error) {
+    throw new TransactionError(
+      `Failed to execute transaction: ${error instanceof Error ? error.message : String(error)}`,
+      void 0,
+      error
+    );
+  }
+}
+
+// src/index.ts
+var SlvrSDK = class _SlvrSDK {
+  constructor(config) {
+    this.config = config;
+    this.lottery = new SlvrGridLottery(
+      config.publicClient,
+      config.walletClient,
+      config.addresses.lottery
+    );
+    this.staking = new SlvrStaking(
+      config.publicClient,
+      config.walletClient,
+      config.addresses.staking
+    );
+    this.token = new SlvrToken(
+      config.publicClient,
+      config.walletClient,
+      config.addresses.token
+    );
+    if (config.addresses.autoCommit) {
+      this.autoCommit = new SlvrAutoCommit(
+        config.publicClient,
+        config.walletClient,
+        config.addresses.autoCommit
+      );
+    }
+    if (config.addresses.hub) {
+      this.hub = new SlvrHub(
+        config.publicClient,
+        config.walletClient,
+        config.addresses.hub
+      );
+    }
+    if (config.addresses.registry) {
+      this.registry = new SlvrGameRegistry(
+        config.publicClient,
+        config.walletClient,
+        config.addresses.registry
+      );
+    }
+    if (config.addresses.jackpot) {
+      this.jackpot = new SlvrJackpot(
+        config.publicClient,
+        config.walletClient,
+        config.addresses.jackpot
+      );
+    }
+    if (config.addresses.slvrEthPair) {
+      this.price = new SlvrPrice(
+        config.publicClient,
+        config.addresses.slvrEthPair,
+        config.addresses.token
+      );
+    }
+    if (config.addresses.chainlinkEthUsd) {
+      this.ethUsd = new ChainlinkPriceFeed(config.publicClient, config.addresses.chainlinkEthUsd);
+    }
+  }
+  /**
+   * One-line setup: build clients (with Multicall3 batching + resilient transport
+   * defaults) and an SDK for a deployment. Pass a `privateKey`/`account` to enable
+   * writes; omit it for a read-only SDK.
+   *
+   * @example
+   * ```typescript
+   * import { SlvrSDK } from '@slvr-labs/sdk';
+   * const sdk = SlvrSDK.connect();                                   // read-only, Robinhood Chain
+   * const bot = SlvrSDK.connect({ privateKey: process.env.PK });     // wallet-backed
+   * ```
+   */
+  static connect(opts = {}) {
+    const deployment = opts.deployment ?? robinhood;
+    const { publicClient, walletClient } = createSlvrClients(opts);
+    return new _SlvrSDK({ publicClient, walletClient, addresses: deployment.addresses });
+  }
+  /**
+   * Get the public client
+   */
+  getPublicClient() {
+    return this.config.publicClient;
+  }
+  /**
+   * Get the wallet client (if available)
+   */
+  getWalletClient() {
+    return this.config.walletClient;
+  }
+  /**
+   * Update the wallet client and reinitialize contracts
+   * @param walletClient New wallet client (or undefined to remove)
+   */
+  setWalletClient(walletClient) {
+    this.config.walletClient = walletClient;
+    this.lottery.setWalletClient(walletClient);
+    this.staking.setWalletClient(walletClient);
+    this.token.setWalletClient(walletClient);
+    if (this.autoCommit) {
+      this.autoCommit.setWalletClient(walletClient);
+    }
+    if (this.hub) {
+      this.hub.setWalletClient(walletClient);
+    }
+    if (this.registry) {
+      this.registry.setWalletClient(walletClient);
+    }
+    if (this.jackpot) {
+      this.jackpot.setWalletClient(walletClient);
+    }
+  }
+  /**
+   * Helper: Calculate bet amounts from percentages
+   * @param totalAmount Total amount to bet
+   * @param percentages Array of percentages (0-100) for each square
+   * @returns Array of amounts in wei
+   * @throws ValidationError if percentages don't sum to 100 or if totalAmount is invalid
+   */
+  static calculateBetAmounts(totalAmount, percentages) {
+    if (percentages.length === 0) {
+      throw new ValidationError("Percentages array cannot be empty", "percentages");
+    }
+    const totalPercent = percentages.reduce((sum, p) => sum + p, 0);
+    if (Math.abs(totalPercent - 100) > 0.01) {
+      throw new ValidationError(`Percentages must sum to 100 (got ${totalPercent})`, "percentages");
+    }
+    const amounts = [];
+    let allocated = 0n;
+    for (let i = 0; i < percentages.length; i++) {
+      const percentage = percentages[i];
+      if (percentage === void 0) continue;
+      const amount = totalAmount * BigInt(Math.round(percentage * 100)) / 10000n;
+      amounts.push(amount);
+      allocated += amount;
+    }
+    if (allocated !== totalAmount && amounts.length > 0 && amounts[0] !== void 0) {
+      amounts[0] += totalAmount - allocated;
+    }
+    return amounts;
+  }
+  /**
+   * Helper: Format bigint to human-readable string.
+   *
+   * `precision` caps the number of decimal places shown; trailing zeros are
+   * stripped (like viem's `formatEther`), so `formatToken(1.5e18)` is `"1.5"`,
+   * not `"1.5000"`.
+   * @param value Value in wei
+   * @param decimals Number of decimals (default 18)
+   * @param precision Max decimal places to show (default 4)
+   */
+  static formatToken(value, decimals = 18, precision = 4) {
+    const divisor = BigInt(10 ** decimals);
+    const whole = value / divisor;
+    const remainder = value % divisor;
+    const fractional = remainder * BigInt(10 ** precision) / divisor;
+    if (fractional === 0n) {
+      return whole.toString();
+    }
+    const fractionalStr = fractional.toString().padStart(precision, "0").replace(/0+$/, "");
+    return fractionalStr ? `${whole}.${fractionalStr}` : whole.toString();
+  }
+  /**
+   * Helper: Parse human-readable string to bigint
+   * @param value Human-readable value (e.g., "1.5")
+   * @param decimals Number of decimals (default 18)
+   */
+  static parseToken(value, decimals = 18) {
+    const parts = value.split(".");
+    const whole = BigInt(parts[0] || "0");
+    const fractional = parts[1] ? BigInt(parts[1].padEnd(decimals, "0").slice(0, decimals)) : 0n;
+    return whole * BigInt(10 ** decimals) + fractional;
+  }
+  /**
+   * Helper: Calculate time remaining until round ends
+   * @param roundId Round ID
+   * @returns Time remaining in seconds, or 0 if round has ended
+   */
+  async getTimeRemaining(roundId) {
+    const [roundEnd, block] = await Promise.all([
+      this.lottery.roundEnd(roundId),
+      this.config.publicClient.getBlock()
+    ]);
+    const remaining = roundEnd - block.timestamp;
+    return remaining > 0n ? Number(remaining) : 0;
+  }
+  /**
+   * Helper: Check if user can claim rewards for a round
+   * @param roundId Round ID
+   * @param user User address
+   * @returns True if user can claim
+   */
+  async canClaim(roundId, user) {
+    const [round, hasClaimed_] = await Promise.all([
+      this.lottery.getRound(roundId),
+      this.lottery.getHasClaimed(roundId, user)
+    ]);
+    if (!round.resolved || hasClaimed_) {
+      return false;
+    }
+    const userBet = await this.lottery.getUserBet(roundId, round.winningSquare, user);
+    return userBet > 0n;
+  }
+  /**
+   * Helper: Get user's claimable rounds
+   * @param user User address
+   * @param startRoundId Start round ID to check from
+   * @param endRoundId End round ID to check to
+   * @returns Array of round IDs that can be claimed
+   */
+  async getClaimableRounds(user, startRoundId, endRoundId) {
+    const rounds = [];
+    for (let roundId = startRoundId; roundId <= endRoundId; roundId++) {
+      rounds.push(roundId);
+    }
+    const flags = await Promise.all(rounds.map((roundId) => this.canClaim(roundId, user)));
+    return rounds.filter((_, i) => flags[i]);
+  }
+  /**
+   * Helper: Compute a game's effective SLVR/sec emission rate.
+   *
+   * Mirrors SlvrHub._effectiveRatePerSec: the game's weighted share of the global emission stream,
+   * i.e. emissionRatePerSec * weightOf(gameId) / totalActiveWeight. NOTE: this does not apply the
+   * per-game maxWeightBps ceiling that the contract also enforces; it is the pre-cap weighted rate.
+   *
+   * Requires both `hub` and `registry` addresses to be configured.
+   * @param gameId Registry game id
+   * @returns Effective emission rate in SLVR/sec (0 if there is no active weight)
+   */
+  async effectiveEmissionRate(gameId) {
+    if (!this.hub) {
+      throw new ValidationError("hub address is required for effectiveEmissionRate", "hub");
+    }
+    if (!this.registry) {
+      throw new ValidationError("registry address is required for effectiveEmissionRate", "registry");
+    }
+    const [rate, weight, totalWeight] = await Promise.all([
+      this.hub.emissionRatePerSec(),
+      this.registry.weightOf(gameId),
+      this.registry.totalActiveWeight()
+    ]);
+    if (totalWeight === 0n) {
+      return 0n;
+    }
+    return rate * weight / totalWeight;
+  }
+  /**
+   * Helper: Get the accrued-but-unminted SLVR emission currently available to a game.
+   *
+   * Thin pass-through to SlvrHub.pendingEmission. Requires `hub` to be configured.
+   * @param gameId Registry game id
+   */
+  async pendingEmission(gameId) {
+    if (!this.hub) {
+      throw new ValidationError("hub address is required for pendingEmission", "hub");
+    }
+    return await this.hub.pendingEmission(gameId);
+  }
+  /**
+   * Helper: current SLVR spot price in ETH (ETH per SLVR).
+   *
+   * Requires a `slvrEthPair` address to be configured (so `sdk.price` exists).
+   * @throws ValidationError if no pair address was configured.
+   */
+  async getSlvrPriceInEth() {
+    if (!this.price) {
+      throw new ValidationError("slvrEthPair address is required for getSlvrPriceInEth", "slvrEthPair");
+    }
+    return await this.price.getPriceInEth();
+  }
+  /**
+   * Helper: current ETH price in USD from the configured Chainlink feed.
+   *
+   * Requires a `chainlinkEthUsd` address (so `sdk.ethUsd` exists). This is wired
+   * for Robinhood Chain in `deployments.robinhood`; on chains without a feed,
+   * supply one or pass `ethUsd` to {@link getSlvrPrice}.
+   * @throws ValidationError if no ETH/USD feed was configured.
+   */
+  async getEthPriceUsd() {
+    if (!this.ethUsd) {
+      throw new ValidationError("chainlinkEthUsd address is required for getEthPriceUsd", "chainlinkEthUsd");
+    }
+    return await this.ethUsd.getPrice();
+  }
+  /**
+   * Helper: current SLVR price in **both ETH and USD**.
+   *
+   * SLVR/ETH comes from the UniswapV2 pair (`sdk.price`). The USD value uses, in
+   * order: an explicit `opts.ethUsd`, else the configured Chainlink ETH/USD feed
+   * (`sdk.ethUsd`), else `usd` is `null`.
+   *
+   * @param opts.ethUsd override the ETH/USD price (e.g. from your own off-chain source)
+   * @throws ValidationError if no `slvrEthPair` was configured.
+   *
+   * @example
+   * ```typescript
+   * const { eth, usd } = await sdk.getSlvrPrice();              // uses Chainlink feed if configured
+   * const q = await sdk.getSlvrPrice({ ethUsd: 1797.35 });      // or supply ETH/USD yourself
+   * ```
+   */
+  async getSlvrPrice(opts) {
+    if (!this.price) {
+      throw new ValidationError("slvrEthPair address is required for getSlvrPrice", "slvrEthPair");
+    }
+    const eth = await this.price.getPriceInEth();
+    let ethUsd = opts?.ethUsd;
+    if (ethUsd === void 0 && this.ethUsd) {
+      ethUsd = await this.ethUsd.getPrice();
+    }
+    return { eth, usd: ethUsd !== void 0 ? eth * ethUsd : null };
+  }
+  /**
+   * Helper: estimate the per-round expected value of grid mining for the given
+   * stake, pulling live pot, emission and SLVR price on-chain.
+   *
+   * This is the SDK-level convenience around {@link computeGridMiningEv}: it reads
+   * the round's pot (sum of all squares), the emission target (`slvrPerRound`), the
+   * protocol fee (`protocolFeeBps`), and the SLVR price (via `sdk.price`), then
+   * returns the full EV breakdown. Any of those can be overridden via `params`.
+   *
+   * The jackpot pool is **not** auto-read (it isn't exposed as a single call on the
+   * live lottery) — pass `jackpotPool` if you want the jackpot term included.
+   *
+   * @remarks `slvrPerRound` is the emission *target*; actual emission is hub-gated
+   * and may be lower, so treat the result as an upper-ish estimate. Requires a
+   * configured `slvrEthPair` unless you pass `slvrPriceEth`.
+   */
+  async estimateRoundEv(params) {
+    const roundId = params.roundId ?? await this.lottery.currentRoundId();
+    const [potEth, emissionPerRound, slvrPriceEth, feeBps, jackpotPoolEth] = await Promise.all([
+      params.pot !== void 0 ? Promise.resolve(params.pot) : this.lottery.getRoundSquares(roundId).then((sqs) => Number(formatEther(sqs.reduce((sum, s) => sum + s.total, 0n)))),
+      params.emissionPerRound !== void 0 ? Promise.resolve(params.emissionPerRound) : this.lottery.slvrPerRound().then((v) => Number(formatEther(v))),
+      params.slvrPriceEth !== void 0 ? Promise.resolve(params.slvrPriceEth) : this.getSlvrPriceInEth(),
+      this.lottery.protocolFeeBps(),
+      // Auto-read the jackpot pool (0 if no jackpot is set for the round / read fails).
+      params.jackpotPool !== void 0 ? Promise.resolve(params.jackpotPool) : this.getJackpotPool(roundId).then((v) => Number(formatEther(v))).catch(() => 0)
+    ]);
+    return computeGridMiningEv({
+      stake: params.stake,
+      pot: potEth,
+      emissionPerRound,
+      slvrPriceEth,
+      feeBps,
+      cashOut: params.cashOut,
+      jackpotPool: jackpotPoolEth,
+      jackpotOdds: params.jackpotOdds
+    });
+  }
+  /**
+   * Helper: current jackpot pool for a round, in wei (0 if no jackpot is set).
+   *
+   * Resolves the round's jackpot contract via `getRoundJackpot` and reads its
+   * `jackpotPool()`. Defaults to the current round.
+   */
+  async getJackpotPool(roundId) {
+    const id = roundId ?? await this.lottery.currentRoundId();
+    const jackpotAddress = await this.lottery.getRoundJackpot(id);
+    if (jackpotAddress === "0x0000000000000000000000000000000000000000") return 0n;
+    return await new SlvrJackpot(this.config.publicClient, void 0, jackpotAddress).jackpotPool();
+  }
+};
+export {
+  ChainlinkPriceFeed,
+  ContractCallError,
+  GRID_SIZE,
+  GameStatus,
+  GameTier,
+  JACKPOT_ODDS,
+  PROTOCOL_FEE_BPS,
+  REFINING_FEE_BPS,
+  SINGLE_SQUARE_WIN_PROBABILITY,
+  SlvrAutoCommit,
+  SlvrAutoCommitEvents,
+  SlvrGameRegistry,
+  SlvrGridLottery,
+  SlvrGridLotteryEvents,
+  SlvrHub,
+  SlvrJackpot,
+  SlvrPrice,
+  SlvrRevertError,
+  SlvrSDK,
+  SlvrSDKError,
+  SlvrStaking,
+  SlvrStakingEvents,
+  SlvrToken,
+  SlvrTokenEvents,
+  TransactionError,
+  ValidationError,
+  WalletClientRequiredError,
+  chainFromDeployment,
+  computeGridMiningEv,
+  createSlvrClients,
+  decodeEvent,
+  decodeEvents,
+  decodeSlvrRevert,
+  deployments,
+  estimateGas,
+  executeTransaction,
+  robinhood,
+  robinhoodChain,
+  validateAddress,
+  validateAmount,
+  validateArrayLengths,
+  validateBps,
+  validateBpsSum,
+  validateSquares,
+  waitForReceipt,
+  waitForTransactionReceipt
+};
+//# sourceMappingURL=index.mjs.map