@raac/rpc 1.1.0-beta.6 → 1.1.0-beta.60

package/dist/scripts/run_analysis.js

@@ -0,0 +1,115 @@
+"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 child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+async function runScript(scriptName) {
+    return new Promise((resolve, reject) => {
+        console.log(`\n🚀 Starting ${scriptName}...`);
+        console.log('='.repeat(50));
+        const child = (0, child_process_1.spawn)('npx', ['ts-node', `scripts/${scriptName}`], {
+            stdio: 'inherit',
+            shell: true
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                console.log(`\n✅ ${scriptName} completed successfully`);
+                resolve();
+            }
+            else {
+                console.error(`\n❌ ${scriptName} failed with exit code ${code}`);
+                reject(new Error(`${scriptName} failed with exit code ${code}`));
+            }
+        });
+        child.on('error', (error) => {
+            console.error(`\n❌ Error running ${scriptName}:`, error);
+            reject(error);
+        });
+    });
+}
+async function main() {
+    console.log('📊 Starting Complete User Analysis Pipeline');
+    console.log('='.repeat(60));
+    const startTime = Date.now();
+    try {
+        // Step 1: Run users.ts to collect user data
+        console.log('\n📋 Step 1: Collecting user data and balances...');
+        await runScript('users.ts');
+        // Check if user_balances.csv was created
+        if (!fs.existsSync('user_balances.csv')) {
+            throw new Error('user_balances.csv was not created by users.ts');
+        }
+        // Step 2: Run analyze_transfers.ts to analyze EOA transfers
+        console.log('\n🔄 Step 2: Analyzing EOA transfers...');
+        await runScript('analyze_transfers.ts');
+        // Step 3: Run calculate_portfolio.ts to calculate total portfolio values
+        console.log('\n💰 Step 3: Calculating portfolio values...');
+        await runScript('calculate_portfolio.ts');
+        const endTime = Date.now();
+        const duration = (endTime - startTime) / 1000;
+        console.log('\n🎉 Complete Analysis Pipeline Finished Successfully!');
+        console.log('='.repeat(60));
+        console.log(`⏱️  Total execution time: ${duration.toFixed(2)} seconds`);
+        // List all generated files
+        console.log('\n📁 Generated Files:');
+        const files = [
+            'user_balances.csv',
+            'multiple_minters.csv',
+            'eoa_transfers.csv',
+            'eoa_transfer_summary.csv',
+            'user_portfolios.csv'
+        ];
+        files.forEach(file => {
+            if (fs.existsSync(file)) {
+                const stats = fs.statSync(file);
+                console.log(`  ✅ ${file} (${(stats.size / 1024).toFixed(2)} KB)`);
+            }
+            else {
+                console.log(`  ❌ ${file} (not found)`);
+            }
+        });
+        console.log('\n📊 Analysis Summary:');
+        console.log('  • user_balances.csv - All user token balances and NFT data');
+        console.log('  • multiple_minters.csv - Users who minted multiple times');
+        console.log('  • eoa_transfers.csv - Detailed EOA transfer transactions');
+        console.log('  • eoa_transfer_summary.csv - Summary of EOA transfers by user');
+        console.log('  • user_portfolios.csv - Total portfolio values for each user');
+    }
+    catch (error) {
+        console.error('\n💥 Pipeline failed:', error);
+        process.exit(1);
+    }
+}
+main().catch(console.error);

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,304 @@
+"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.g.alchemy.com/v2/GRu4-s8cjabOCnh-3ZFzapF-MwUcURV_'; // Replace with actual RPC
+const provider = new ethers_1.ethers.JsonRpcProvider(RPC_URL);
+const TOKEN_CONTRACT_ADDRESS = '0xd39d5D3289B6B76D4d584a9cD58AED99442D29eb'; // ERC20 token contract
+const NFT_CONTRACT_ADDRESS = '0x9f732c8082a660a89A55ec7551d90393572F5d42'; // Add your ERC721 contract address here
+const ORACLE_CONTRACT_ADDRESS = '0x3a933ab12852a30c83dFDeAEf4a67b84241B0acc'; // Add your oracle contract address here
+const R_TOKEN_ADDRESS = '0x3fea2bF12b686FfFD0321DA6CA6c762FA7C2121C';
+const DE_TOKEN_ADDRESS = '0xdCB4C5aB4aE4873ec700C3EACD1f338547cE6117';
+const IRAAC_TOKEN_ADDRESS = '0xc23b30B0fd654f51e6b833d3d550c320c0f32018';
+// User to exclude from all calculations
+const EXCLUDED_USER = '0x7FaE0737292cD3B7Dc9067AA30a67C42c205015c'.toLowerCase();
+const START_BLOCK = 8718016;
+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;
+            }
+        }
+        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);

package/dist/types/RPCLibrary.d.ts

@@ -14,8 +14,8 @@ import withdrawFromLendingPool from "./pools/lendingPool/withdrawFromLendingPool
 import getLendingPoolTotalLiquidity from "./pools/lendingPool/getLendingPoolTotalLiquidity";
 import borrowFromLendingPool from "./pools/lendingPool/borrowFromLendingPool";
 import repayToLendingPool from "./pools/lendingPool/repayToLendingPool";
-import depositNFTToLendingPool from "./pools/lendingPool/depositAssetToLendingPool";
-import withdrawNFTFromLendingPool from "./pools/lendingPool/withdrawAssetFromLendingPool";
+import depositAssetToLendingPool from "./pools/lendingPool/depositAssetToLendingPool";
+import withdrawAssetFromLendingPool from "./pools/lendingPool/withdrawAssetFromLendingPool";
 import getHousePrice from "./pools/lendingPool/getHousePrice";
 import getERC20AdapterInfo from "./pools/lendingPool/adapters/erc20/getERC20AdapterInfo";
 import getERC20AdapterBalance from "./pools/lendingPool/adapters/erc20/getERC20AdapterBalance";
@@ -37,6 +37,7 @@ import mintNFT from "./nfts/mint";
 import getNFTHousePrice from "./nfts/getHousePrice";
 import setNFTBaseUri from "./nfts/setBaseUri";
 import getTokensByOwner from "./nfts/getTokensByOwner";
+import getOwnerOfNFT from "./nfts/getOwnerOfNFT";
 import getContractAddress from "./contracts/getContractAddress";
 import getContract from "./contracts/getContract";
 import getLatestPrice from "./contracts/housePrices/getLatestPrice";
@@ -80,6 +81,21 @@ import calculateInsuranceFee from "./pools/lendingPool/calculateInsuranceFee";
 import getTotalPropertiesCount from "./nfts/getTotalPropertiesCount";
 import getParameters from "./pools/lendingPool/getParameters";
 import getAdapters from "./pools/lendingPool/getAdapters";
+import { getWithdrawRequestInfo } from "./pools/lendingPool/getWithdrawRequestInfo";
+import { requestWithdraw } from "./pools/lendingPool/requestWithdraw";
+import openVaultPosition from "./pools/lendingPool/openVaultPosition";
+import { getAdapterAddress as getLendingPoolAdapterAddress, getAdapterAddressOnly as getLendingPoolAdapterAddressOnly } from "./pools/lendingPool/getAdapterAddress";
+import { getAdapterAddress as getRWAVaultAdapterAddress, getAdapterAddressOnly as getRWAVaultAdapterAddressOnly } from "./pools/rwaVault/getAdapterAddress";
+import getRWAVaultAdapters from "./pools/rwaVault/getAdapters";
+import getNFTApproval from "./nfts/getNFTApproval";
+import getApprovedForAll from "./nfts/getApprovalForAll";
+import setApprovalForAll from "./nfts/setApprovalForAll";
+import approveNFT from "./nfts/approveNFT";
+import vaultOpened from "./pools/lendingPool/vaultOpened";
+import { getWithdrawRequestInfo as getStabilityPoolWithdrawRequestInfo } from "./pools/stabilityPool/getWithdrawRequestInfo";
+import { requestWithdraw as requestStabilityPoolWithdraw } from "./pools/stabilityPool/requestWithdraw";
+import { getABI } from "./utils/artifacts";
+import { decodeErrorName, getErrorInfo, attachDecodedError, decodeErrorMessage, attachDecodedErrorMessage } from "./utils/errorDecoder";
 declare class RPCLibrary {
     signer: Signer | null;
     isConnected: boolean;
@@ -102,12 +118,14 @@ declare class RPCLibrary {
             mintAsset: typeof mintAsset;
             burnAsset: typeof burnAsset;
         };
+        rpcs: {};
     };
     nfts: {
         getBaseUri: typeof getBaseUri;
         mint: typeof mintNFT;
         getHousePrice: typeof getNFTHousePrice;
         getTokensByOwner: typeof getTokensByOwner;
+        getOwnerOfNFT: typeof getOwnerOfNFT;
         setBaseUri: typeof setNFTBaseUri;
         totalSupply: typeof totalNFTSupply;
         getMintPrice: typeof getMintPrice;
@@ -115,6 +133,10 @@ declare class RPCLibrary {
         getAllTokens: typeof getAllTokens;
         getTokenURI: typeof getTokenURI;
         getTotalPropertiesCount: typeof getTotalPropertiesCount;
+        getNFTApproval: typeof getNFTApproval;
+        getApprovedForAll: typeof getApprovedForAll;
+        setApprovalForAll: typeof setApprovalForAll;
+        approveNFT: typeof approveNFT;
     };
     contracts: {
         housePrices: {
@@ -131,6 +153,7 @@ declare class RPCLibrary {
         feeCollector: {
             claimRewardFromPool: typeof claimRewardFromPool;
         };
+        getABI: typeof getABI;
     };
     pools: {
         stabilityPool: {
@@ -138,6 +161,8 @@ declare class RPCLibrary {
             depositToStabilityPool: typeof depositToStabilityPool;
             withdrawFromStabilityPool: typeof withdrawFromStabilityPool;
             getRawUserDepositInStabilityPool: typeof getRawUserDepositInStabilityPool;
+            getWithdrawRequestInfo: typeof getStabilityPoolWithdrawRequestInfo;
+            requestWithdraw: typeof requestStabilityPoolWithdraw;
         };
         lendingPool: {
             getAdapters: typeof getAdapters;
@@ -145,8 +170,8 @@ declare class RPCLibrary {
             repayToLendingPool: typeof repayToLendingPool;
             borrowFromLendingPool: typeof borrowFromLendingPool;
             getHousePrice: typeof getHousePrice;
-            depositNFTToLendingPool: typeof depositNFTToLendingPool;
-            withdrawNFTFromLendingPool: typeof withdrawNFTFromLendingPool;
+            depositAssetToLendingPool: typeof depositAssetToLendingPool;
+            withdrawAssetFromLendingPool: typeof withdrawAssetFromLendingPool;
             getLendingPoolInfo: typeof getLendingPoolInfo;
             getRawUserDepositsInLendingPool: typeof getRawUserDepositsInLendingPool;
             getEligibleUserDeposits: typeof getEligibleUserDeposits;
@@ -157,6 +182,7 @@ declare class RPCLibrary {
             getPositionView: typeof getPositionView;
             getUserCollateralValue: typeof getUserCollateralValue;
             depositToLendingPool: typeof depositToLendingPool;
+            withdrawFromLendingPool: typeof withdrawFromLendingPool;
             initializeLiquidation: typeof initializeLiquidation;
             closeLiquidation: typeof closeLiquidation;
             borrowFromLendingPoolWithInsurance: typeof borrowFromLendingPoolWithInsurance;
@@ -165,6 +191,12 @@ declare class RPCLibrary {
             getERC20AdapterBalance: typeof getERC20AdapterBalance;
             getERC721AdapterInfo: typeof getERC721AdapterInfo;
             getERC721AdapterDeposits: typeof getERC721AdapterDeposits;
+            requestWithdraw: typeof requestWithdraw;
+            getWithdrawRequestInfo: typeof getWithdrawRequestInfo;
+            openVaultPosition: typeof openVaultPosition;
+            getAdapterAddress: typeof getLendingPoolAdapterAddress;
+            getAdapterAddressOnly: typeof getLendingPoolAdapterAddressOnly;
+            vaultOpened: typeof vaultOpened;
         };
         rwaVault: {
             depositToRWAVault: typeof depositToRWAVault;
@@ -179,6 +211,9 @@ declare class RPCLibrary {
             getERC721VaultAdapterDeposits: typeof getERC721VaultAdapterDeposits;
             getERC721VaultAdapterTotalValue: typeof getERC721VaultAdapterTotalValue;
             getERC721VaultAdapterAssetValue: typeof getERC721VaultAdapterAssetValue;
+            getAdapters: typeof getRWAVaultAdapters;
+            getAdapterAddress: typeof getRWAVaultAdapterAddress;
+            getAdapterAddressOnly: typeof getRWAVaultAdapterAddressOnly;
         };
         depositToLendingPool: typeof depositToLendingPool;
         withdrawFromLendingPool: typeof withdrawFromLendingPool;
@@ -202,6 +237,13 @@ declare class RPCLibrary {
     checkAllowance: typeof checkAllowance;
     getChainsConfig: typeof getChainsConfig;
     setChainsConfig: typeof setChainConfig;
+    errors: {
+        decodeErrorName: typeof decodeErrorName;
+        getErrorInfo: typeof getErrorInfo;
+        attachDecodedError: typeof attachDecodedError;
+        decodeErrorMessage: typeof decodeErrorMessage;
+        attachDecodedErrorMessage: typeof attachDecodedErrorMessage;
+    };
     constructor(privateKey?: string);
     getWallet(privateKey: string, provider: Provider): Promise<ethers.JsonRpcSigner | ethers.Wallet>;
     getProvider(chainId: ChainId, providerRpc?: string): Promise<ethers.BrowserProvider | ethers.JsonRpcProvider>;