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

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";
@@ -26,6 +26,8 @@ import redeemNFTFromRWAVault from "./pools/rwaVault/redeemNFTFromRWAVault";
 import getRWAVaultInfo from "./pools/rwaVault/getRWAVaultInfo";
 import getNextRandomNFT from "./pools/rwaVault/getNextRandomNFT";
 import requestRandomSeed from "./pools/rwaVault/requestRandomSeed";
+import previewDeposit from "./pools/rwaVault/previewDeposit";
+import previewWithdraw from "./pools/rwaVault/previewWithdraw";
 import getERC20VaultAdapterInfo from "./pools/rwaVault/adapters/erc20/getERC20VaultAdapterInfo";
 import getERC20VaultAdapterTotalValue from "./pools/rwaVault/adapters/erc20/getERC20VaultAdapterTotalValue";
 import getERC20VaultAdapterAssetValue from "./pools/rwaVault/adapters/erc20/getERC20VaultAdapterAssetValue";
@@ -37,6 +39,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,12 +83,19 @@ 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;
@@ -108,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;
@@ -121,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: {
@@ -137,6 +153,7 @@ declare class RPCLibrary {
         feeCollector: {
             claimRewardFromPool: typeof claimRewardFromPool;
         };
+        getABI: typeof getABI;
     };
     pools: {
         stabilityPool: {
@@ -144,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;
@@ -151,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;
@@ -163,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;
@@ -171,11 +191,10 @@ 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;
@@ -193,6 +212,8 @@ declare class RPCLibrary {
             getAdapters: typeof getRWAVaultAdapters;
             getAdapterAddress: typeof getRWAVaultAdapterAddress;
             getAdapterAddressOnly: typeof getRWAVaultAdapterAddressOnly;
+            previewDeposit: typeof previewDeposit;
+            previewWithdraw: typeof previewWithdraw;
         };
         depositToLendingPool: typeof depositToLendingPool;
         withdrawFromLendingPool: typeof withdrawFromLendingPool;
@@ -216,9 +237,16 @@ 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.JsonRpcProvider | ethers.BrowserProvider>;
+    getProvider(chainId: ChainId, providerRpc?: string): Promise<ethers.BrowserProvider | ethers.JsonRpcProvider>;
     getSigner(chainId: ChainId, address: string): Promise<ethers.JsonRpcSigner>;
     connectWallet(): Promise<void>;
     checkConnection(): Promise<void>;

package/dist/types/configs/chains/index.d.ts

@@ -1,14 +1,16 @@
-import { Chain8453, Chain11155111 } from "./chain";
+import { Chain8453 } from "./chain";
 declare const chains: {
     8453: Chain8453;
     17000: Chain8453;
-    11155111: Chain11155111;
+    11155111: Chain8453;
+    18453: Chain8453;
 };
 export default chains;
 export declare const configs: {
     8453: Chain8453;
     17000: Chain8453;
-    11155111: Chain11155111;
+    11155111: Chain8453;
+    18453: Chain8453;
 };
 export type Configs = typeof chains;
 export type ConfigKeys = keyof Configs;

package/dist/types/configs/index.d.ts

@@ -2,7 +2,8 @@ import { ChainId } from "./chains/index";
 declare function getChainsConfig(): {
     8453: import("./chains/chain").Chain8453;
     17000: import("./chains/chain").Chain8453;
-    11155111: import("./chains/chain").Chain11155111;
+    11155111: import("./chains/chain").Chain8453;
+    18453: import("./chains/chain").Chain8453;
 };
 declare function setChainConfig(chainId: ChainId, config: any): void;
 declare function getChainConfig(chainId: ChainId): any;

package/dist/types/nfts/approveNFT.d.ts

@@ -0,0 +1,9 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { configs } from "../configs/chains";
+type NftContractNames = {
+    [K in keyof typeof configs]: keyof (typeof configs)[K]['nfts'];
+}[keyof typeof configs];
+declare function approveNFT(chainId: ChainId, nftContractName: NftContractNames, approvedAddress: string, tokenId: string, signer: Signer): Promise<ethers.ContractTransactionReceipt>;
+export default approveNFT;
+export type { NftContractNames };

package/dist/types/nfts/getApprovalForAll.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Check if an address is approved for all tokens of an NFT contract (operator approval)
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param owner - The owner address
+ * @param operator - The operator address to check
+ * @param provider - The provider to use for the contract call
+ * @returns Boolean indicating if the operator is approved for all
+ */
+declare function getApprovedForAll(chainId: ChainId, nftContractName: NftContractNames, owner: string, operator: string, provider: Provider): Promise<boolean>;
+export default getApprovedForAll;

package/dist/types/nfts/getNFTApproval.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Check if an NFT token is approved for a specific address
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param tokenId - The token ID to check
+ * @param checkAddress - The address to check if it's approved
+ * @param provider - The provider to use for the contract call
+ * @returns Boolean indicating if the address is approved for the token
+ */
+declare function getNFTApproval(chainId: ChainId, nftContractName: NftContractNames, tokenId: string, checkAddress: string, provider: Provider): Promise<boolean>;
+export default getNFTApproval;

package/dist/types/nfts/getOwnerOfNFT.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Get the owner of an NFT token
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param tokenId - The token ID to check ownership for
+ * @param provider - The provider to use for the contract call
+ * @returns The owner address of the NFT, or null if the token doesn't exist or has no owner
+ */
+declare function getOwnerOfNFT(chainId: ChainId, nftContractName: NftContractNames, tokenId: string, provider: Provider): Promise<string | null>;
+export default getOwnerOfNFT;

package/dist/types/nfts/setApprovalForAll.d.ts

@@ -0,0 +1,14 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Set approval for all tokens of an NFT contract (operator approval)
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param operator - The operator address to approve/disapprove
+ * @param approved - Boolean indicating whether to approve or disapprove
+ * @param signer - The signer to use for the transaction
+ * @returns Transaction receipt
+ */
+declare function setApprovalForAll(chainId: ChainId, nftContractName: NftContractNames, operator: string, approved: boolean, signer: Signer): Promise<ethers.ContractTransactionReceipt>;
+export default setApprovalForAll;