@deserialize/multi-vm-wallet 1.4.2 → 1.5.0

package/dist/evm/transactionParsing.js

@@ -5,109 +5,47 @@ exports.getEVMTransactionHistoryWithAPI = getEVMTransactionHistoryWithAPI;
 const viem_1 = require("viem");
 const constant_1 = require("../constant");
 const helpers_1 = require("../helpers");
-// Mapping of chainId to RouteScan network name
 const CHAIN_ID_TO_NETWORK = {
-    1: 'mainnet', // Ethereum Mainnet
-    5: 'testnet', // Goerli
-    11155111: 'testnet', // Sepolia
-    137: 'mainnet', // Polygon
-    80001: 'testnet', // Polygon Mumbai
-    56: 'mainnet', // BSC
-    97: 'testnet', // BSC Testnet
-    43114: 'mainnet', // Avalanche
-    43113: 'testnet', // Avalanche Fuji
-    42161: 'mainnet', // Arbitrum
-    421611: 'testnet', // Arbitrum Testnet
-    10: 'mainnet', // Optimism
-    420: 'testnet', // Optimism Goerli
-    8453: 'mainnet', // Base
-    84531: 'testnet', // Base Goerli
-    16661: 'mainnet', // 0G Newton Testnet (using mainnet for simplicity)
+    1: 'mainnet',
+    5: 'testnet',
+    11155111: 'testnet',
+    137: 'mainnet',
+    80001: 'testnet',
+    56: 'mainnet',
+    97: 'testnet',
+    43114: 'mainnet',
+    43113: 'testnet',
+    42161: 'mainnet',
+    421611: 'testnet',
+    10: 'mainnet',
+    420: 'testnet',
+    8453: 'mainnet',
+    84531: 'testnet',
+    16661: 'mainnet',
 };
-// ERC20 Transfer event signature
 const ERC20_TRANSFER_EVENT = (0, viem_1.parseAbi)([
     'event Transfer(address indexed from, address indexed to, uint256 value)'
 ]);
-// ERC721 Transfer event signature
 const ERC721_TRANSFER_EVENT = (0, viem_1.parseAbi)([
     'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)'
 ]);
-// ERC1155 TransferSingle event signature
 const ERC1155_TRANSFER_SINGLE_EVENT = (0, viem_1.parseAbi)([
     'event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)'
 ]);
-// ERC1155 TransferBatch event signature
 const ERC1155_TRANSFER_BATCH_EVENT = (0, viem_1.parseAbi)([
     'event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)'
 ]);
-/**
- * Fetches and parses transaction history for an EVM wallet address
- * @param client - Viem public client
- * @param walletAddress - Ethereum address
- * @param options - Optional parameters for filtering and features
- * @returns Array of parsed transaction history items
- */
 async function getEVMTransactionHistory(client, walletAddress, options = {}) {
-    // const {
-    //     startBlock = 0n,
-    //     endBlock,
-    //     includeTokenTransfers = true,
-    //     includeNFTTransfers = true,
-    // } = options;
-    // try {
-    //     const currentBlock = await client.getBlockNumber();
-    //     const toBlock = endBlock || currentBlock;
-    //     // For wallet UI, we typically want recent transactions
-    //     // Start scanning from current block backwards
-    //     const scanStartBlock = startBlock > 0n ? startBlock : (currentBlock > 5000n ? currentBlock - 5000n : 0n);
-    //     console.log(`Fetching recent transactions from block ${scanStartBlock} to ${toBlock}`);
-    //     // Get transaction hashes for the address (max 15 transactions)
-    //     const txHashes = await getRecentTransactionHashes(
-    //         client,
-    //         walletAddress,
-    //         scanStartBlock,
-    //         toBlock,
-    //         15 // max transactions to fetch
-    //     );
-    //     console.log(`Found ${txHashes.length} unique transactions`);
-    //     // Fetch full transaction details in batches
-    //     const transactions = await fetchTransactionsInBatches(client, txHashes, 10);
-    //     // Parse each transaction
-    //     const history: EVMTransactionHistoryItem[] = [];
-    //     for (const { tx, receipt, block } of transactions) {
-    //         if (!tx || !receipt) continue;
-    //         const parsed = await parseEVMTransaction(
-    //             client,
-    //             tx,
-    //             receipt,
-    //             block?.timestamp || null,
-    //             walletAddress,
-    //             includeTokenTransfers,
-    //             includeNFTTransfers
-    //         );
-    //         history.push(parsed);
-    //     }
-    //     // Sort by block number (newest first)
-    //     history.sort((a, b) => Number(b.blockNumber - a.blockNumber));
-    //     return history;
-    // } catch (error) {
-    //     console.error('Error fetching EVM transaction history:', error);
-    //     throw error;
-    // }
     if (client.chain?.id === undefined)
         throw new Error("Chain Id is Undefined");
     const chainId = client.chain.id;
     const network = CHAIN_ID_TO_NETWORK[chainId];
-    // Try RouteScan first if network mapping exists
     if (network) {
         try {
             console.log(`Fetching transaction history from RouteScan for chain ${chainId} (${network})`);
-            const routeScanResponse = await helpers_1.RouteScanAPI.getTxList(network, chainId, walletAddress, 0, 99999999, 1, 20, // limit to 20 recent transactions
-            'desc' // newest first
-            );
+            const routeScanResponse = await helpers_1.RouteScanAPI.getTxList(network, chainId, walletAddress, 0, 99999999, 1, 20, 'desc');
             if (routeScanResponse.status === '1' && routeScanResponse.result) {
                 console.log(`RouteScan returned ${routeScanResponse.result.length} transactions`);
-                // Convert RouteScan format to our EVMTransactionHistoryItem format
                 return routeScanResponse.result.map(tx => ({
                     hash: tx.hash,
                     timestamp: parseInt(tx.timeStamp),
@@ -118,11 +56,9 @@ async function getEVMTransactionHistory(client, walletAddress, options = {}) {
                     to: tx.to || null,
                     blockNumber: BigInt(tx.blockNumber),
                     gasUsed: BigInt(tx.gasUsed),
-                    gasPrice: (0, viem_1.formatUnits)(BigInt(tx.gasPrice), 9), // gwei
+                    gasPrice: (0, viem_1.formatUnits)(BigInt(tx.gasPrice), 9),
                     value: (0, viem_1.formatEther)(BigInt(tx.value)),
                     method: tx.methodId || undefined,
-                    // Token and NFT transfers would need additional API calls
-                    // We'll skip them for now to keep it simple
                 }));
             }
         }
@@ -130,34 +66,26 @@ async function getEVMTransactionHistory(client, walletAddress, options = {}) {
             console.warn('RouteScan failed, falling back to HelperAPI:', error);
         }
     }
-    // Fallback to HelperAPI
     console.log(`Fetching transaction history from HelperAPI for chain ${chainId}`);
     return await helpers_1.HelperAPI.getTransactionHistory(walletAddress, "EVM", chainId);
 }
-/**
- * Determine transaction type from input data and value (simpler version for RouteScan data)
- */
 function determineTransactionTypeFromInput(input, value) {
     if (input === '0x' || input === '') {
         return BigInt(value) > 0n ? constant_1.TRANSACTION_TYPE.NATIVE_TRANSFER : constant_1.TRANSACTION_TYPE.CONTRACT_INTERACTION;
     }
     const methodSig = input.slice(0, 10);
     if (methodSig === '0xa9059cbb')
-        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER; // ERC20 transfer
+        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER;
     if (methodSig === '0x23b872dd')
-        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER; // ERC20 transferFrom
+        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER;
     if (methodSig === '0x42842e0e')
-        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER; // ERC721 safeTransferFrom
+        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER;
     if (methodSig === '0xf242432a')
-        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER; // ERC1155 safeTransferFrom
+        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER;
     if (BigInt(value) > 0n)
         return constant_1.TRANSACTION_TYPE.NATIVE_TRANSFER;
     return constant_1.TRANSACTION_TYPE.CONTRACT_INTERACTION;
 }
-/**
- * Gets recent transaction hashes by scanning blocks backwards
- * Uses batched parallel requests for better performance
- */
 async function getRecentTransactionHashes(client, address, startBlock, endBlock, maxTransactions = 15, batchSize = 9) {
     const txHashes = [];
     const seenHashes = new Map();
@@ -165,16 +93,13 @@ async function getRecentTransactionHashes(client, address, startBlock, endBlock,
     let currentBlock = endBlock;
     let blocksScanned = 0n;
     console.log(`Scanning blocks backwards from ${endBlock}...`);
-    // Iterate backwards in batches
     while (currentBlock >= startBlock && txHashes.length < maxTransactions) {
-        // Create batch of block numbers to fetch
         const blockNumbers = [];
         for (let i = 0; i < batchSize && currentBlock >= startBlock; i++) {
             blockNumbers.push(currentBlock);
             currentBlock--;
         }
         try {
-            // Fetch all blocks in parallel
             const blocks = await Promise.all(blockNumbers.map(blockNumber => client.getBlock({
                 blockNumber,
                 includeTransactions: true,
@@ -184,14 +109,12 @@ async function getRecentTransactionHashes(client, address, startBlock, endBlock,
             })));
             blocks.length;
             console.log('blocks.length: ', blocks.length);
-            // Process blocks in order (newest to oldest)
             for (const block of blocks) {
                 if (!block || !block.transactions)
                     continue;
                 for (let i = 0; i < block.transactions.length && txHashes.length < maxTransactions; i++) {
                     const tx = block.transactions[i];
                     if (typeof tx === 'object') {
-                        // Check if wallet is sender or receiver
                         const isSender = tx.from.toLowerCase() === addressLower;
                         const isReceiver = tx.to?.toLowerCase() === addressLower;
                         if ((isSender || isReceiver) && !seenHashes.has(tx.hash)) {
@@ -203,12 +126,10 @@ async function getRecentTransactionHashes(client, address, startBlock, endBlock,
                         console.log("Transaction is not an object: ", tx);
                     }
                 }
-                // Early exit if we found enough transactions
                 if (txHashes.length >= maxTransactions)
                     break;
             }
             blocksScanned += BigInt(blockNumbers.length);
-            // Log progress
             if (blocksScanned % 50n === 0n || blocksScanned < 50n) {
                 console.log(`Scanned ${blocksScanned} blocks, found ${txHashes.length} transactions`);
             }
@@ -221,19 +142,14 @@ async function getRecentTransactionHashes(client, address, startBlock, endBlock,
     console.log(`Found ${txHashes.length} transactions after scanning ${blocksScanned} blocks`);
     return txHashes;
 }
-/**
- * Alternative function that uses Etherscan-like API
- * This is the recommended approach for production use
- */
 async function getEVMTransactionHistoryWithAPI(client, walletAddress, apiEndpoint, apiKey, options = {}) {
     const { includeTokenTransfers = true, includeNFTTransfers = true } = options;
     try {
-        // Fetch normal transactions
         const normalTxResponse = await fetch(`${apiEndpoint}?module=account&action=txlist&address=${walletAddress}&startblock=0&endblock=99999999&sort=desc&apikey=${apiKey}`);
         const normalTxData = await normalTxResponse.json();
         const history = [];
         if (normalTxData.status === '1' && normalTxData.result) {
-            for (const tx of normalTxData.result.slice(0, 50)) { // Limit to 50 most recent
+            for (const tx of normalTxData.result.slice(0, 50)) {
                 const receipt = await client.getTransactionReceipt({ hash: tx.hash });
                 const parsed = await parseEVMTransaction(client, {
                     hash: tx.hash,
@@ -256,16 +172,11 @@ async function getEVMTransactionHistoryWithAPI(client, walletAddress, apiEndpoin
         throw error;
     }
 }
-/**
- * Fetches transaction hashes for an address by iterating through blocks
- * Efficient for recent transactions (last 10-15 txs)
- */
 async function getTransactionHashesByAddress(client, address, startBlock, endBlock, direction, maxTransactions = 15) {
     const txHashes = [];
     const addressLower = address.toLowerCase();
     let currentBlock = endBlock;
     console.log(`Scanning blocks backwards from ${endBlock} to ${startBlock}...`);
-    // Iterate backwards from most recent block
     while (currentBlock >= startBlock && txHashes.length < maxTransactions) {
         try {
             const block = await client.getBlock({
@@ -274,7 +185,6 @@ async function getTransactionHashesByAddress(client, address, startBlock, endBlo
             });
             if (block.transactions) {
                 for (const tx of block.transactions) {
-                    // Check if transaction matches the direction filter
                     if (typeof tx === 'object') {
                         const matchesDirection = (direction === 'from' && tx.from.toLowerCase() === addressLower) ||
                             (direction === 'to' && tx.to?.toLowerCase() === addressLower) ||
@@ -282,7 +192,6 @@ async function getTransactionHashesByAddress(client, address, startBlock, endBlo
                             (direction === 'to' && tx.to?.toLowerCase() === addressLower);
                         if (matchesDirection) {
                             txHashes.push(tx.hash);
-                            // Stop if we've found enough transactions
                             if (txHashes.length >= maxTransactions) {
                                 break;
                             }
@@ -291,7 +200,6 @@ async function getTransactionHashesByAddress(client, address, startBlock, endBlo
                 }
             }
             currentBlock--;
-            // Log progress every 100 blocks
             if ((endBlock - currentBlock) % 100n === 0n) {
                 console.log(`Scanned ${endBlock - currentBlock} blocks, found ${txHashes.length} transactions`);
             }
@@ -305,9 +213,6 @@ async function getTransactionHashesByAddress(client, address, startBlock, endBlo
     console.log(`Found ${txHashes.length} transactions after scanning ${endBlock - currentBlock} blocks`);
     return txHashes;
 }
-/**
- * Fetches full transaction details in batches
- */
 async function fetchTransactionsInBatches(client, hashes, batchSize) {
     const results = [];
     for (let i = 0; i < hashes.length; i += batchSize) {
@@ -330,28 +235,21 @@ async function fetchTransactionsInBatches(client, hashes, batchSize) {
             }
         }));
         results.push(...batchResults);
-        // Small delay to avoid rate limiting
         if (i + batchSize < hashes.length) {
             await new Promise(resolve => setTimeout(resolve, 100));
         }
     }
     return results;
 }
-/**
- * Parses a single EVM transaction
- */
 async function parseEVMTransaction(client, tx, receipt, timestamp, walletAddress, includeTokenTransfers, includeNFTTransfers) {
     const gasUsed = receipt.gasUsed;
     const effectiveGasPrice = receipt.effectiveGasPrice || tx.gasPrice || 0n;
     const fee = (0, viem_1.formatEther)(gasUsed * effectiveGasPrice);
-    const gasPrice = (0, viem_1.formatUnits)(effectiveGasPrice, 9); // gwei
-    // Determine transaction type
+    const gasPrice = (0, viem_1.formatUnits)(effectiveGasPrice, 9);
     const type = determineTransactionType(tx, receipt);
-    // Extract method signature
     const method = tx.input && tx.input.length >= 10
         ? tx.input.slice(0, 10)
         : undefined;
-    // Parse token transfers from logs
     let tokenTransfers = [];
     let nftTransfers = [];
     if (includeTokenTransfers || includeNFTTransfers) {
@@ -376,27 +274,20 @@ async function parseEVMTransaction(client, tx, receipt, timestamp, walletAddress
         nftTransfers: nftTransfers.length > 0 ? nftTransfers : undefined,
     };
 }
-/**
- * Determines the transaction type
- */
 function determineTransactionType(tx, receipt) {
-    // Contract creation
     if (!tx.to)
         return constant_1.TRANSACTION_TYPE.CONTRACT_CREATION;
-    // Check if it's a token/NFT transfer based on method signature
     const methodSig = tx.input?.slice(0, 10);
     if (methodSig === '0xa9059cbb')
-        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER; // ERC20 transfer
+        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER;
     if (methodSig === '0x23b872dd')
-        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER; // ERC20 transferFrom
+        return constant_1.TRANSACTION_TYPE.TOKEN_TRANSFER;
     if (methodSig === '0x42842e0e')
-        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER; // ERC721 safeTransferFrom
+        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER;
     if (methodSig === '0xf242432a')
-        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER; // ERC1155 safeTransferFrom
-    // Check value
+        return constant_1.TRANSACTION_TYPE.NFT_TRANSFER;
     if (tx.value && tx.value > 0n)
         return constant_1.TRANSACTION_TYPE.NATIVE_TRANSFER;
-    // Check logs for common patterns
     if (receipt.logs.some(log => log.topics[0]?.includes('Swap')))
         return constant_1.TRANSACTION_TYPE.SWAP;
     if (receipt.logs.some(log => log.topics[0]?.includes('Deposit')))
@@ -405,15 +296,11 @@ function determineTransactionType(tx, receipt) {
         return constant_1.TRANSACTION_TYPE.WITHDRAWAL;
     return constant_1.TRANSACTION_TYPE.CONTRACT_INTERACTION;
 }
-/**
- * Parses transfer events from transaction logs
- */
 async function parseTransferLogs(client, logs, walletAddress, includeTokenTransfers, includeNFTTransfers) {
     const tokens = [];
     const nfts = [];
     for (const log of logs) {
         try {
-            // Try ERC20 Transfer
             if (includeTokenTransfers && log.topics.length === 3) {
                 try {
                     const decoded = (0, viem_1.decodeEventLog)({
@@ -423,10 +310,8 @@ async function parseTransferLogs(client, logs, walletAddress, includeTokenTransf
                     });
                     if (decoded.eventName === 'Transfer') {
                         const { from, to, value } = decoded.args;
-                        // Only include if wallet is involved
                         if (from.toLowerCase() === walletAddress.toLowerCase() ||
                             to.toLowerCase() === walletAddress.toLowerCase()) {
-                            // Try to get token info (this might fail for non-standard tokens)
                             let decimals = 18;
                             try {
                                 decimals = await client.readContract({
@@ -450,7 +335,6 @@ async function parseTransferLogs(client, logs, walletAddress, includeTokenTransf
                 }
                 catch { }
             }
-            // Try ERC721 Transfer (has indexed tokenId)
             if (includeNFTTransfers && log.topics.length === 4) {
                 try {
                     const decoded = (0, viem_1.decodeEventLog)({
@@ -474,7 +358,6 @@ async function parseTransferLogs(client, logs, walletAddress, includeTokenTransf
                 }
                 catch { }
             }
-            // Try ERC1155 TransferSingle
             if (includeNFTTransfers) {
                 try {
                     const decoded = (0, viem_1.decodeEventLog)({
@@ -501,10 +384,8 @@ async function parseTransferLogs(client, logs, walletAddress, includeTokenTransf
             }
         }
         catch (error) {
-            // Skip logs that don't match our patterns
             continue;
         }
     }
     return { tokens, nfts };
 }
-//# sourceMappingURL=transactionParsing.js.map

package/dist/evm/utils.d.ts

@@ -180,9 +180,6 @@ export declare function viemReceiptToEthersReceipt(receipt: ViemTransactionRecei
 export declare const getNativeBalance: (address: Hex, client: PublicClient) => Promise<Balance>;
 export declare const getTokenInfo: (tokenAddress: Hex, client: PublicClient) => Promise<TokenInfo>;
 export declare const getTokenBalance: (tokenAddress: Hex, walletAddress: Hex, client: PublicClient) => Promise<Balance>;
-/**
- * Sign, send, and confirm any EVM transaction
- */
 export declare const signSendAndConfirm: (walletClient: WalletClient, publicClient: PublicClient, params: {
     to: Hex;
     data?: Hex;
@@ -192,25 +189,13 @@ export declare const signSendAndConfirm: (walletClient: WalletClient, publicClie
     maxFeePerGas?: bigint;
     maxPriorityFeePerGas?: bigint;
 }, confirmations?: number) => Promise<TransactionResult>;
-/**
- * Send native token (ETH, BNB, MATIC, etc.)
- */
 export declare const sendNativeToken: (walletClient: WalletClient, publicClient: PublicClient, to: Hex, amount: string | bigint, confirmations?: number) => Promise<TransactionResult>;
-/**
- * Send ERC-20 token
- */
 export declare const sendERC20Token: (walletClient: WalletClient, publicClient: PublicClient, tokenAddress: Hex, to: Hex, amount: bigint, confirmations?: number) => Promise<TransactionResult>;
-/**
- * Get current gas prices (both legacy and EIP-1559)
- */
 export declare const getGasPrices: (client: PublicClient) => Promise<{
     gasPrice: undefined;
     maxFeePerGas: bigint;
     maxPriorityFeePerGas: bigint;
 }>;
-/**
- * Estimate gas for a transaction
- */
 export declare const estimateGas: (client: PublicClient, params: {
     to: Hex;
     data?: Hex;
@@ -221,34 +206,15 @@ export declare const checkAllowance: (client: PublicClient, tokenAddress: Hex, o
     formatted: string;
     decimals: number;
 }>;
-/**
- * Check if allowance is sufficient for a transaction
- */
 export declare const isAllowanceSufficient: (publicClient: PublicClient, tokenAddress: `0x${string}`, owner: `0x${string}`, spender: `0x${string}`, requiredAmount: string | bigint) => Promise<boolean>;
-/**
- * Approve ERC-20 token spending
- */
 export declare const approveToken: (walletClient: WalletClient, publicClient: PublicClient, tokenAddress: Hex, spender: Hex, amount: bigint, confirmations?: number) => Promise<TransactionResult>;
-/**
- * Approve unlimited token spending (MaxUint256)
- */
 export declare const approveTokenUnlimited: (walletClient: WalletClient, publicClient: PublicClient, tokenAddress: `0x${string}`, spender: `0x${string}`, gas?: bigint, confirmations?: number) => Promise<TransactionResult>;
-/**
- * Check allowance and approve if necessary
- */
 export declare const checkAndApprove: (walletClient: WalletClient, publicClient: PublicClient, tokenAddress: `0x${string}`, spender: `0x${string}`, requiredAmount: bigint, approvalAmount?: bigint, gas?: bigint, confirmations?: number) => Promise<{
     approvalNeeded: boolean;
     currentAllowance: bigint;
     approvalResult?: TransactionResult;
 }>;
-/**
- * Reset token allowance to zero (security best practice before setting new allowance)
- */
 export declare const resetAllowance: (walletClient: WalletClient, publicClient: PublicClient, tokenAddress: `0x${string}`, spender: `0x${string}`, gas?: bigint, confirmations?: number) => Promise<TransactionResult>;
-/**
- * Safe approve: Reset to zero first, then approve the desired amount
- * (Some tokens like USDT require this)
- */
 export declare const safeApprove: (walletClient: WalletClient, publicClient: PublicClient, tokenAddress: `0x${string}`, spender: `0x${string}`, amount: bigint, gas?: bigint, confirmations?: number) => Promise<{
     resetResult: TransactionResult;
     approveResult: TransactionResult;
@@ -256,21 +222,9 @@ export declare const safeApprove: (walletClient: WalletClient, publicClient: Pub
 export declare const discoverTokens: (wallet: string, chain: ChainWalletConfig) => Promise<UserTokenBalance<string>[]>;
 export declare function calcGasTotal(gasLimit?: string, gasPrice?: string): string;
 export declare function toPrecisionWithoutTrailingZeros(n: number, precision: number): string;
-/**
- * @param {number|string|BigNumber} value
- * @param {number=} decimals
- * @returns {BigNumber}
- */
 export declare function calcTokenAmount(value: number | string | BigNumber, decimals?: number): BigNumber;
 export declare const transformEVMNFTToUnified: (nft: EVMNFT) => NFT;
 export declare const discoverNFTs: (wallet: string, chain: ChainWalletConfig) => Promise<NFT[]>;
 export declare const discoverAllNFTs: (wallet: string, chain: ChainWalletConfig) => Promise<NFT[]>;
-/**
- * Get NFT collection details for a specific collection
- * @param wallet - User's wallet address
- * @param collectionAddress - The NFT collection contract address
- * @param chain - Chain configuration
- * @returns NFTCollection object with collection details and user's NFTs in that collection
- */
 export declare const getNFTCollection: (wallet: string, collectionAddress: string, chain: ChainWalletConfig) => Promise<NFTCollection | null>;
 export {};