@raac/rpc 1.1.0-beta.9 → 1.1.0-beta.90

package/dist/scripts/test_lending_analysis.js

@@ -0,0 +1,105 @@
+"use strict";
+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 chains_1 = __importDefault(require("../configs/chains"));
+const RPCLibrary_1 = __importDefault(require("../RPCLibrary"));
+const artifacts_1 = require("../utils/artifacts");
+const chainId = 8453; // Base
+const config = chains_1.default[chainId];
+async function getProvider() {
+    return new ethers_1.ethers.JsonRpcProvider(config.rpcs[0]);
+}
+async function testLendingAnalysis() {
+    console.log("🧪 Testing Lending Position Analysis...");
+    console.log("=====================================");
+    try {
+        const provider = await getProvider();
+        const rpc = new RPCLibrary_1.default();
+        rpc.provider = provider;
+        rpc.chainId = chainId;
+        // Test 1: Get adapters
+        console.log("1. Testing adapter retrieval...");
+        const adapters = await rpc.pools.lendingPool.getAdapters(chainId, provider);
+        console.log(`   Found ${adapters.adapters.length} adapters:`, adapters.adapters);
+        // Test 2: Test each adapter
+        for (const adapterAddress of adapters.adapters) {
+            console.log(`\n2. Testing adapter ${adapterAddress}...`);
+            try {
+                // Get adapter info
+                const adapterInfo = rpc.pools.lendingPool.getAdapterAddress(chainId, adapterAddress);
+                if (!adapterInfo) {
+                    console.log(`   ❌ Adapter not found in config`);
+                    continue;
+                }
+                console.log(`   ✅ Adapter type: ${adapterInfo.type}`);
+                // Test event querying
+                if (adapterInfo.type === "ERC20") {
+                    const erc20AdapterABI = (0, artifacts_1.getABI)("erc20assetadapter");
+                    const erc20AdapterContract = new ethers_1.ethers.Contract(adapterInfo.address, erc20AdapterABI, provider);
+                    const events = await erc20AdapterContract.queryFilter(erc20AdapterContract.filters.TokenDeposited(), "latest" // Only check latest block for testing
+                    );
+                    console.log(`   ✅ Found ${events.length} TokenDeposited events in latest block`);
+                }
+                else if (adapterInfo.type === "ERC721") {
+                    const erc721AdapterABI = (0, artifacts_1.getABI)("erc721assetadapter");
+                    const erc721AdapterContract = new ethers_1.ethers.Contract(adapterInfo.address, erc721AdapterABI, provider);
+                    const events = await erc721AdapterContract.queryFilter(erc721AdapterContract.filters.NFTDeposited(), "latest" // Only check latest block for testing
+                    );
+                    console.log(`   ✅ Found ${events.length} NFTDeposited events in latest block`);
+                }
+            }
+            catch (error) {
+                console.log(`   ❌ Error testing adapter:`, error);
+            }
+        }
+        // Test 3: Test lending pool contract
+        console.log("\n3. Testing lending pool contract...");
+        try {
+            const lendingPoolAddress = config.pools.lendingpool.contract;
+            const lendingPoolABI = (0, artifacts_1.getABI)("lendingpool");
+            const lendingPoolContract = new ethers_1.ethers.Contract(lendingPoolAddress, lendingPoolABI, provider);
+            // Test basic contract calls
+            const totalLiquidity = await lendingPoolContract.getTotalLiquidity();
+            console.log(`   ✅ Total liquidity: ${ethers_1.ethers.formatEther(totalLiquidity)}`);
+            const primeRate = await lendingPoolContract.getPrimeRate();
+            console.log(`   ✅ Prime rate: ${ethers_1.ethers.formatEther(primeRate)}`);
+        }
+        catch (error) {
+            console.log(`   ❌ Error testing lending pool:`, error);
+        }
+        // Test 4: Test position view (if we have any positions)
+        console.log("\n4. Testing position view...");
+        try {
+            // Try to get position view for a test address (should fail gracefully if no position)
+            const testAddress = "0x0000000000000000000000000000000000000000";
+            const testData = new ethers_1.ethers.AbiCoder().encode(["uint256"], [0]);
+            if (adapters.adapters.length > 0) {
+                const testAdapter = adapters.adapters[0];
+                const lendingPoolAddress = config.pools.lendingpool.contract;
+                const lendingPoolABI = (0, artifacts_1.getABI)("lendingpool");
+                const lendingPoolContract = new ethers_1.ethers.Contract(lendingPoolAddress, lendingPoolABI, provider);
+                try {
+                    await lendingPoolContract.getPositionView(testAdapter, testAddress, testData);
+                    console.log("   ❌ Unexpected: Position view succeeded for zero address");
+                }
+                catch (error) {
+                    console.log("   ✅ Position view correctly failed for zero address (expected)");
+                }
+            }
+        }
+        catch (error) {
+            console.log(`   ❌ Error testing position view:`, error);
+        }
+        console.log("\n✅ Test completed successfully!");
+        console.log("The analysis script should work correctly.");
+    }
+    catch (error) {
+        console.error("❌ Test failed:", error);
+        throw error;
+    }
+}
+// Run the test
+testLendingAnalysis().catch(console.error);

package/dist/scripts/users.js

@@ -0,0 +1,305 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const fs = __importStar(require("fs"));
+const RPC_URL = 'https://eth-sepolia.api.onfinality.io/rpc?apikey=8fe121c5-8961-4321-be50-6fd272c487d1'; // Replace with actual RPC
+const provider = new ethers_1.ethers.JsonRpcProvider(RPC_URL);
+const TOKEN_CONTRACT_ADDRESS = '0x990c1Aa9162d2c5B51378F86420f1752874e034B'; // ERC20 token contract
+const NFT_CONTRACT_ADDRESS = '0x7421e594B65414d1b3eb5b798bc7bEeB2f834b6F'; // Add your ERC721 contract address here
+const ORACLE_CONTRACT_ADDRESS = '0x5B2b86931846A66C178725CFd8fCae4bf2A08617'; // Add your oracle contract address here
+const R_TOKEN_ADDRESS = '0x062a641EF54810B321f123487fFf083cadB50989';
+const DE_TOKEN_ADDRESS = '0xE9594c6923a909528336009f0Ab916d72d28478e';
+const IRAAC_TOKEN_ADDRESS = '0x531b322933ebc65b4A139a11139534A3872bEB1a';
+// User to exclude from all calculations
+const EXCLUDED_USER = '0x7FaE0737292cD3B7Dc9067AA30a67C42c205015c'.toLowerCase();
+const START_BLOCK = 9022468;
+const END_BLOCK = 'latest';
+const BLOCK_RANGE_LIMIT = 500; // RPC limit for eth_getLogs
+const ERC20_ABI = [
+    'event Transfer(address indexed from, address indexed to, uint256 value)',
+    'function balanceOf(address owner) view returns (uint256)'
+];
+const ERC721_ABI = [
+    'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)',
+    'function balanceOf(address owner) view returns (uint256)',
+    'function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)'
+];
+const ORACLE_ABI = [
+    'function getLatestPrice(uint256 id) view returns (uint256 price, uint256 timestamp)'
+];
+async function isEOA(address) {
+    const code = await provider.getCode(address);
+    return code === '0x';
+}
+async function getERC20Balance(tokenAddress, user) {
+    const token = new ethers_1.ethers.Contract(tokenAddress, ERC20_ABI, provider);
+    return await token.balanceOf(user);
+}
+async function getNFTBalance(nftContract, user) {
+    try {
+        return await nftContract.balanceOf(user);
+    }
+    catch (error) {
+        console.error(`Error getting NFT balance for ${user}:`, error);
+        return 0;
+    }
+}
+async function getNFTTokenIds(nftContract, user) {
+    try {
+        const balance = await nftContract.balanceOf(user);
+        const tokenIds = [];
+        for (let i = 0; i < balance; i++) {
+            try {
+                const tokenId = await nftContract.tokenOfOwnerByIndex(user, i);
+                tokenIds.push(Number(tokenId));
+            }
+            catch (error) {
+                console.error(`Error getting token ID at index ${i} for user ${user}:`, error);
+            }
+        }
+        return tokenIds;
+    }
+    catch (error) {
+        console.error(`Error getting NFT token IDs for ${user}:`, error);
+        return [];
+    }
+}
+async function getHousePrice(oracleContract, tokenId) {
+    try {
+        const [price, timestamp] = await oracleContract.getLatestPrice(tokenId);
+        return {
+            price: ethers_1.ethers.formatUnits(price, 18),
+            timestamp: new Date(Number(timestamp) * 1000).toISOString()
+        };
+    }
+    catch (error) {
+        console.error(`Error getting house price for token ID ${tokenId}:`, error);
+        return {
+            price: '0',
+            timestamp: 'N/A'
+        };
+    }
+}
+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 we hit an error, try with a smaller range
+            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;
+            }
+        }
+        // await new Promise(resolve => setTimeout(resolve, 100));
+        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];
+            // Escape commas and quotes in CSV
+            if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
+                return `"${value.replace(/"/g, '""')}"`;
+            }
+            return value;
+        });
+        csvRows.push(values.join(','));
+    }
+    return csvRows.join('\n');
+}
+async function main() {
+    // Check if NFT contract address is provided
+    if (!NFT_CONTRACT_ADDRESS) {
+        console.error('❌ Please provide NFT_CONTRACT_ADDRESS in the script');
+        return;
+    }
+    if (!ORACLE_CONTRACT_ADDRESS) {
+        console.error('❌ Please provide ORACLE_CONTRACT_ADDRESS in the script');
+        return;
+    }
+    const token = new ethers_1.ethers.Contract(TOKEN_CONTRACT_ADDRESS, ERC20_ABI, provider);
+    const nft = new ethers_1.ethers.Contract(NFT_CONTRACT_ADDRESS, ERC721_ABI, provider);
+    const oracle = new ethers_1.ethers.Contract(ORACLE_CONTRACT_ADDRESS, ORACLE_ABI, provider);
+    console.log('Querying token mint events...');
+    const mintEvents = await queryLogsInChunks(token, token.filters.Transfer(ethers_1.ethers.ZeroAddress), START_BLOCK, END_BLOCK);
+    // Track mint counts per user
+    const mintCounts = {};
+    const allMinters = new Set();
+    for (const event of mintEvents) {
+        const to = event?.args?.to;
+        if (to) {
+            const user = to.toLowerCase();
+            // Exclude the specified user
+            if (user === EXCLUDED_USER)
+                continue;
+            allMinters.add(user);
+            mintCounts[user] = (mintCounts[user] || 0) + 1;
+        }
+    }
+    // Log users who minted multiple times
+    const multipleMinters = Object.entries(mintCounts).filter(([_, count]) => count > 1);
+    console.log(`\n=== USERS WHO MINTED MULTIPLE TIMES ===`);
+    console.log(`Found ${multipleMinters.length} users who minted multiple times:`);
+    for (const [user, count] of multipleMinters) {
+        console.log(`User: ${user} - Minted ${count} times`);
+    }
+    console.log('========================================\n');
+    console.log(`Found ${allMinters.size} unique minters total`);
+    console.log('Querying transfer events...');
+    const transferEvents = await queryLogsInChunks(token, token.filters.Transfer(), START_BLOCK, END_BLOCK);
+    const interactedWithEOA = new Set();
+    console.log('Checking EOA interactions...');
+    for (const event of transferEvents) {
+        const from = event?.args?.from?.toLowerCase();
+        const to = event?.args?.to?.toLowerCase();
+        // Skip if either from or to is the excluded user
+        if (from === EXCLUDED_USER || to === EXCLUDED_USER)
+            continue;
+        if (from && allMinters.has(from)) {
+            const isToEOA = await isEOA(to);
+            if (isToEOA)
+                interactedWithEOA.add(from);
+        }
+        if (to && allMinters.has(to)) {
+            const isFromEOA = await isEOA(from);
+            if (isFromEOA)
+                interactedWithEOA.add(to);
+        }
+    }
+    const excludedUsers = [...allMinters].filter(x => !interactedWithEOA.has(x));
+    console.log(`Found ${excludedUsers.length} users who haven't interacted with EOAs`);
+    // Get balances for ALL users (not just excluded ones)
+    console.log('Getting token balances and NFT data for all users...');
+    const allUserData = [];
+    for (const user of [...allMinters]) {
+        const [rTokenBal, deTokenBal, iraacBal, nftBalance, tokenBal] = await Promise.all([
+            getERC20Balance(R_TOKEN_ADDRESS, user),
+            getERC20Balance(DE_TOKEN_ADDRESS, user),
+            getERC20Balance(IRAAC_TOKEN_ADDRESS, user),
+            getNFTBalance(nft, user),
+            getERC20Balance(TOKEN_CONTRACT_ADDRESS, user)
+        ]);
+        // Get NFT token IDs and their prices
+        const nftTokenIds = await getNFTTokenIds(nft, user);
+        const nftData = [];
+        for (const tokenId of nftTokenIds) {
+            const housePrice = await getHousePrice(oracle, tokenId);
+            nftData.push({
+                tokenId: tokenId,
+                price: housePrice.price,
+                timestamp: housePrice.timestamp
+            });
+        }
+        const userData = {
+            address: user,
+            mintCount: mintCounts[user] || 0,
+            hasInteractedWithEOA: interactedWithEOA.has(user),
+            rTokenBalance: ethers_1.ethers.formatUnits(rTokenBal, 18),
+            deTokenBalance: ethers_1.ethers.formatUnits(deTokenBal, 18),
+            iraacBalance: ethers_1.ethers.formatUnits(iraacBal, 18),
+            tokenBalance: ethers_1.ethers.formatUnits(tokenBal, 18),
+            nftBalance: nftBalance,
+            nftTokenIds: nftTokenIds.join(';'),
+            nftData: JSON.stringify(nftData)
+        };
+        allUserData.push(userData);
+        console.log(`User: ${user}`);
+        console.log(`  Mint Count: ${userData.mintCount}`);
+        console.log(`  Interacted with EOA: ${userData.hasInteractedWithEOA}`);
+        console.log(`  R Token: ${userData.rTokenBalance}`);
+        console.log(`  DE Token: ${userData.deTokenBalance}`);
+        console.log(`  iRAAC: ${userData.iraacBalance}`);
+        console.log(`  Token Balance: ${userData.tokenBalance}`);
+        console.log(`  NFT Balance: ${userData.nftBalance}`);
+        if (nftTokenIds.length > 0) {
+            console.log(`  NFT Token IDs: ${nftTokenIds.join(', ')}`);
+            console.log(`  NFT Prices:`);
+            for (const nft of nftData) {
+                console.log(`    Token ID ${nft.tokenId}: ${nft.price} (${nft.timestamp})`);
+            }
+        }
+        console.log('-----------------------------');
+    }
+    // Save to CSV file
+    const csvData = arrayToCSV(allUserData);
+    fs.writeFileSync('user_balances.csv', csvData);
+    console.log('✅ Saved all user data to user_balances.csv');
+    // Also save the multiple minters data separately
+    const multipleMintersData = multipleMinters.map(([user, count]) => ({
+        address: user,
+        mintCount: count,
+        rTokenBalance: allUserData.find(u => u.address === user)?.rTokenBalance || '0',
+        deTokenBalance: allUserData.find(u => u.address === user)?.deTokenBalance || '0',
+        iraacBalance: allUserData.find(u => u.address === user)?.iraacBalance || '0',
+        tokenBalance: allUserData.find(u => u.address === user)?.tokenBalance || '0',
+        nftBalance: allUserData.find(u => u.address === user)?.nftBalance || '0',
+        nftTokenIds: allUserData.find(u => u.address === user)?.nftTokenIds || '',
+        nftData: allUserData.find(u => u.address === user)?.nftData || '[]'
+    }));
+    const multipleMintersCSV = arrayToCSV(multipleMintersData);
+    fs.writeFileSync('multiple_minters.csv', multipleMintersCSV);
+    console.log('✅ Saved multiple minters data to multiple_minters.csv');
+}
+main().catch(console.error);