aiia-vault-sdk 1.0.1

package/SeedRoundFundraiser.ts

@@ -0,0 +1,742 @@
+import { ethers } from "ethers";
+import { SeedRoundFundraiser } from "./contracts/SeedRoundFundraiser";
+import SeedRoundFundraiserABI from "./abis/SeedRoundFundraiser.json";
+import contracts from "./contracts.json";
+import {
+  ParsedSeedRoundFundraiserEvent,
+  ParsedSeedRoundFundraiserEventRaw,
+} from "./types";
+import { type SendTransactionMutateAsync } from "@wagmi/core/query";
+import { Config } from "@wagmi/core/dist/types/createConfig";
+import {
+  getRandomProvider,
+  checkRpcHealth,
+  getTransactionStatus,
+  getTokenDecimals,
+  getTokenSymbol,
+  resolveContractAddress,
+  streamEvents,
+  getAllEvents,
+  signAndSendTransaction,
+} from "./utils";
+import whitelistData from "./whitelist-tokens.json";
+
+export interface WhitelistedToken {
+  isWhitelisted: boolean;
+  price: number; // Price in USD with PRICE_PRECISION decimals
+}
+
+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; // In USD with PRICE_PRECISION decimals
+  totalAllocation: number; // Total tokens to be allocated
+  maxFundPerAccount: number; // Max fund per account in USD with PRICE_PRECISION decimals
+  exists: boolean;
+  ended: boolean;
+  claimingEnabled: boolean; // Flag to control token claiming for this round
+  refundEnabled: boolean; // Flag to control refunds for this round
+}
+
+export interface UserContribution {
+  fundAmount: number; // In USD with PRICE_PRECISION decimals
+  tokenAllocation: number; // Token allocation
+  claimed: boolean;
+  refunded: boolean; // Flag to track if user has been refunded
+  contributedToken: string; // The token address used for contribution
+  contributedAmount: number; // The actual token amount contributed
+}
+
+export class SeedRoundFundraiserSDK {
+  name = "SeedRoundFundraiser";
+  private contract: SeedRoundFundraiser;
+  private providers: ethers.Provider[];
+  private contractAddress: string;
+  private isBootstrapped: boolean = false;
+  private PRICE_PRECISION = 1e18;
+  private whitelistedTokensArray: string[] = [];
+  private networkName: string;
+
+  constructor(rpcUrls: string | string[], contractAddress?: string) {
+    // 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.JsonRpcProvider(rpc));
+
+    // Get a random provider for initial setup
+    const initialProvider = getRandomProvider(this.providers);
+
+    // Determine contract address based on RPC URL if not provided
+    this.contractAddress = resolveContractAddress(
+      rpcArray[0],
+      this.name,
+      contracts,
+      contractAddress
+    );
+
+    // Initialize contract with initial provider
+    this.contract = new ethers.Contract(
+      this.contractAddress,
+      SeedRoundFundraiserABI.abi,
+      initialProvider
+    ) as unknown as SeedRoundFundraiser;
+
+    // Determine network name from RPC URL
+    this.networkName = this.getNetworkNameFromRpc(rpcArray[0]);
+
+    // Import whitelisted tokens from JSON file
+    this.importWhitelistedTokens();
+  }
+
+  private getNetworkNameFromRpc(rpcUrl: string): string {
+    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";
+  }
+
+  private importWhitelistedTokens() {
+    try {
+      // Try to read the whitelist-tokens.json file
+
+      // Check if the network exists in the whitelist data
+      if ((whitelistData as any)[this.networkName]) {
+        this.whitelistedTokensArray = (whitelistData as any)[
+          this.networkName
+        ].map((address: string) => 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: string
+  ): Promise<WhitelistedTokenInfo | null> {
+    // 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.ZeroAddress) {
+      [symbol, decimals] = await Promise.all([
+        getTokenSymbol(normalizedAddress, this.getRandomProvider()),
+        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(): Promise<WhitelistedTokenInfo[]> {
+    const results: WhitelistedTokenInfo[] = [];
+
+    for (const tokenAddress of this.whitelistedTokensArray) {
+      const tokenInfo = await this.getWhitelistedTokenInfo(tokenAddress);
+      if (tokenInfo) {
+        results.push(tokenInfo);
+      }
+    }
+
+    return results;
+  }
+
+  private getRandomProvider(): ethers.Provider {
+    return getRandomProvider(this.providers);
+  }
+
+  private getContractWithRandomProvider(): SeedRoundFundraiser {
+    return new ethers.Contract(
+      this.contractAddress,
+      SeedRoundFundraiserABI.abi,
+      this.getRandomProvider()
+    ) as unknown as SeedRoundFundraiser;
+  }
+
+  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) => 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: 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;
+    };
+  }> {
+    return signAndSendTransaction(
+      tx,
+      wallet,
+      () => this.getRandomProvider(),
+      callbacks,
+      this.contract
+    );
+  }
+
+  // Transaction builders
+  async buildAddWhitelistedTokenTx(token: string, price: number) {
+    const priceBigInt = BigInt(Math.floor(price * this.PRICE_PRECISION));
+    return await this.contract.addWhitelistedToken.populateTransaction(
+      token,
+      priceBigInt
+    );
+  }
+
+  async buildUpdateTokenPriceTx(token: string, newPrice: number) {
+    const priceBigInt = BigInt(Math.floor(newPrice * this.PRICE_PRECISION));
+    return await this.contract.updateTokenPrice.populateTransaction(
+      token,
+      priceBigInt
+    );
+  }
+
+  async buildRemoveWhitelistedTokenTx(token: string) {
+    return await this.contract.removeWhitelistedToken.populateTransaction(
+      token
+    );
+  }
+
+  async buildCreateRoundTx(
+    startTime: number,
+    endTime: number,
+    targetFund: number,
+    totalAllocation: number,
+    maxFundPerAccount: number
+  ) {
+    const targetFundBigInt = BigInt(
+      Math.floor(targetFund * this.PRICE_PRECISION)
+    );
+    const maxFundPerAccountBigInt = BigInt(
+      Math.floor(maxFundPerAccount * this.PRICE_PRECISION)
+    );
+    const decimals = await 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: number,
+    startTime: number,
+    endTime: number,
+    targetFund: number,
+    totalAllocation: number,
+    maxFundPerAccount: number
+  ) {
+    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: number) {
+    return await this.contract.endRound.populateTransaction(roundId);
+  }
+
+  async buildSetClaimingEnabledTx(roundId: number, enabled: boolean) {
+    return await this.contract.setClaimingEnabled.populateTransaction(
+      roundId,
+      enabled
+    );
+  }
+
+  async buildSetRefundEnabledTx(roundId: number, enabled: boolean) {
+    return await this.contract.setRefundEnabled.populateTransaction(
+      roundId,
+      enabled
+    );
+  }
+
+  async buildContributeTx(roundId: number, token: string, amount: number) {
+    let decimals = 18;
+
+    if (token !== ethers.ZeroAddress) {
+      decimals = await getTokenDecimals(token, this.getRandomProvider());
+    }
+
+    const amountWei = ethers.parseUnits(amount.toString(), decimals);
+
+    const tx = await this.contract.contribute.populateTransaction(
+      roundId,
+      token,
+      token === ethers.ZeroAddress ? 0 : amountWei
+    );
+
+    if (token === 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: string, amount: number) {
+    const decimals = await 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: number) {
+    return await this.contract.claimTokensByRoundId.populateTransaction(
+      roundId
+    );
+  }
+
+  // Read methods
+  async getWhitelistedToken(token: string): Promise<WhitelistedToken> {
+    const result = await this.contract.whitelistedTokens(token);
+    return {
+      isWhitelisted: result.isWhitelisted,
+      price: Number(result.price) / this.PRICE_PRECISION,
+    };
+  }
+
+  async getRound(roundId: number): Promise<RoundConfig> {
+    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: number,
+    user: string
+  ): Promise<UserContribution> {
+    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: number): Promise<number> {
+    const result = await this.contract.roundRaisedFunds(roundId);
+    return Number(result) / this.PRICE_PRECISION;
+  }
+
+  async getRoundParticipants(roundId: number): Promise<number> {
+    const result = await this.contract.roundParticipants(roundId);
+    return Number(result);
+  }
+
+  async getUserParticipatedRound(user: string): Promise<number> {
+    const result = await this.contract.userParticipatedRound(user);
+    return Number(result);
+  }
+
+  async getProjectToken(): Promise<string> {
+    return await this.contract.projectToken();
+  }
+
+  async getTotalRounds(): Promise<number> {
+    const result = await this.contract.totalRounds();
+    return Number(result);
+  }
+
+  async getTotalRaisedFunds(): Promise<number> {
+    const result = await this.contract.totalRaisedFunds();
+    return Number(result) / this.PRICE_PRECISION;
+  }
+
+  async isRoundActive(roundId: number): Promise<boolean> {
+    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(): Promise<number> {
+    // 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: number): Promise<{
+    roundId: number;
+    config: RoundConfig;
+    raisedFunds: number;
+    participants: number;
+    isActive: boolean;
+  }> {
+    // 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: string): Promise<{
+    totalFundAmount: number;
+    totalTokenAllocation: number;
+  }> {
+    const result = await this.contract.getUserTotalContribution(user);
+    return {
+      totalFundAmount: Number(result.totalFundAmount) / this.PRICE_PRECISION,
+      totalTokenAllocation: Number(result.totalTokenAllocation),
+    };
+  }
+
+  async getTransactionStatus(
+    txHash: string,
+    maxRetries: number = 10
+  ): Promise<{
+    hash: string;
+    status: boolean | null;
+    confirmations: number;
+    isCompleted: boolean;
+    attempts: number;
+  }> {
+    return await getTransactionStatus(
+      this.getRandomProvider(),
+      txHash,
+      maxRetries
+    );
+  }
+
+  getContractAddress(): string {
+    return this.contractAddress;
+  }
+
+  async getAllEvents(
+    fromBlock: number,
+    toBlock: number
+  ): Promise<ParsedSeedRoundFundraiserEventRaw[]> {
+    await this.bootstrap();
+    return getAllEvents<ParsedSeedRoundFundraiserEventRaw, SeedRoundFundraiser>(
+      this.contract,
+      () => this.getRandomProvider(),
+      () => this.getContractWithRandomProvider(),
+      fromBlock,
+      toBlock
+    );
+  }
+
+  async streamEvents(
+    fromBlock: number,
+    onEvent: (event: ParsedSeedRoundFundraiserEvent) => Promise<void>,
+    saveLatestBlock: (blockNumber: number) => Promise<void>,
+    batchSize: number = 1000,
+    sleepTime: number = 5000
+  ) {
+    await this.bootstrap();
+
+    return streamEvents<
+      ParsedSeedRoundFundraiserEventRaw,
+      ParsedSeedRoundFundraiserEvent
+    >({
+      getProvider: () => this.getRandomProvider(),
+      getAllEvents: (fromBlock, toBlock) =>
+        this.getAllEvents(fromBlock, toBlock),
+      formatEvent: (event) => this.formatEventArgs(event),
+      onEvent,
+      saveLatestBlock,
+      fromBlock,
+      batchSize,
+      sleepTime,
+    });
+  }
+
+  formatEventArgs = (
+    event: ParsedSeedRoundFundraiserEventRaw
+  ): ParsedSeedRoundFundraiserEvent => {
+    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;
+    }
+  };
+}