@slvr-labs/sdk 0.1.0 → 0.1.2

package/dist/contracts/lottery.js

@@ -1,767 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlvrGridLottery = void 0;
-const viem_1 = require("viem");
-const errors_1 = require("../errors");
-const utils_1 = require("../utils");
-const events_1 = require("../events");
-/**
- * SlvrGridLottery contract interface
- */
-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 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 errors_1.WalletClientRequiredError('betting');
-        }
-        const { roundId, squares, amounts, beneficiary } = params;
-        // Validate inputs
-        if (roundId < 0n) {
-            throw new errors_1.ContractCallError('Round ID must be non-negative');
-        }
-        (0, utils_1.validateSquares)(squares);
-        (0, utils_1.validateArrayLengths)([squares, amounts], ['squares', 'amounts']);
-        for (const amount of amounts) {
-            (0, utils_1.validateAmount)(amount, 'bet amount');
-        }
-        const totalAmount = amounts.reduce((sum, amt) => sum + amt, 0n);
-        try {
-            // Check if account exists, if not, add account deposit to the value sent
-            const beneficiaryAddress = beneficiary
-                ? (0, utils_1.validateAddress)(beneficiary, 'beneficiary')
-                : this.walletClient.account.address;
-            const hasAccount_ = await this.hasAccount(beneficiaryAddress);
-            const accountDeposit_ = hasAccount_ ? 0n : await this.accountDeposit();
-            const totalValue = totalAmount + accountDeposit_;
-            if (beneficiary) {
-                return await this.walletClient.writeContract({
-                    address: this.address,
-                    abi: SlvrGridLottery.ABI,
-                    functionName: 'betFor',
-                    args: [roundId, beneficiaryAddress, squares, amounts],
-                    value: totalValue,
-                    account: this.walletClient.account,
-                    chain: null,
-                });
-            }
-            else {
-                return await this.walletClient.writeContract({
-                    address: this.address,
-                    abi: SlvrGridLottery.ABI,
-                    functionName: 'bet',
-                    args: [roundId, squares, amounts],
-                    value: totalValue,
-                    account: this.walletClient.account,
-                    chain: null,
-                });
-            }
-        }
-        catch (error) {
-            if (error instanceof errors_1.WalletClientRequiredError || error instanceof errors_1.ContractCallError) {
-                throw error;
-            }
-            throw new errors_1.ContractCallError(`Failed to place bet: ${error instanceof Error ? error.message : String(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 errors_1.WalletClientRequiredError('claiming');
-        }
-        if (params.roundId < 0n) {
-            throw new errors_1.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,
-            });
-        }
-        catch (error) {
-            if (error instanceof errors_1.WalletClientRequiredError || error instanceof errors_1.ContractCallError) {
-                throw error;
-            }
-            throw new errors_1.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 errors_1.WalletClientRequiredError('claiming');
-        }
-        if (params.roundId < 0n) {
-            throw new errors_1.ContractCallError('Round ID must be non-negative');
-        }
-        const user = (0, utils_1.validateAddress)(params.user, 'user');
-        const recipientNative = params.recipientNative
-            ? (0, utils_1.validateAddress)(params.recipientNative, 'recipientNative')
-            : '0x0000000000000000000000000000000000000000';
-        const recipientSlvr = params.recipientSlvr
-            ? (0, utils_1.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 errors_1.WalletClientRequiredError || error instanceof errors_1.ContractCallError) {
-                throw error;
-            }
-            throw new errors_1.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 errors_1.WalletClientRequiredError('batch claiming');
-        }
-        if (roundIds.length === 0) {
-            throw new errors_1.ContractCallError('No rounds to claim');
-        }
-        const claimUser = user ? (0, utils_1.validateAddress)(user, 'user') : this.walletClient.account.address;
-        const hashes = [];
-        for (const roundId of roundIds) {
-            if (roundId < 0n) {
-                throw new errors_1.ContractCallError(`Invalid round ID: ${roundId}`);
-            }
-            try {
-                const hash = await this.claimAdvanced({
-                    user: claimUser,
-                    roundId,
-                });
-                hashes.push(hash);
-                // Optionally wait for receipt before proceeding
-                if (options?.waitForReceipt) {
-                    await (0, utils_1.waitForTransactionReceipt)(this.publicClient, hash);
-                }
-            }
-            catch (error) {
-                // If one claim fails, we still return the hashes we've collected so far
-                // The caller can decide how to handle partial failures
-                throw new errors_1.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 errors_1.WalletClientRequiredError('approving delegate');
-        }
-        const delegateAddress = (0, utils_1.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 errors_1.WalletClientRequiredError('revoking delegate');
-        }
-        const delegateAddress = (0, utils_1.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 errors_1.WalletClientRequiredError('donating to jackpot');
-        }
-        (0, utils_1.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 errors_1.WalletClientRequiredError('adding ETH to jackpot');
-        }
-        (0, utils_1.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 errors_1.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 errors_1.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);
-        // Fast path: batch all 2×gridSize reads into a single multicall. Requires the
-        // client's chain to know Multicall3 (robinhoodChain registers it). Falls back
-        // to parallel individual reads on any chain/client without it.
-        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: 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);
-        // Batch via multicall when available; fall back to parallel reads otherwise.
-        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: 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 ?? 4000;
-        const deadline = opts.timeoutMs !== undefined ? 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: events_1.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: events_1.SlvrGridLotteryEvents,
-            eventName: 'BetPlaced',
-            args: opts.roundId !== undefined ? { roundId: opts.roundId } : undefined,
-            onLogs: (logs) => {
-                for (const log of logs)
-                    onBet(log.args);
-            },
-            onError: opts.onError,
-            poll: true,
-        });
-    }
-}
-exports.SlvrGridLottery = SlvrGridLottery;
-// ABI for SlvrGridLottery contract
-SlvrGridLottery.ABI = (0, viem_1.parseAbi)([
-    // 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)',
-]);
-//# sourceMappingURL=lottery.js.map