@raac/rpc 1.1.0-beta.7 → 1.1.0-beta.71

package/dist/scripts/analyze_transfers.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const fs = __importStar(require("fs"));
+const csv_parser_1 = __importDefault(require("csv-parser"));
+const RPC_URL = 'https://eth-sepolia.g.alchemy.com/v2/GRu4-s8cjabOCnh-3ZFzapF-MwUcURV_';
+const provider = new ethers_1.ethers.JsonRpcProvider(RPC_URL);
+const TOKEN_CONTRACT_ADDRESS = '0xd39d5D3289B6B76D4d584a9cD58AED99442D29eb';
+const START_BLOCK = 8718016;
+const END_BLOCK = 'latest';
+const BLOCK_RANGE_LIMIT = 500;
+// User to exclude from all calculations
+const EXCLUDED_USER = '0x7FaE0737292cD3B7Dc9067AA30a67C42c205015c'.toLowerCase();
+const ERC20_ABI = [
+    'event Transfer(address indexed from, address indexed to, uint256 value)',
+    'function balanceOf(address owner) view returns (uint256)'
+];
+async function isEOA(address) {
+    const code = await provider.getCode(address);
+    return code === '0x';
+}
+async function queryLogsInChunks(contract, filter, startBlock, endBlock) {
+    const logs = [];
+    let endBlockNumber;
+    if (typeof endBlock === 'string' && endBlock === 'latest') {
+        endBlockNumber = await provider.getBlockNumber();
+    }
+    else {
+        endBlockNumber = endBlock;
+    }
+    let currentBlock = startBlock;
+    while (currentBlock < endBlockNumber) {
+        const chunkEndBlock = Math.min(currentBlock + BLOCK_RANGE_LIMIT - 1, endBlockNumber);
+        console.log(`Querying logs from block ${currentBlock} to ${chunkEndBlock}...`);
+        try {
+            const chunkLogs = await contract.queryFilter(filter, currentBlock, chunkEndBlock);
+            logs.push(...chunkLogs);
+            console.log(`Found ${chunkLogs.length} logs in this chunk`);
+        }
+        catch (error) {
+            console.error(`Error querying logs from ${currentBlock} to ${chunkEndBlock}:`, error);
+            if (chunkEndBlock - currentBlock > 100) {
+                console.log('Retrying with smaller block range...');
+                const smallerEndBlock = Math.min(currentBlock + 100 - 1, endBlockNumber);
+                const smallerChunkLogs = await contract.queryFilter(filter, currentBlock, smallerEndBlock);
+                logs.push(...smallerChunkLogs);
+                console.log(`Found ${smallerChunkLogs.length} logs in smaller chunk`);
+                currentBlock = smallerEndBlock + 1;
+            }
+            else {
+                throw error;
+            }
+        }
+        currentBlock = chunkEndBlock + 1;
+    }
+    return logs;
+}
+function arrayToCSV(data) {
+    if (data.length === 0)
+        return '';
+    const headers = Object.keys(data[0]);
+    const csvRows = [headers.join(',')];
+    for (const row of data) {
+        const values = headers.map(header => {
+            const value = row[header];
+            if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
+                return `"${value.replace(/"/g, '""')}"`;
+            }
+            return value;
+        });
+        csvRows.push(values.join(','));
+    }
+    return csvRows.join('\n');
+}
+async function readUserBalances() {
+    return new Promise((resolve, reject) => {
+        const users = [];
+        fs.createReadStream('user_balances.csv')
+            .pipe((0, csv_parser_1.default)())
+            .on('data', (row) => {
+            users.push(row);
+        })
+            .on('end', () => {
+            console.log(`✅ Loaded ${users.length} users from user_balances.csv`);
+            resolve(users);
+        })
+            .on('error', reject);
+    });
+}
+async function main() {
+    // Check if user_balances.csv exists
+    if (!fs.existsSync('user_balances.csv')) {
+        console.error('❌ user_balances.csv not found. Please run the users.ts script first.');
+        return;
+    }
+    console.log('Loading user data from user_balances.csv...');
+    const users = await readUserBalances();
+    // Filter out the excluded user
+    const filteredUsers = users.filter(user => user.address.toLowerCase() !== EXCLUDED_USER);
+    const userAddresses = filteredUsers.map(u => u.address.toLowerCase());
+    console.log(`Analyzing transfers for ${userAddresses.length} users (excluded ${users.length - filteredUsers.length} user)...`);
+    const token = new ethers_1.ethers.Contract(TOKEN_CONTRACT_ADDRESS, ERC20_ABI, provider);
+    console.log('Querying all transfer events...');
+    const allTransferEvents = await queryLogsInChunks(token, token.filters.Transfer(), START_BLOCK, END_BLOCK);
+    console.log(`Found ${allTransferEvents.length} total transfer events`);
+    const eoaTransfers = [];
+    const processedTransactions = new Set();
+    console.log('Analyzing transfers involving EOAs...');
+    for (const event of allTransferEvents) {
+        const from = event?.args?.from?.toLowerCase();
+        const to = event?.args?.to?.toLowerCase();
+        const value = event?.args?.value;
+        const blockNumber = event.blockNumber;
+        const transactionHash = event.transactionHash;
+        // Skip if we've already processed this transaction
+        if (processedTransactions.has(transactionHash))
+            continue;
+        processedTransactions.add(transactionHash);
+        // Skip if either from or to is the excluded user
+        if (from === EXCLUDED_USER || to === EXCLUDED_USER)
+            continue;
+        // Check if either from or to is one of our users
+        const isFromUser = userAddresses.includes(from);
+        const isToUser = userAddresses.includes(to);
+        if (isFromUser || isToUser) {
+            // Check if the other party is an EOA
+            const otherParty = isFromUser ? to : from;
+            const isOtherPartyEOA = await isEOA(otherParty);
+            if (isOtherPartyEOA) {
+                if (isFromUser) {
+                    // User sent tokens to EOA
+                    eoaTransfers.push({
+                        user: from,
+                        type: 'sent',
+                        toFrom: to,
+                        amount: ethers_1.ethers.formatUnits(value, 18),
+                        blockNumber: blockNumber,
+                        transactionHash: transactionHash
+                    });
+                }
+                else {
+                    // User received tokens from EOA
+                    eoaTransfers.push({
+                        user: to,
+                        type: 'received',
+                        toFrom: from,
+                        amount: ethers_1.ethers.formatUnits(value, 18),
+                        blockNumber: blockNumber,
+                        transactionHash: transactionHash
+                    });
+                }
+            }
+        }
+    }
+    console.log(`\n=== USERS WHO TRANSFERRED/RECEIVED TOKENS WITH EOAs ===`);
+    console.log(`Found ${eoaTransfers.length} transfers involving EOAs`);
+    // Group by user
+    const userTransfers = {};
+    for (const transfer of eoaTransfers) {
+        if (!userTransfers[transfer.user]) {
+            userTransfers[transfer.user] = [];
+        }
+        userTransfers[transfer.user].push(transfer);
+    }
+    console.log(`\nUsers involved in EOA transfers: ${Object.keys(userTransfers).length}`);
+    for (const [user, transfers] of Object.entries(userTransfers)) {
+        const userData = filteredUsers.find(u => u.address.toLowerCase() === user);
+        console.log(`\nUser: ${user}`);
+        console.log(`  Mint Count: ${userData?.mintCount || 'N/A'}`);
+        console.log(`  Current Token Balance: ${userData?.tokenBalance || 'N/A'}`);
+        console.log(`  Transfers with EOAs:`);
+        for (const transfer of transfers) {
+            const direction = transfer.type === 'sent' ? '→' : '←';
+            console.log(`    ${direction} ${transfer.amount} tokens ${transfer.type === 'sent' ? 'to' : 'from'} ${transfer.toFrom} (Block: ${transfer.blockNumber})`);
+        }
+    }
+    // Save detailed transfer data to CSV
+    const transferCSVData = eoaTransfers.map(transfer => ({
+        user: transfer.user,
+        type: transfer.type,
+        toFrom: transfer.toFrom,
+        amount: transfer.amount,
+        blockNumber: transfer.blockNumber,
+        transactionHash: transfer.transactionHash
+    }));
+    const transferCSV = arrayToCSV(transferCSVData);
+    fs.writeFileSync('eoa_transfers.csv', transferCSV);
+    console.log('\n✅ Saved detailed transfer data to eoa_transfers.csv');
+    // Save summary by user
+    const userSummaryData = Object.entries(userTransfers).map(([user, transfers]) => {
+        const userData = filteredUsers.find(u => u.address.toLowerCase() === user);
+        const sentTransfers = transfers.filter(t => t.type === 'sent');
+        const receivedTransfers = transfers.filter(t => t.type === 'received');
+        const totalSent = sentTransfers.reduce((sum, t) => sum + parseFloat(t.amount), 0);
+        const totalReceived = receivedTransfers.reduce((sum, t) => sum + parseFloat(t.amount), 0);
+        return {
+            address: user,
+            mintCount: userData?.mintCount || '0',
+            currentTokenBalance: userData?.tokenBalance || '0',
+            totalSentToEOA: totalSent.toString(),
+            totalReceivedFromEOA: totalReceived.toString(),
+            sentTransactions: sentTransfers.length,
+            receivedTransactions: receivedTransfers.length,
+            totalTransactions: transfers.length
+        };
+    });
+    const summaryCSV = arrayToCSV(userSummaryData);
+    fs.writeFileSync('eoa_transfer_summary.csv', summaryCSV);
+    console.log('✅ Saved user summary to eoa_transfer_summary.csv');
+}
+main().catch(console.error);

package/dist/scripts/calculate_portfolio.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const csv_parser_1 = __importDefault(require("csv-parser"));
+// User to exclude from all calculations
+const EXCLUDED_USER = '0x7FaE0737292cD3B7Dc9067AA30a67C42c205015c'.toLowerCase();
+function arrayToCSV(data) {
+    if (data.length === 0)
+        return '';
+    const headers = Object.keys(data[0]);
+    const csvRows = [headers.join(',')];
+    for (const row of data) {
+        const values = headers.map(header => {
+            const value = row[header];
+            if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
+                return `"${value.replace(/"/g, '""')}"`;
+            }
+            return value;
+        });
+        csvRows.push(values.join(','));
+    }
+    return csvRows.join('\n');
+}
+async function readUserBalances() {
+    return new Promise((resolve, reject) => {
+        const users = [];
+        fs.createReadStream('user_balances.csv')
+            .pipe((0, csv_parser_1.default)())
+            .on('data', (row) => {
+            users.push(row);
+        })
+            .on('end', () => {
+            console.log(`✅ Loaded ${users.length} users from user_balances.csv`);
+            resolve(users);
+        })
+            .on('error', reject);
+    });
+}
+function calculateTotalNftValue(nftDataString) {
+    try {
+        const nftData = JSON.parse(nftDataString);
+        let totalValue = 0;
+        const details = [];
+        for (const nft of nftData) {
+            const price = parseFloat(nft.price);
+            if (!isNaN(price)) {
+                totalValue += price;
+                details.push(`Token ${nft.tokenId}: $${price.toFixed(2)} (${nft.timestamp})`);
+            }
+        }
+        return {
+            totalValue,
+            details: details.join('; ')
+        };
+    }
+    catch (error) {
+        console.error('Error parsing NFT data:', error);
+        return { totalValue: 0, details: 'Error parsing NFT data' };
+    }
+}
+async function main() {
+    // Check if user_balances.csv exists
+    if (!fs.existsSync('user_balances.csv')) {
+        console.error('❌ user_balances.csv not found. Please run the users.ts script first.');
+        return;
+    }
+    console.log('Loading user data from user_balances.csv...');
+    const users = await readUserBalances();
+    // Filter out the excluded user
+    const filteredUsers = users.filter(user => user.address.toLowerCase() !== EXCLUDED_USER);
+    console.log(`Calculating portfolio values for ${filteredUsers.length} users (excluded ${users.length - filteredUsers.length} user)...`);
+    console.log('Calculating portfolio values...');
+    const portfolioData = [];
+    for (const user of filteredUsers) {
+        // Parse token balances
+        const rTokenValue = parseFloat(user.rTokenBalance) || 0;
+        const deTokenValue = parseFloat(user.deTokenBalance) || 0;
+        const iraacValue = (parseFloat(user.iraacBalance) || 0) * 0.97; // Apply 0.97 multiplier to iRAAC balance
+        const tokenValue = parseFloat(user.tokenBalance) || 0;
+        // Calculate NFT total value
+        const { totalValue: nftTotalValue, details: nftDetails } = calculateTotalNftValue(user.nftData);
+        // Calculate total portfolio value
+        const totalPortfolioValue = rTokenValue + deTokenValue + iraacValue + tokenValue + nftTotalValue;
+        const portfolio = {
+            address: user.address,
+            mintCount: user.mintCount,
+            hasInteractedWithEOA: user.hasInteractedWithEOA,
+            rTokenBalance: user.rTokenBalance,
+            deTokenBalance: user.deTokenBalance,
+            iraacBalance: user.iraacBalance,
+            tokenBalance: user.tokenBalance,
+            nftBalance: user.nftBalance,
+            totalNftValue: nftTotalValue.toFixed(2),
+            totalPortfolioValue: totalPortfolioValue.toFixed(2),
+            nftDetails: nftDetails
+        };
+        portfolioData.push(portfolio);
+        console.log(`\nUser: ${user.address}`);
+        console.log(`  R Token: $${rTokenValue.toFixed(2)}`);
+        console.log(`  DE Token: $${deTokenValue.toFixed(2)}`);
+        console.log(`  iRAAC: $${iraacValue.toFixed(2)}`);
+        console.log(`  Token: $${tokenValue.toFixed(2)}`);
+        console.log(`  NFT Total: $${nftTotalValue.toFixed(2)}`);
+        console.log(`  Total Portfolio: $${totalPortfolioValue.toFixed(2)}`);
+        if (nftDetails && nftDetails !== 'Error parsing NFT data') {
+            console.log(`  NFT Details: ${nftDetails}`);
+        }
+    }
+    // Sort by total portfolio value (highest first)
+    portfolioData.sort((a, b) => parseFloat(b.totalPortfolioValue) - parseFloat(a.totalPortfolioValue));
+    // Save to CSV
+    const csvData = arrayToCSV(portfolioData);
+    fs.writeFileSync('user_portfolios.csv', csvData);
+    console.log('\n✅ Saved portfolio data to user_portfolios.csv');
+    // Print summary statistics
+    const totalUsers = portfolioData.length;
+    const usersWithValue = portfolioData.filter(p => parseFloat(p.totalPortfolioValue) > 0).length;
+    const totalPortfolioValue = portfolioData.reduce((sum, p) => sum + parseFloat(p.totalPortfolioValue), 0);
+    const averagePortfolioValue = totalPortfolioValue / totalUsers;
+    console.log('\n=== PORTFOLIO SUMMARY ===');
+    console.log(`Total Users: ${totalUsers}`);
+    console.log(`Users with Value > 0: ${usersWithValue}`);
+    console.log(`Total Portfolio Value: $${totalPortfolioValue.toFixed(2)}`);
+    console.log(`Average Portfolio Value: $${averagePortfolioValue.toFixed(2)}`);
+    // Top 10 portfolios
+    console.log('\n=== TOP 10 PORTFOLIOS ===');
+    portfolioData.slice(0, 10).forEach((portfolio, index) => {
+        console.log(`${index + 1}. ${portfolio.address}: $${portfolio.totalPortfolioValue}`);
+    });
+}
+main().catch(console.error);

package/dist/scripts/generateErrorMap.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ethers_1 = require("ethers");
+// Custom error messages based on error names
+const ERROR_MESSAGES = {
+    // Access Control
+    'AccessControlBadConfirmation': 'Invalid access control confirmation',
+    'AccessControlUnauthorizedAccount': 'Account does not have required permissions',
+    'AccessDenied': 'Access denied - insufficient permissions',
+    // Adapter Errors
+    'AdapterAlreadySupported': 'This adapter is already supported',
+    'AdapterNotSupported': 'This adapter is not supported',
+    // Address Errors
+    'AddressCannotBeZero': 'Address cannot be zero',
+    'AddressEmptyCode': 'Target address has no code',
+    'AddressInsufficientBalance': 'Insufficient balance for operation',
+    // Amount Errors
+    'AmountDifferentThanRequested': 'Amount differs from requested amount',
+    'ApprovalFailed': 'Token approval failed',
+    // Compliance
+    'BlacklistedAddress': 'Address is blacklisted',
+    // Pool Errors
+    'BorrowCapReached': 'Borrow cap has been reached',
+    'BorrowThresholdTooHigh': 'Borrow threshold is too high',
+    'CannotBorrowUnderLiquidation': 'Cannot borrow while under liquidation',
+    'CannotDepositWhenUnderLiquidation': 'Cannot deposit while under liquidation',
+    'CannotRepayUnderLiquidationWithoutInsurance': 'Cannot repay under liquidation without insurance',
+    'CannotWithdrawInSameBlock': 'Cannot withdraw in the same block',
+    'CannotWithdrawUnderLiquidation': 'Cannot withdraw while under liquidation',
+    'CapExceedSupply': 'Cap exceeds available supply',
+    'CapZero': 'Cap cannot be zero',
+    'DebtNotZero': 'Debt must be zero for this operation',
+    'SupplyCapReached': 'Supply cap has been reached',
+    // Pause Errors
+    'EnforcedPause': 'Contract is paused',
+    'ExpectedPause': 'Contract should be paused',
+    // General Errors
+    'FailedInnerCall': 'Internal call failed',
+    'GracePeriodExpired': 'Grace period has expired',
+    'InsufficientAllowance': 'Insufficient allowance for operation',
+    'InsufficientBalance': 'Insufficient balance for operation',
+    'InvalidAmount': 'Invalid amount provided',
+    'InvalidCollateralRatio': 'Invalid collateral ratio',
+    'InvalidHealthFactor': 'Invalid health factor',
+    'InvalidLiquidationThreshold': 'Invalid liquidation threshold',
+    'InvalidParameter': 'Invalid parameter provided',
+    'InvalidPrice': 'Invalid price provided',
+    'InvalidToken': 'Invalid token address',
+    'LiquidationNotAllowed': 'Liquidation is not allowed',
+    'NoLiquidationAvailable': 'No liquidation available',
+    'NotEnoughLiquidity': 'Not enough liquidity available',
+    'OperationNotAllowed': 'Operation is not allowed',
+    'Overflow': 'Arithmetic overflow occurred',
+    'Paused': 'Contract is paused',
+    'ReentrancyGuardReentrantCall': 'Reentrant call detected',
+    'ReserveAlreadyInitialized': 'Reserve is already initialized',
+    'ReserveNotActive': 'Reserve is not active',
+    'ReserveNotInitialized': 'Reserve is not initialized',
+    'SafeERC20FailedOperation': 'SafeERC20 operation failed',
+    'TransferFailed': 'Token transfer failed',
+    'Unauthorized': 'Unauthorized operation',
+    'Underflow': 'Arithmetic underflow occurred',
+    'VaultNotOpen': 'Vault is not open',
+    'WithdrawalNotAllowed': 'Withdrawal is not allowed',
+    // Custom contract-specific errors
+    'InvalidOraclePrice': 'Invalid oracle price received',
+    'PriceStale': 'Oracle price is stale',
+    'InvalidRandomSeed': 'Invalid random seed provided',
+    'RandomSeedNotReady': 'Random seed is not ready',
+    'NFTNotAvailable': 'NFT is not available',
+    'InvalidNFTId': 'Invalid NFT ID provided',
+    'NFTAlreadyDeposited': 'NFT is already deposited',
+    'NFTNotDeposited': 'NFT is not deposited',
+    'InvalidVaultPosition': 'Invalid vault position',
+    'PositionNotOpen': 'Position is not open',
+    'InvalidCollateral': 'Invalid collateral provided',
+    'CollateralNotSupported': 'Collateral is not supported',
+    'InvalidDebtToken': 'Invalid debt token',
+    'DebtTokenNotSupported': 'Debt token is not supported',
+    'InvalidLiquidationProxy': 'Invalid liquidation proxy',
+    'InvalidVaultProxy': 'Invalid vault proxy',
+    'InvalidComplianceRegistry': 'Invalid compliance registry',
+    'InvalidPrimeRate': 'Invalid prime rate',
+    'InvalidAdmin': 'Invalid admin address',
+    'InvalidReserveAsset': 'Invalid reserve asset',
+    'InvalidRToken': 'Invalid R token',
+    'InvalidDebtTokenAddress': 'Invalid debt token address',
+    'InvalidLiquidationProxyAddress': 'Invalid liquidation proxy address',
+    'InvalidVaultProxyAddress': 'Invalid vault proxy address',
+    'InvalidComplianceRegistryAddress': 'Invalid compliance registry address',
+    'InvalidInitialPrimeRate': 'Invalid initial prime rate',
+    'InvalidAdminAddress': 'Invalid admin address',
+};
+function walkDir(dir) {
+    const files = [];
+    const items = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+        const fullPath = path_1.default.join(dir, item.name);
+        if (item.isDirectory()) {
+            files.push(...walkDir(fullPath));
+        }
+        else if (item.name.endsWith('.json')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function generateErrorMap() {
+    const errorMap = {};
+    const artifactsDir = path_1.default.join(process.cwd(), 'artifacts');
+    if (!fs_1.default.existsSync(artifactsDir)) {
+        console.error('Artifacts directory not found');
+        process.exit(1);
+    }
+    const jsonFiles = walkDir(artifactsDir);
+    for (const filePath of jsonFiles) {
+        try {
+            const content = fs_1.default.readFileSync(filePath, 'utf8');
+            const json = JSON.parse(content);
+            if (!json.abi || !Array.isArray(json.abi))
+                continue;
+            const contractName = json.contractName || path_1.default.basename(filePath, '.json');
+            for (const item of json.abi) {
+                if (item.type !== 'error')
+                    continue;
+                const inputs = item.inputs || [];
+                const signature = `${item.name}(${inputs.map((input) => input.type).join(',')})`;
+                const selector = (0, ethers_1.id)(signature).slice(0, 10).toLowerCase();
+                // Skip if already processed (first occurrence wins)
+                if (errorMap[selector])
+                    continue;
+                const customMessage = ERROR_MESSAGES[item.name] ||
+                    `${item.name.replace(/([A-Z])/g, ' $1').trim()} error occurred`;
+                errorMap[selector] = {
+                    name: item.name,
+                    signature,
+                    message: customMessage,
+                    contract: contractName,
+                    inputs: inputs.map((input) => ({
+                        name: input.name || '',
+                        type: input.type,
+                        internalType: input.internalType || input.type,
+                    })),
+                };
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to process ${filePath}:`, error);
+        }
+    }
+    return errorMap;
+}
+function main() {
+    console.log('🔍 Scanning ABIs for error definitions...');
+    const errorMap = generateErrorMap();
+    const outputPath = path_1.default.join(process.cwd(), 'generated', 'errorMap.json');
+    // Ensure generated directory exists
+    const generatedDir = path_1.default.dirname(outputPath);
+    if (!fs_1.default.existsSync(generatedDir)) {
+        fs_1.default.mkdirSync(generatedDir, { recursive: true });
+    }
+    // Write the error map
+    fs_1.default.writeFileSync(outputPath, JSON.stringify(errorMap, null, 2));
+    console.log(`✅ Generated error map with ${Object.keys(errorMap).length} errors`);
+    console.log(`📁 Output: ${outputPath}`);
+    // Show some examples
+    const examples = Object.entries(errorMap).slice(0, 5);
+    console.log('\n📋 Examples:');
+    for (const [selector, info] of examples) {
+        console.log(`  ${selector} → ${info.name}: ${info.message}`);
+    }
+}
+if (require.main === module) {
+    main();
+}