aiia-vault-sdk 1.0.1

package/dist/utils.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signAndSendTransaction = exports.streamEvents = exports.getAllEvents = exports.resolveContractAddress = exports.getRewardWeight = exports.buildApproveERC20Tx = exports.getTokenAllowance = exports.getTokenSymbol = exports.getTokenDecimals = exports.getTransactionStatus = exports.checkRpcHealth = exports.getRandomProvider = exports.sleep = exports.LOG_PREFIXES = void 0;
+const ethers_1 = require("ethers");
+// Debug log prefixes with colors
+exports.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
+};
+const sleep = async (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+exports.sleep = sleep;
+const getRandomProvider = (providers) => {
+    return providers[Math.floor(Math.random() * providers.length)];
+};
+exports.getRandomProvider = getRandomProvider;
+const checkRpcHealth = async (provider, index = 0) => {
+    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(`${exports.LOG_PREFIXES.ERROR} RPC health check failed:`, error, index);
+        return false;
+    }
+};
+exports.checkRpcHealth = checkRpcHealth;
+const getTransactionStatus = async (provider, txHash, maxRetries = 10) => {
+    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 (0, exports.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) {
+            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");
+};
+exports.getTransactionStatus = getTransactionStatus;
+const getTokenDecimals = async (tokenAddress, provider) => {
+    const tokenContract = new ethers_1.ethers.Contract(tokenAddress, ["function decimals() view returns (uint8)"], provider);
+    return Number(await tokenContract.decimals());
+};
+exports.getTokenDecimals = getTokenDecimals;
+const getTokenSymbol = async (tokenAddress, provider) => {
+    const tokenContract = new ethers_1.ethers.Contract(tokenAddress, ["function symbol() view returns (string)"], provider);
+    return await tokenContract.symbol();
+};
+exports.getTokenSymbol = getTokenSymbol;
+const getTokenAllowance = async (tokenAddress, owner, spender, provider) => {
+    // If the token is ETH (zero address), return max bigint value
+    if (tokenAddress === ethers_1.ethers.ZeroAddress ||
+        tokenAddress.toLowerCase() === ethers_1.ethers.ZeroAddress) {
+        // Max bigint value (2^256 - 1)
+        return BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    }
+    const tokenContract = new ethers_1.ethers.Contract(tokenAddress, [
+        "function allowance(address owner, address spender) view returns (uint256)",
+    ], provider);
+    return await tokenContract.allowance(owner, spender);
+};
+exports.getTokenAllowance = getTokenAllowance;
+const buildApproveERC20Tx = async (tokenAddress, spender, amount, provider) => {
+    const tokenContract = new ethers_1.ethers.Contract(tokenAddress, ["function approve(address spender, uint256 amount) returns (bool)"], provider);
+    return await tokenContract.approve.populateTransaction(spender, amount);
+};
+exports.buildApproveERC20Tx = buildApproveERC20Tx;
+const getRewardWeight = (duration, configs) => {
+    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;
+};
+exports.getRewardWeight = getRewardWeight;
+const resolveContractAddress = (rpcUrl, contractName, contracts, providedAddress) => {
+    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];
+};
+exports.resolveContractAddress = resolveContractAddress;
+/**
+ * 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
+ */
+const getAllEvents = async (contract, getRandomProvider, getContractWithRandomProvider, fromBlock, toBlock) => {
+    // Get all event names from the contract interface
+    const eventNames = [];
+    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[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
+            };
+        });
+    });
+    // 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,
+    }));
+};
+exports.getAllEvents = getAllEvents;
+/**
+ * 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
+ */
+const streamEvents = async ({ getProvider, getAllEvents, formatEvent, onEvent, saveLatestBlock, fromBlock, batchSize = 1000, sleepTime = 5000, }) => {
+    const debugEnabled = process.env.DEBUG_STREAM_EVENTS === "1";
+    let currentBlock = fromBlock;
+    if (debugEnabled) {
+        console.log(`${exports.LOG_PREFIXES.INFO} StreamEvents Debug Mode Enabled`);
+        console.log(`${exports.LOG_PREFIXES.INFO} Initial fromBlock: ${currentBlock}`);
+        console.log(`${exports.LOG_PREFIXES.INFO} Batch size: ${batchSize}`);
+        console.log(`${exports.LOG_PREFIXES.INFO} Sleep time: ${sleepTime}ms`);
+    }
+    while (true) {
+        try {
+            // Get the latest block number
+            const latestBlock = await getProvider().getBlockNumber();
+            if (debugEnabled) {
+                console.log(`${exports.LOG_PREFIXES.BLOCK} Latest block: ${latestBlock}`);
+            }
+            // Calculate toBlock as min(fromBlock + batchSize, latestBlock)
+            const toBlock = Math.min(currentBlock + batchSize, latestBlock);
+            if (debugEnabled) {
+                console.log(`${exports.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(`${exports.LOG_PREFIXES.DEBUG} Caught up to latest block, waiting ${sleepTime}ms...`);
+                }
+                await (0, exports.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.eventName || "Unknown";
+                    acc[eventName] = (acc[eventName] || 0) + 1;
+                    return acc;
+                }, {});
+                console.log(`${exports.LOG_PREFIXES.EVENT} Found ${events.length} events:`);
+                Object.entries(eventTypes).forEach(([eventName, count]) => {
+                    console.log(`${exports.LOG_PREFIXES.EVENT} - ${eventName}: ${count}`);
+                });
+            }
+            // Process each event
+            for (const event of events) {
+                if (debugEnabled) {
+                    console.log(`${exports.LOG_PREFIXES.EVENT} Processing: ${event.eventName || "Event"}`);
+                }
+                await onEvent(formatEvent(event));
+            }
+            // Save the latest processed block
+            await saveLatestBlock(toBlock);
+            if (debugEnabled) {
+                console.log(`${exports.LOG_PREFIXES.SAVE} Saved latest block: ${toBlock}`);
+            }
+            // Update fromBlock for next iteration
+            currentBlock = toBlock + 1;
+        }
+        catch (error) {
+            if (debugEnabled) {
+                console.error(`${exports.LOG_PREFIXES.ERROR} Error in streamEvents:`, error);
+                console.error(`${exports.LOG_PREFIXES.ERROR} Stack trace:`, error instanceof Error ? error.stack : "");
+            }
+            else {
+                console.error(`${exports.LOG_PREFIXES.ERROR} Error in streamEvents:`, error);
+            }
+            await (0, exports.sleep)(1000); // Wait before retrying on error
+        }
+    }
+};
+exports.streamEvents = streamEvents;
+/**
+ * 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
+ */
+const signAndSendTransaction = async (tx, wallet, getRandomProvider, { onSubmit, onFinally, onError, } = {}, contract) => {
+    try {
+        // Prepare the transaction
+        const transaction = {
+            ...tx,
+        };
+        // Sign and send the transaction
+        let txHash;
+        // 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 (0, exports.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) {
+        // 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);
+                            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(`${exports.LOG_PREFIXES.DEBUG} Unknown custom error with selector: ${errorSelector}`);
+                }
+            }
+            catch (decodeError) {
+                console.error(`${exports.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
+    }
+};
+exports.signAndSendTransaction = signAndSendTransaction;

package/dist/whitelist-tokens.json

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

package/index.ts

@@ -0,0 +1,3 @@
+export * from "./TradingVault";
+export * from "./SeedRoundFundraiser";
+export * from "./types";

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "aiia-vault-sdk",
+  "version": "1.0.1",
+  "description": "SDK for AIIA Vault Contract",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean"
+  },
+  "dependencies": {
+    "ethers": "^6.0.0",
+    "wagmi": "^2.14.6",
+    "@wagmi/core": "^2.16.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}