aiia-vault-sdk 1.0.1

package/utils.ts

@@ -0,0 +1,576 @@
+import { ethers } from "ethers";
+
+// Debug log prefixes with colors
+export const LOG_PREFIXES = {
+  INFO: "\x1b[36m[STREAM-INFO]\x1b[0m", // Cyan
+  BLOCK: "\x1b[33m[STREAM-BLOCK]\x1b[0m", // Yellow
+  EVENT: "\x1b[32m[STREAM-EVENT]\x1b[0m", // Green
+  ERROR: "\x1b[31m[STREAM-ERROR]\x1b[0m", // Red
+  SAVE: "\x1b[35m[STREAM-SAVE]\x1b[0m", // Magenta
+  DEBUG: "\x1b[34m[STREAM-DEBUG]\x1b[0m", // Blue
+};
+
+export const sleep = async (ms: number): Promise<void> => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+export const getRandomProvider = (
+  providers: ethers.Provider[]
+): ethers.Provider => {
+  return providers[Math.floor(Math.random() * providers.length)];
+};
+
+export const checkRpcHealth = async (
+  provider: ethers.Provider,
+  index = 0
+): Promise<boolean> => {
+  try {
+    // Try to get the latest block number with a timeout of 5 seconds
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("RPC request timeout")), 5000);
+    });
+
+    await Promise.race([provider.getBlockNumber(), timeoutPromise]);
+    return true;
+  } catch (error) {
+    console.error(
+      `${LOG_PREFIXES.ERROR} RPC health check failed:`,
+      error,
+      index
+    );
+    return false;
+  }
+};
+
+export const getTransactionStatus = async (
+  provider: ethers.Provider,
+  txHash: string,
+  maxRetries: number = 10
+): Promise<{
+  hash: string;
+  status: boolean | null;
+  confirmations: number;
+  isCompleted: boolean;
+  attempts: number;
+}> => {
+  let attempts = 0;
+  let waitTime = 1000; // Start with 1 second
+
+  while (attempts < maxRetries) {
+    try {
+      const receipt = await provider.getTransactionReceipt(txHash);
+
+      if (!receipt) {
+        attempts++;
+        if (attempts === maxRetries) {
+          return {
+            hash: txHash,
+            status: null,
+            confirmations: 0,
+            isCompleted: false,
+            attempts,
+          };
+        }
+        // Exponential backoff: 1s, 2s, 4s, 8s, 16s
+        await sleep(waitTime);
+        waitTime *= 2;
+        continue;
+      }
+
+      const confirmations = Number((await receipt.confirmations()) || 0);
+
+      return {
+        hash: receipt.hash,
+        status: receipt.status === 1,
+        confirmations,
+        isCompleted: true,
+        attempts: attempts + 1,
+      };
+    } catch (error: any) {
+      throw new Error(`Failed to get transaction status: ${error.message}`);
+    }
+  }
+
+  // This should never be reached due to the return in the if(!receipt) block
+  throw new Error("Failed to get transaction status after maximum retries");
+};
+
+export const getTokenDecimals = async (
+  tokenAddress: string,
+  provider: ethers.Provider
+): Promise<number> => {
+  const tokenContract = new ethers.Contract(
+    tokenAddress,
+    ["function decimals() view returns (uint8)"],
+    provider
+  );
+  return Number(await tokenContract.decimals());
+};
+
+export const getTokenSymbol = async (
+  tokenAddress: string,
+  provider: ethers.Provider
+): Promise<string> => {
+  const tokenContract = new ethers.Contract(
+    tokenAddress,
+    ["function symbol() view returns (string)"],
+    provider
+  );
+  return await tokenContract.symbol();
+};
+
+export const getTokenAllowance = async (
+  tokenAddress: string,
+  owner: string,
+  spender: string,
+  provider: ethers.Provider
+): Promise<bigint> => {
+  // If the token is ETH (zero address), return max bigint value
+  if (
+    tokenAddress === ethers.ZeroAddress ||
+    tokenAddress.toLowerCase() === ethers.ZeroAddress
+  ) {
+    // Max bigint value (2^256 - 1)
+    return BigInt(
+      "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+    );
+  }
+
+  const tokenContract = new ethers.Contract(
+    tokenAddress,
+    [
+      "function allowance(address owner, address spender) view returns (uint256)",
+    ],
+    provider
+  );
+  return await tokenContract.allowance(owner, spender);
+};
+
+export const buildApproveERC20Tx = async (
+  tokenAddress: string,
+  spender: string,
+  amount: bigint,
+  provider: ethers.Provider
+) => {
+  const tokenContract = new ethers.Contract(
+    tokenAddress,
+    ["function approve(address spender, uint256 amount) returns (bool)"],
+    provider
+  );
+  return await tokenContract.approve.populateTransaction(spender, amount);
+};
+
+export const getRewardWeight = (
+  duration: number,
+  configs: Array<{ weight: number; duration: number }>
+): number => {
+  let maxWeight = 0;
+  // Sort configs by duration to ensure correct weight calculation
+  const sortedConfigs = [...configs].sort((a, b) => a.duration - b.duration);
+
+  for (const config of sortedConfigs) {
+    if (duration >= config.duration) {
+      maxWeight = config.weight;
+    }
+  }
+  return maxWeight;
+};
+
+export const resolveContractAddress = (
+  rpcUrl: string,
+  contractName: string,
+  contracts: any,
+  providedAddress?: string
+): string => {
+  if (providedAddress) {
+    return providedAddress;
+  }
+
+  const rpcLower = rpcUrl.toLowerCase();
+  if (
+    ["testnet", "sepolia", "goerli"].some((network) =>
+      rpcLower.includes(network)
+    )
+  ) {
+    if (rpcLower.includes("sepolia.base")) {
+      return contracts?.["base-sepolia"]?.[contractName];
+    } else if (rpcLower.includes("sepolia")) {
+      return contracts?.sepolia?.[contractName];
+    } else if (rpcLower.includes("goerli")) {
+      return contracts?.goerli?.[contractName];
+    }
+    throw new Error("Unsupported testnet network");
+  }
+  return contracts?.mainnet?.[contractName];
+};
+
+// Define a base interface for blockchain events
+export interface BaseEventRaw {
+  eventName: string;
+  blockNumber: number;
+  transactionHash: string;
+  args: Record<string, any>;
+  timestamp: number | null;
+}
+
+/**
+ * Generic function to get all events from a contract within a block range
+ * @param contract The ethers contract instance
+ * @param getRandomProvider Function to get a random provider
+ * @param fromBlock Starting block number
+ * @param toBlock Ending block number
+ * @returns Array of parsed events with timestamps
+ */
+export const getAllEvents = async <TEventRaw extends BaseEventRaw, TContract extends ethers.BaseContract>(
+  contract: TContract,
+  getRandomProvider: () => ethers.Provider,
+  getContractWithRandomProvider: () => TContract,
+  fromBlock: number,
+  toBlock: number
+): Promise<TEventRaw[]> => {
+  // Get all event names from the contract interface
+  const eventNames: string[] = [];
+
+  contract.interface.forEachEvent((event) => {
+    eventNames.push(event.name);
+  });
+
+  // Create filter for each event type
+  const eventPromises = eventNames.map(async (eventName) => {
+    // Create a new contract instance with a random provider for each query
+    const randomContract = getContractWithRandomProvider();
+    const filter = (randomContract.filters as any)[eventName]();
+    const events = await randomContract.queryFilter(
+      filter,
+      fromBlock,
+      toBlock
+    );
+
+    // Parse each event into a more readable format
+    return events.map((event) => {
+      const parsedLog = contract.interface.parseLog({
+        topics: event.topics,
+        data: event.data,
+      });
+
+      return {
+        eventName,
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        args: parsedLog?.args.toObject(),
+        timestamp: null, // Will be populated below
+      } as TEventRaw;
+    });
+  });
+
+  // Wait for all event queries to complete
+  const allEvents = (await Promise.all(eventPromises)).flat();
+
+  // Sort events by block number
+  allEvents.sort((a, b) => a.blockNumber - b.blockNumber);
+
+  // Get block timestamps in batches to improve performance
+  const uniqueBlocks = [...new Set(allEvents.map((e) => e.blockNumber))];
+  const blockPromises = uniqueBlocks.map((blockNumber) =>
+    getRandomProvider().getBlock(blockNumber)
+  );
+  const blocks = await Promise.all(blockPromises);
+
+  // Create a map of block numbers to timestamps
+  const blockTimestamps = new Map(
+    blocks.map((block) => [block!.number, block!.timestamp])
+  );
+
+  // Add timestamps to events
+  return allEvents.map(
+    (event) =>
+      ({
+        eventName: event.eventName,
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        args: Object.fromEntries(
+          Object.entries(event.args || {}).filter(([key]) =>
+            isNaN(Number(key))
+          )
+        ),
+        timestamp: blockTimestamps.get(event.blockNumber) ?? null,
+      } as TEventRaw)
+  );
+};
+
+/**
+ * Generic function to stream blockchain events
+ * @param getProvider Function to get a provider
+ * @param getAllEvents Function to get events for a block range
+ * @param formatEvent Function to format raw events
+ * @param onEvent Callback for each processed event
+ * @param saveLatestBlock Function to save the latest processed block
+ * @param fromBlock Starting block number
+ * @param batchSize Number of blocks to process in each batch
+ * @param sleepTime Time to wait between iterations when caught up
+ */
+export const streamEvents = async <TRawEvent, TFormattedEvent>({
+  getProvider,
+  getAllEvents,
+  formatEvent,
+  onEvent,
+  saveLatestBlock,
+  fromBlock,
+  batchSize = 1000,
+  sleepTime = 5000,
+}: {
+  getProvider: () => ethers.Provider;
+  getAllEvents: (fromBlock: number, toBlock: number) => Promise<TRawEvent[]>;
+  formatEvent: (event: TRawEvent) => TFormattedEvent;
+  onEvent: (event: TFormattedEvent) => Promise<void>;
+  saveLatestBlock: (blockNumber: number) => Promise<void>;
+  fromBlock: number;
+  batchSize?: number;
+  sleepTime?: number;
+}): Promise<void> => {
+  const debugEnabled = process.env.DEBUG_STREAM_EVENTS === "1";
+  let currentBlock = fromBlock;
+
+  if (debugEnabled) {
+    console.log(`${LOG_PREFIXES.INFO} StreamEvents Debug Mode Enabled`);
+    console.log(`${LOG_PREFIXES.INFO} Initial fromBlock: ${currentBlock}`);
+    console.log(`${LOG_PREFIXES.INFO} Batch size: ${batchSize}`);
+    console.log(`${LOG_PREFIXES.INFO} Sleep time: ${sleepTime}ms`);
+  }
+
+  while (true) {
+    try {
+      // Get the latest block number
+      const latestBlock = await getProvider().getBlockNumber();
+      if (debugEnabled) {
+        console.log(`${LOG_PREFIXES.BLOCK} Latest block: ${latestBlock}`);
+      }
+
+      // Calculate toBlock as min(fromBlock + batchSize, latestBlock)
+      const toBlock = Math.min(currentBlock + batchSize, latestBlock);
+      if (debugEnabled) {
+        console.log(
+          `${LOG_PREFIXES.BLOCK} Processing blocks from ${currentBlock} to ${toBlock}`
+        );
+      }
+
+      // If we've caught up to the latest block, wait before next iteration
+      if (currentBlock >= latestBlock) {
+        if (debugEnabled) {
+          console.log(
+            `${LOG_PREFIXES.DEBUG} Caught up to latest block, waiting ${sleepTime}ms...`
+          );
+        }
+        await sleep(sleepTime);
+        continue;
+      }
+
+      // Get events for the current batch
+      const events = await getAllEvents(currentBlock, toBlock);
+      if (debugEnabled && events.length > 0) {
+        const eventTypes = events.reduce((acc, event) => {
+          const eventName = (event as any).eventName || "Unknown";
+          acc[eventName] = (acc[eventName] || 0) + 1;
+          return acc;
+        }, {} as Record<string, number>);
+
+        console.log(`${LOG_PREFIXES.EVENT} Found ${events.length} events:`);
+        Object.entries(eventTypes).forEach(([eventName, count]) => {
+          console.log(`${LOG_PREFIXES.EVENT} - ${eventName}: ${count}`);
+        });
+      }
+
+      // Process each event
+      for (const event of events) {
+        if (debugEnabled) {
+          console.log(
+            `${LOG_PREFIXES.EVENT} Processing: ${
+              (event as any).eventName || "Event"
+            }`
+          );
+        }
+        await onEvent(formatEvent(event));
+      }
+
+      // Save the latest processed block
+      await saveLatestBlock(toBlock);
+      if (debugEnabled) {
+        console.log(`${LOG_PREFIXES.SAVE} Saved latest block: ${toBlock}`);
+      }
+
+      // Update fromBlock for next iteration
+      currentBlock = toBlock + 1;
+    } catch (error) {
+      if (debugEnabled) {
+        console.error(`${LOG_PREFIXES.ERROR} Error in streamEvents:`, error);
+        console.error(
+          `${LOG_PREFIXES.ERROR} Stack trace:`,
+          error instanceof Error ? error.stack : ""
+        );
+      } else {
+        console.error(`${LOG_PREFIXES.ERROR} Error in streamEvents:`, error);
+      }
+      await sleep(1000); // Wait before retrying on error
+    }
+  }
+};
+
+/**
+ * Generic function to sign and send a transaction
+ * @param tx The transaction to send
+ * @param wallet The wallet or sendTransaction function to use
+ * @param getRandomProvider Function to get a random provider
+ * @param contract Optional contract instance
+ * @param callbacks Optional callbacks for transaction events
+ * @returns Transaction result with status
+ */
+export const signAndSendTransaction = async (
+  tx: ethers.ContractTransaction,
+  wallet: ethers.Wallet | any,
+  getRandomProvider: () => ethers.Provider,
+  {
+    onSubmit,
+    onFinally,
+    onError,
+  }: {
+    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>;
+  } = {},
+  contract?: ethers.BaseContract
+): Promise<{
+  transaction: {
+    hash: string;
+  };
+  status: {
+    status: boolean | null;
+    confirmations: number;
+    isCompleted: boolean;
+    attempts: number;
+  };
+}> => {
+  try {
+    // Prepare the transaction
+    const transaction = {
+      ...tx,
+    };
+
+    // Sign and send the transaction
+    let txHash: string;
+
+    // Check if wallet is an object with the expected Wallet methods
+    if (
+      typeof wallet === "object" &&
+      wallet !== null &&
+      "sendTransaction" in wallet
+    ) {
+      const connectedWallet = wallet.connect(getRandomProvider());
+      const signedTx = await connectedWallet.sendTransaction(transaction);
+      txHash = signedTx.hash;
+    } else {
+      // Assume it's a SendTransactionMutateAsync function
+      txHash = await wallet(transaction);
+    }
+
+    // Call onSubmit callback if provided
+    if (onSubmit) {
+      await onSubmit(txHash);
+    }
+
+    // Check transaction status
+    const status = await getTransactionStatus(getRandomProvider(), txHash);
+
+    // Add new error handling
+    if (status.status === null) {
+      throw new Error(
+        "Transaction may not be minted on-chain yet or has failed. Please check the blockchain explorer."
+      );
+    }
+
+    if (status.status === false) {
+      throw new Error(
+        "Transaction failed. Please check the blockchain explorer for details."
+      );
+    }
+
+    // Call onFinally callback if provided
+    if (onFinally) {
+      await onFinally({ ...status, txHash });
+    }
+
+    return {
+      transaction: {
+        hash: txHash,
+      },
+      status,
+    };
+  } catch (error: any) {
+    // Try to decode the error if contract is provided
+    if (contract && error) {
+      try {
+        // Handle custom errors from estimateGas or other pre-transaction errors
+        if (error.code === "CALL_EXCEPTION" && error.data) {
+          // The error.data contains the custom error selector (first 4 bytes of the error signature hash)
+          const errorSelector = error.data;
+
+          // Try to find matching error in the contract interface
+          for (const errorFragment of Object.values(
+            contract.interface.fragments
+          ).filter((fragment) => fragment.type === "error")) {
+            if ("name" in errorFragment) {
+              // Calculate the selector for this error
+              const errorDef = contract.interface.getError(
+                errorFragment.name as string
+              );
+              if (errorDef && errorDef.selector) {
+                const calculatedSelector = errorDef.selector;
+
+                if (calculatedSelector === errorSelector) {
+                  // Found matching error!
+                  const errorName = errorFragment.name;
+                  const errorArgs = error.errorArgs || [];
+
+                  const enhancedError = new Error(
+                    `Transaction failed with custom error: ${errorName}(${errorArgs.join(
+                      ", "
+                    )})`
+                  );
+
+                  // Preserve original error properties
+                  Object.assign(enhancedError, error);
+
+                  if (onError) {
+                    await onError(enhancedError);
+                  }
+                  throw enhancedError;
+                }
+              }
+            }
+          }
+
+          // If we couldn't match the selector to a known error
+          console.log(
+            `${LOG_PREFIXES.DEBUG} Unknown custom error with selector: ${errorSelector}`
+          );
+        }
+      } catch (decodeError) {
+        console.error(
+          `${LOG_PREFIXES.ERROR} Error decoding transaction error:`,
+          decodeError
+        );
+      }
+    }
+
+    // Call onError callback if provided
+    if (onError) {
+      await onError(error instanceof Error ? error : new Error(String(error)));
+    }
+    throw error; // Re-throw the error after handling
+  }
+};

package/whitelist-tokens.json

@@ -0,0 +1,14 @@
+{
+  "sepolia": [
+    "0x1234567890123456789012345678901234567890",
+    "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+    "0x0000000000000000000000000000000000000000",
+    "0x09F827Fa3307cF467F51782722A5e3f43a2598dc",
+    "0xC82AE9c8b25F5b48ac200efd3e86Ca372AE1AD91"
+  ],
+  "base-sepolia": [
+    "0x0000000000000000000000000000000000000000",
+    "0xa5Ef2328aa2F6F231D15cdcF48503974D0938eD4",
+    "0x08a2d38807B1D345b6c1642f8030a29DC2Cc7223"
+  ]
+}