aiia-vault-sdk 1.0.1

package/contracts/factories/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { SeedRoundFundraiser__factory } from "./SeedRoundFundraiser__factory";

package/contracts/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { SeedRoundFundraiser } from "./SeedRoundFundraiser";
+export * as factories from "./factories";
+export { SeedRoundFundraiser__factory } from "./factories/SeedRoundFundraiser__factory";

package/contracts.json

@@ -0,0 +1,28 @@
+{
+  "sepolia": {
+    "Currency-old": "0x8c1598399bEb88F9a2aF5966438D4f481512C2f8",
+    "Reward-old": "0x098048C7F6Afd2dA8661965e2d34bf009faA12F2",
+    "TradingVault": "0x1567fEF642c15bbc0738200F04c52e4966cFA0c9",
+    "TradingVault-implemented": "0x74890EC41c499d998d9131a738EFF51229A7f989",
+    "TradingVault-implemented-old": "0x74890EC41c499d998d9131a738EFF51229A7f989",
+    "Currency": "0x2677818cf5e8519273f354FBDA21F794309d8D98",
+    "Reward": "0x09F827Fa3307cF467F51782722A5e3f43a2598dc",
+    "SeedRoundFundraiser": "0xDB40B1E554718555B2E55574B36f0974635c93f4",
+    "SeedRoundFundraiser-implemented": "0xEF7bDB1A5D287d6B3f9a6bD9008471C728249732",
+    "WETH": "0xC82AE9c8b25F5b48ac200efd3e86Ca372AE1AD91"
+  },
+  "hardhat": {
+    "Currency": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+    "Reward": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+    "TradingVault": "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+    "TradingVault-implemented": "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+  },
+  "base-sepolia": {
+    "Currency": "0xDB2e50234a3BE8aA4200C96712F190cf712cd8ec",
+    "Reward": "0xa5Ef2328aa2F6F231D15cdcF48503974D0938eD4",
+    "SeedRoundFundraiser": "0xbd520dbcb8e0b062D10d7879D27C20d214a262F6",
+    "SeedRoundFundraiser-implemented": "0x539C6D1f51d42f4A1376B0998b4Fff602C9908a6",
+    "WETH": "0x08a2d38807B1D345b6c1642f8030a29DC2Cc7223",
+    "SeedRoundFundraiser-implemented-old": "0x823f099526F2c69bD764686bb4D41afeD7509366"
+  }
+}

package/dist/SeedRoundFundraiser.d.ts

@@ -0,0 +1,130 @@
+import { ethers } from "ethers";
+import { ParsedSeedRoundFundraiserEvent, ParsedSeedRoundFundraiserEventRaw } from "./types";
+import { type SendTransactionMutateAsync } from "@wagmi/core/query";
+import { Config } from "@wagmi/core/dist/types/createConfig";
+export interface WhitelistedToken {
+    isWhitelisted: boolean;
+    price: number;
+}
+export interface WhitelistedTokenInfo {
+    address: string;
+    isWhitelisted: boolean;
+    price: number;
+    symbol: string;
+    maxContribution: number;
+    maxContributionRaw: number;
+    decimals: number;
+}
+export interface RoundConfig {
+    startTime: number;
+    endTime: number;
+    targetFund: number;
+    totalAllocation: number;
+    maxFundPerAccount: number;
+    exists: boolean;
+    ended: boolean;
+    claimingEnabled: boolean;
+    refundEnabled: boolean;
+}
+export interface UserContribution {
+    fundAmount: number;
+    tokenAllocation: number;
+    claimed: boolean;
+    refunded: boolean;
+    contributedToken: string;
+    contributedAmount: number;
+}
+export declare class SeedRoundFundraiserSDK {
+    name: string;
+    private contract;
+    private providers;
+    private contractAddress;
+    private isBootstrapped;
+    private PRICE_PRECISION;
+    private whitelistedTokensArray;
+    private networkName;
+    constructor(rpcUrls: string | string[], contractAddress?: string);
+    private getNetworkNameFromRpc;
+    private importWhitelistedTokens;
+    getWhitelistedTokenInfo(tokenAddress: string): Promise<WhitelistedTokenInfo | null>;
+    getAllWhitelistedTokensInfo(): Promise<WhitelistedTokenInfo[]>;
+    private getRandomProvider;
+    private getContractWithRandomProvider;
+    bootstrap(): Promise<void>;
+    signAndSendTransaction(tx: ethers.ContractTransaction, wallet: ethers.Wallet | SendTransactionMutateAsync<Config, any>, callbacks?: {
+        onSubmit?: (tx: string) => void | Promise<void>;
+        onFinally?: (status: {
+            status: boolean | null;
+            confirmations: number;
+            txHash: string;
+            isCompleted: boolean;
+            attempts: number;
+        }) => void | Promise<void>;
+        onError?: (error: Error) => void | Promise<void>;
+    }): Promise<{
+        transaction: {
+            hash: string;
+        };
+        status: {
+            status: boolean | null;
+            confirmations: number;
+            isCompleted: boolean;
+            attempts: number;
+        };
+    }>;
+    buildAddWhitelistedTokenTx(token: string, price: number): Promise<ethers.ContractTransaction>;
+    buildUpdateTokenPriceTx(token: string, newPrice: number): Promise<ethers.ContractTransaction>;
+    buildRemoveWhitelistedTokenTx(token: string): Promise<ethers.ContractTransaction>;
+    buildCreateRoundTx(startTime: number, endTime: number, targetFund: number, totalAllocation: number, maxFundPerAccount: number): Promise<ethers.ContractTransaction>;
+    buildUpdateRoundTx(roundId: number, startTime: number, endTime: number, targetFund: number, totalAllocation: number, maxFundPerAccount: number): Promise<ethers.ContractTransaction>;
+    buildEndRoundTx(roundId: number): Promise<ethers.ContractTransaction>;
+    buildSetClaimingEnabledTx(roundId: number, enabled: boolean): Promise<ethers.ContractTransaction>;
+    buildSetRefundEnabledTx(roundId: number, enabled: boolean): Promise<ethers.ContractTransaction>;
+    buildContributeTx(roundId: number, token: string, amount: number): Promise<ethers.ContractTransaction>;
+    buildClaimTokensTx(): Promise<ethers.ContractTransaction>;
+    buildRefundTx(): Promise<ethers.ContractTransaction>;
+    buildWithdrawFundsTx(token: string, amount: number): Promise<ethers.ContractTransaction>;
+    buildClaimTokensByRoundIdTx(roundId: number): Promise<ethers.ContractTransaction>;
+    getWhitelistedToken(token: string): Promise<WhitelistedToken>;
+    getRound(roundId: number): Promise<RoundConfig>;
+    getUserContribution(roundId: number, user: string): Promise<UserContribution>;
+    getRoundRaisedFunds(roundId: number): Promise<number>;
+    getRoundParticipants(roundId: number): Promise<number>;
+    getUserParticipatedRound(user: string): Promise<number>;
+    getProjectToken(): Promise<string>;
+    getTotalRounds(): Promise<number>;
+    getTotalRaisedFunds(): Promise<number>;
+    isRoundActive(roundId: number): Promise<boolean>;
+    /**
+     * Get the ID of the latest round
+     * @returns The ID of the latest round or -1 if no rounds exist
+     */
+    getLatestRoundId(): Promise<number>;
+    /**
+     * Get comprehensive information about a specific round
+     * @param roundId The ID of the round to get information for
+     * @returns An object containing all information about the specified round
+     */
+    getRoundInfo(roundId: number): Promise<{
+        roundId: number;
+        config: RoundConfig;
+        raisedFunds: number;
+        participants: number;
+        isActive: boolean;
+    }>;
+    getUserTotalContribution(user: string): Promise<{
+        totalFundAmount: number;
+        totalTokenAllocation: number;
+    }>;
+    getTransactionStatus(txHash: string, maxRetries?: number): Promise<{
+        hash: string;
+        status: boolean | null;
+        confirmations: number;
+        isCompleted: boolean;
+        attempts: number;
+    }>;
+    getContractAddress(): string;
+    getAllEvents(fromBlock: number, toBlock: number): Promise<ParsedSeedRoundFundraiserEventRaw[]>;
+    streamEvents(fromBlock: number, onEvent: (event: ParsedSeedRoundFundraiserEvent) => Promise<void>, saveLatestBlock: (blockNumber: number) => Promise<void>, batchSize?: number, sleepTime?: number): Promise<void>;
+    formatEventArgs: (event: ParsedSeedRoundFundraiserEventRaw) => ParsedSeedRoundFundraiserEvent;
+}

package/dist/SeedRoundFundraiser.js

@@ -0,0 +1,445 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedRoundFundraiserSDK = void 0;
+const ethers_1 = require("ethers");
+const SeedRoundFundraiser_json_1 = __importDefault(require("./abis/SeedRoundFundraiser.json"));
+const contracts_json_1 = __importDefault(require("./contracts.json"));
+const utils_1 = require("./utils");
+const whitelist_tokens_json_1 = __importDefault(require("./whitelist-tokens.json"));
+class SeedRoundFundraiserSDK {
+    constructor(rpcUrls, contractAddress) {
+        this.name = "SeedRoundFundraiser";
+        this.isBootstrapped = false;
+        this.PRICE_PRECISION = 1e18;
+        this.whitelistedTokensArray = [];
+        this.formatEventArgs = (event) => {
+            const { eventName, args } = event;
+            switch (eventName) {
+                case "TokenWhitelisted":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            token: args.token.toLowerCase(),
+                            price: Number(args.price) / this.PRICE_PRECISION,
+                        },
+                    };
+                case "TokenPriceUpdated":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            token: args.token.toLowerCase(),
+                            oldPrice: Number(args.oldPrice) / this.PRICE_PRECISION,
+                            newPrice: Number(args.newPrice) / this.PRICE_PRECISION,
+                        },
+                    };
+                case "TokenRemovedFromWhitelist":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            token: args.token.toLowerCase(),
+                        },
+                    };
+                case "RoundCreated":
+                case "RoundUpdated":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            roundId: Number(args.roundId),
+                            startTime: Number(args.startTime),
+                            endTime: Number(args.endTime),
+                            targetFund: Number(args.targetFund) / this.PRICE_PRECISION,
+                            totalAllocation: Number(args.totalAllocation),
+                            maxFundPerAccount: Number(args.maxFundPerAccount) / this.PRICE_PRECISION,
+                        },
+                    };
+                case "RoundEnded":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            roundId: Number(args.roundId),
+                            raisedFunds: Number(args.raisedFunds) / this.PRICE_PRECISION,
+                            participants: Number(args.participants),
+                        },
+                    };
+                case "Contribution":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            roundId: Number(args.roundId),
+                            contributor: args.contributor.toLowerCase(),
+                            token: args.token.toLowerCase(),
+                            amount: Number(args.amount),
+                            fundAmount: Number(args.fundAmount) / this.PRICE_PRECISION,
+                            tokenAllocation: Number(args.tokenAllocation),
+                        },
+                    };
+                case "TokensClaimed":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            roundId: Number(args.roundId),
+                            user: args.user.toLowerCase(),
+                            amount: Number(args.amount),
+                        },
+                    };
+                case "ProjectTokenUpdated":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            oldToken: args.oldToken.toLowerCase(),
+                            newToken: args.newToken.toLowerCase(),
+                        },
+                    };
+                case "ClaimingEnabledUpdated":
+                case "RefundEnabledUpdated":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            roundId: Number(args.roundId),
+                            enabled: args.enabled,
+                        },
+                    };
+                case "Refunded":
+                    return {
+                        ...event,
+                        args: {
+                            ...args,
+                            roundId: Number(args.roundId),
+                            user: args.user.toLowerCase(),
+                            token: args.token.toLowerCase(),
+                            amount: Number(args.amount),
+                        },
+                    };
+                default:
+                    return event;
+            }
+        };
+        // Convert single RPC to array if needed
+        const rpcArray = Array.isArray(rpcUrls) ? rpcUrls : [rpcUrls];
+        // Create providers for each RPC
+        this.providers = rpcArray.map((rpc) => new ethers_1.ethers.JsonRpcProvider(rpc));
+        // Get a random provider for initial setup
+        const initialProvider = (0, utils_1.getRandomProvider)(this.providers);
+        // Determine contract address based on RPC URL if not provided
+        this.contractAddress = (0, utils_1.resolveContractAddress)(rpcArray[0], this.name, contracts_json_1.default, contractAddress);
+        // Initialize contract with initial provider
+        this.contract = new ethers_1.ethers.Contract(this.contractAddress, SeedRoundFundraiser_json_1.default.abi, initialProvider);
+        // Determine network name from RPC URL
+        this.networkName = this.getNetworkNameFromRpc(rpcArray[0]);
+        // Import whitelisted tokens from JSON file
+        this.importWhitelistedTokens();
+    }
+    getNetworkNameFromRpc(rpcUrl) {
+        const rpcLower = rpcUrl.toLowerCase();
+        // Extract network name from RPC URL or use a default method
+        if (rpcLower.includes("sepolia.base")) {
+            return "base-sepolia";
+        }
+        else if (rpcLower.includes("sepolia")) {
+            return "sepolia";
+        }
+        else if (rpcLower.includes("mainnet")) {
+            return "mainnet";
+        }
+        else if (rpcLower.includes("localhost") ||
+            rpcLower.includes("127.0.0.1")) {
+            return "hardhat";
+        }
+        // Default to sepolia if can't determine
+        return "sepolia";
+    }
+    importWhitelistedTokens() {
+        try {
+            // Try to read the whitelist-tokens.json file
+            // Check if the network exists in the whitelist data
+            if (whitelist_tokens_json_1.default[this.networkName]) {
+                this.whitelistedTokensArray = whitelist_tokens_json_1.default[this.networkName].map((address) => address.toLowerCase());
+                console.log(`Imported ${this.whitelistedTokensArray.length} whitelisted tokens for ${this.networkName} network`);
+            }
+            else {
+                console.log(`No whitelisted tokens found for ${this.networkName} network`);
+            }
+        }
+        catch (error) {
+            console.error("Error importing whitelisted tokens:", error);
+        }
+    }
+    // Get whitelisted token info from the array
+    async getWhitelistedTokenInfo(tokenAddress) {
+        // Convert to lowercase for case-insensitive comparison
+        const normalizedAddress = tokenAddress.toLowerCase();
+        // Check if token is in the whitelisted array
+        if (!this.whitelistedTokensArray.includes(normalizedAddress)) {
+            return null;
+        }
+        // Get token info from contract
+        const tokenInfo = await this.getWhitelistedToken(normalizedAddress);
+        // Skip if not whitelisted in contract
+        if (!tokenInfo.isWhitelisted) {
+            return null;
+        }
+        let symbol = "ETH";
+        let decimals = 18;
+        // Get token symbol and decimals
+        if (normalizedAddress !== ethers_1.ethers.ZeroAddress) {
+            [symbol, decimals] = await Promise.all([
+                (0, utils_1.getTokenSymbol)(normalizedAddress, this.getRandomProvider()),
+                (0, utils_1.getTokenDecimals)(normalizedAddress, this.getRandomProvider()),
+            ]);
+        }
+        // Get latest active round to determine max contribution
+        const latestRoundId = await this.getLatestRoundId();
+        let maxTokenContribution = 0;
+        if (latestRoundId >= 0) {
+            const roundInfo = await this.getRound(latestRoundId);
+            if (roundInfo.exists && !roundInfo.ended) {
+                // Calculate max token contribution based on maxFundPerAccount and token price
+                // maxTokens = (maxFundPerAccount / tokenPrice) * 10^decimals
+                maxTokenContribution = roundInfo.maxFundPerAccount / tokenInfo.price;
+            }
+        }
+        return {
+            address: normalizedAddress,
+            isWhitelisted: tokenInfo.isWhitelisted,
+            price: tokenInfo.price,
+            symbol: symbol,
+            maxContribution: maxTokenContribution,
+            maxContributionRaw: Math.floor(maxTokenContribution * Math.pow(10, decimals)),
+            decimals: decimals,
+        };
+    }
+    // Get all whitelisted tokens info
+    async getAllWhitelistedTokensInfo() {
+        const results = [];
+        for (const tokenAddress of this.whitelistedTokensArray) {
+            const tokenInfo = await this.getWhitelistedTokenInfo(tokenAddress);
+            if (tokenInfo) {
+                results.push(tokenInfo);
+            }
+        }
+        return results;
+    }
+    getRandomProvider() {
+        return (0, utils_1.getRandomProvider)(this.providers);
+    }
+    getContractWithRandomProvider() {
+        return new ethers_1.ethers.Contract(this.contractAddress, SeedRoundFundraiser_json_1.default.abi, this.getRandomProvider());
+    }
+    async bootstrap() {
+        if (this.isBootstrapped) {
+            return;
+        }
+        // Check health of all RPCs and remove inactive ones
+        const healthChecks = await Promise.all(this.providers.map((provider, index) => (0, utils_1.checkRpcHealth)(provider, index)));
+        // Filter out inactive providers
+        this.providers = this.providers.filter((_, index) => healthChecks[index]);
+        if (this.providers.length === 0) {
+            throw new Error("No active RPC providers available");
+        }
+        this.isBootstrapped = true;
+    }
+    async signAndSendTransaction(tx, wallet, callbacks = {}) {
+        return (0, utils_1.signAndSendTransaction)(tx, wallet, () => this.getRandomProvider(), callbacks, this.contract);
+    }
+    // Transaction builders
+    async buildAddWhitelistedTokenTx(token, price) {
+        const priceBigInt = BigInt(Math.floor(price * this.PRICE_PRECISION));
+        return await this.contract.addWhitelistedToken.populateTransaction(token, priceBigInt);
+    }
+    async buildUpdateTokenPriceTx(token, newPrice) {
+        const priceBigInt = BigInt(Math.floor(newPrice * this.PRICE_PRECISION));
+        return await this.contract.updateTokenPrice.populateTransaction(token, priceBigInt);
+    }
+    async buildRemoveWhitelistedTokenTx(token) {
+        return await this.contract.removeWhitelistedToken.populateTransaction(token);
+    }
+    async buildCreateRoundTx(startTime, endTime, targetFund, totalAllocation, maxFundPerAccount) {
+        const targetFundBigInt = BigInt(Math.floor(targetFund * this.PRICE_PRECISION));
+        const maxFundPerAccountBigInt = BigInt(Math.floor(maxFundPerAccount * this.PRICE_PRECISION));
+        const decimals = await (0, utils_1.getTokenDecimals)(await this.getProjectToken(), this.getRandomProvider());
+        const totalAllocationBigInt = BigInt(Math.floor(totalAllocation * Math.pow(10, decimals)));
+        return await this.contract.createRound.populateTransaction(startTime, endTime, targetFundBigInt, totalAllocationBigInt, maxFundPerAccountBigInt);
+    }
+    async buildUpdateRoundTx(roundId, startTime, endTime, targetFund, totalAllocation, maxFundPerAccount) {
+        const targetFundBigInt = BigInt(Math.floor(targetFund * this.PRICE_PRECISION));
+        const maxFundPerAccountBigInt = BigInt(Math.floor(maxFundPerAccount * this.PRICE_PRECISION));
+        return await this.contract.updateRound.populateTransaction(roundId, startTime, endTime, targetFundBigInt, totalAllocation, maxFundPerAccountBigInt);
+    }
+    async buildEndRoundTx(roundId) {
+        return await this.contract.endRound.populateTransaction(roundId);
+    }
+    async buildSetClaimingEnabledTx(roundId, enabled) {
+        return await this.contract.setClaimingEnabled.populateTransaction(roundId, enabled);
+    }
+    async buildSetRefundEnabledTx(roundId, enabled) {
+        return await this.contract.setRefundEnabled.populateTransaction(roundId, enabled);
+    }
+    async buildContributeTx(roundId, token, amount) {
+        let decimals = 18;
+        if (token !== ethers_1.ethers.ZeroAddress) {
+            decimals = await (0, utils_1.getTokenDecimals)(token, this.getRandomProvider());
+        }
+        const amountWei = ethers_1.ethers.parseUnits(amount.toString(), decimals);
+        const tx = await this.contract.contribute.populateTransaction(roundId, token, token === ethers_1.ethers.ZeroAddress ? 0 : amountWei);
+        if (token === ethers_1.ethers.ZeroAddress) {
+            tx.value = amountWei;
+        }
+        return tx;
+    }
+    async buildClaimTokensTx() {
+        return await this.contract.claimTokens.populateTransaction();
+    }
+    async buildRefundTx() {
+        return await this.contract.refund.populateTransaction();
+    }
+    async buildWithdrawFundsTx(token, amount) {
+        const decimals = await (0, utils_1.getTokenDecimals)(token, this.getRandomProvider());
+        const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+        return await this.contract.withdrawFunds.populateTransaction(token, amountBigInt);
+    }
+    async buildClaimTokensByRoundIdTx(roundId) {
+        return await this.contract.claimTokensByRoundId.populateTransaction(roundId);
+    }
+    // Read methods
+    async getWhitelistedToken(token) {
+        const result = await this.contract.whitelistedTokens(token);
+        return {
+            isWhitelisted: result.isWhitelisted,
+            price: Number(result.price) / this.PRICE_PRECISION,
+        };
+    }
+    async getRound(roundId) {
+        const result = await this.contract.rounds(roundId);
+        return {
+            startTime: Number(result.startTime),
+            endTime: Number(result.endTime),
+            targetFund: Number(result.targetFund) / this.PRICE_PRECISION,
+            totalAllocation: Number(result.totalAllocation),
+            maxFundPerAccount: Number(result.maxFundPerAccount) / this.PRICE_PRECISION,
+            exists: result.exists,
+            ended: result.ended,
+            claimingEnabled: result.claimingEnabled,
+            refundEnabled: result.refundEnabled,
+        };
+    }
+    async getUserContribution(roundId, user) {
+        const result = await this.contract.userContributions(roundId, user);
+        return {
+            fundAmount: Number(result.fundAmount) / this.PRICE_PRECISION,
+            tokenAllocation: Number(result.tokenAllocation),
+            claimed: result.claimed,
+            refunded: result.refunded,
+            contributedToken: result.contributedToken,
+            contributedAmount: Number(result.contributedAmount),
+        };
+    }
+    async getRoundRaisedFunds(roundId) {
+        const result = await this.contract.roundRaisedFunds(roundId);
+        return Number(result) / this.PRICE_PRECISION;
+    }
+    async getRoundParticipants(roundId) {
+        const result = await this.contract.roundParticipants(roundId);
+        return Number(result);
+    }
+    async getUserParticipatedRound(user) {
+        const result = await this.contract.userParticipatedRound(user);
+        return Number(result);
+    }
+    async getProjectToken() {
+        return await this.contract.projectToken();
+    }
+    async getTotalRounds() {
+        const result = await this.contract.totalRounds();
+        return Number(result);
+    }
+    async getTotalRaisedFunds() {
+        const result = await this.contract.totalRaisedFunds();
+        return Number(result) / this.PRICE_PRECISION;
+    }
+    async isRoundActive(roundId) {
+        return await this.contract.isRoundActive(roundId);
+    }
+    /**
+     * Get the ID of the latest round
+     * @returns The ID of the latest round or -1 if no rounds exist
+     */
+    async getLatestRoundId() {
+        // Get total number of rounds
+        const totalRounds = await this.getTotalRounds();
+        // If no rounds exist, return -1
+        if (totalRounds === 0) {
+            return -1;
+        }
+        // Latest round ID (0-indexed, so subtract 1)
+        return totalRounds - 1;
+    }
+    /**
+     * Get comprehensive information about a specific round
+     * @param roundId The ID of the round to get information for
+     * @returns An object containing all information about the specified round
+     */
+    async getRoundInfo(roundId) {
+        // Get total number of rounds
+        const totalRounds = await this.getTotalRounds();
+        // Check if roundId is valid
+        if (roundId < 0 || roundId >= totalRounds) {
+            throw new Error(`Invalid round ID: ${roundId}`);
+        }
+        // Get round configuration
+        const roundConfig = await this.getRound(roundId);
+        // Get additional information
+        const raisedFunds = await this.getRoundRaisedFunds(roundId);
+        const participants = await this.getRoundParticipants(roundId);
+        const isActive = await this.isRoundActive(roundId);
+        return {
+            roundId,
+            config: roundConfig,
+            raisedFunds,
+            participants,
+            isActive,
+        };
+    }
+    async getUserTotalContribution(user) {
+        const result = await this.contract.getUserTotalContribution(user);
+        return {
+            totalFundAmount: Number(result.totalFundAmount) / this.PRICE_PRECISION,
+            totalTokenAllocation: Number(result.totalTokenAllocation),
+        };
+    }
+    async getTransactionStatus(txHash, maxRetries = 10) {
+        return await (0, utils_1.getTransactionStatus)(this.getRandomProvider(), txHash, maxRetries);
+    }
+    getContractAddress() {
+        return this.contractAddress;
+    }
+    async getAllEvents(fromBlock, toBlock) {
+        await this.bootstrap();
+        return (0, utils_1.getAllEvents)(this.contract, () => this.getRandomProvider(), () => this.getContractWithRandomProvider(), fromBlock, toBlock);
+    }
+    async streamEvents(fromBlock, onEvent, saveLatestBlock, batchSize = 1000, sleepTime = 5000) {
+        await this.bootstrap();
+        return (0, utils_1.streamEvents)({
+            getProvider: () => this.getRandomProvider(),
+            getAllEvents: (fromBlock, toBlock) => this.getAllEvents(fromBlock, toBlock),
+            formatEvent: (event) => this.formatEventArgs(event),
+            onEvent,
+            saveLatestBlock,
+            fromBlock,
+            batchSize,
+            sleepTime,
+        });
+    }
+}
+exports.SeedRoundFundraiserSDK = SeedRoundFundraiserSDK;