pwc-sdk-wallet 0.6.3

package/dist/services/TokenUtils.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviderAuto = getProviderAuto;
+exports.getTokenBalance = getTokenBalance;
+exports.getTokenInfo = getTokenInfo;
+exports.getNativeBalance = getNativeBalance;
+exports.checkAllowance = checkAllowance;
+exports.buildTransaction = buildTransaction;
+exports.signTransactionWithVault = signTransactionWithVault;
+exports.approveTokenWithVault = approveTokenWithVault;
+exports.sendTransaction = sendTransaction;
+exports.trackTxStatus = trackTxStatus;
+exports.getNonce = getNonce;
+exports.signMessageWithVault = signMessageWithVault;
+exports.signMessage = signMessage;
+exports.verifyMessage = verifyMessage;
+exports.signTypedDataWithVault = signTypedDataWithVault;
+exports.signTypedData = signTypedData;
+exports.verifyTypedData = verifyTypedData;
+exports.signMessageWithNonce = signMessageWithNonce;
+exports.signMessageWithNoncePrivateKey = signMessageWithNoncePrivateKey;
+exports.verifyMessageWithNonce = verifyMessageWithNonce;
+const ethers_1 = require("ethers");
+const chains_1 = require("../config/chains");
+const ERC20_ABI = [
+    "function name() view returns (string)",
+    "function symbol() view returns (string)",
+    "function decimals() view returns (uint8)",
+    "function totalSupply() view returns (uint256)",
+    "function balanceOf(address) view returns (uint)",
+    "function transfer(address to, uint amount) returns (bool)",
+    "function approve(address spender, uint amount) returns (bool)",
+    "function allowance(address owner, address spender) view returns (uint)"
+];
+// Provider manager: cache provider per chainId
+const providerCache = {};
+/**
+ * Gets or creates a cached provider for the specified chain.
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Cached ethers provider for the chain
+ */
+function getProviderAuto(chainId) {
+    if (!providerCache[chainId]) {
+        providerCache[chainId] = (0, chains_1.getProvider)(chainId);
+    }
+    return providerCache[chainId];
+}
+/**
+ * Gets the token balance for a specific account.
+ * @param tokenAddress - The ERC-20 token contract address
+ * @param account - The account address to check balance for
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the token balance as bigint
+ * @example
+ * ```typescript
+ * const balance = await getTokenBalance('0xToken...', '0xAccount...', '1');
+ * console.log('Balance:', ethers.formatUnits(balance, 18));
+ * ```
+ */
+async function getTokenBalance(tokenAddress, account, chainId) {
+    const provider = getProviderAuto(chainId);
+    const contract = new ethers_1.Contract(tokenAddress, ERC20_ABI, provider);
+    return contract.balanceOf(account);
+}
+/**
+ * Gets comprehensive information about an ERC-20 token.
+ * @param tokenAddress - The ERC-20 token contract address
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to token information including name, symbol, decimals, total supply
+ * @example
+ * ```typescript
+ * const info = await getTokenInfo('0xToken...', '1');
+ * console.log('Token:', info.name, '(', info.symbol, ')');
+ * ```
+ */
+async function getTokenInfo(tokenAddress, chainId) {
+    const provider = getProviderAuto(chainId);
+    const contract = new ethers_1.Contract(tokenAddress, ERC20_ABI, provider);
+    const [name, symbol, decimals, totalSupply] = await Promise.all([
+        contract.name(),
+        contract.symbol(),
+        contract.decimals(),
+        contract.totalSupply()
+    ]);
+    return { name, symbol, decimals, totalSupply, address: tokenAddress };
+}
+/**
+ * Gets the native token balance (ETH, BNB, MATIC, etc.) for an account.
+ * @param account - The account address to check balance for
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the native token balance as bigint
+ * @example
+ * ```typescript
+ * const balance = await getNativeBalance('0xAccount...', '1');
+ * console.log('ETH Balance:', ethers.formatEther(balance));
+ * ```
+ */
+async function getNativeBalance(account, chainId) {
+    const provider = getProviderAuto(chainId);
+    return provider.getBalance(account);
+}
+/**
+ * Checks the allowance granted by an owner to a spender for a specific token.
+ * @param tokenAddress - The ERC-20 token contract address
+ * @param owner - The token owner's address
+ * @param spender - The spender's address (e.g., DEX contract address)
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the allowance amount as bigint
+ * @example
+ * ```typescript
+ * const allowance = await checkAllowance('0xToken...', '0xOwner...', '0xSpender...', '1');
+ * console.log('Allowance:', ethers.formatUnits(allowance, 18));
+ * ```
+ */
+async function checkAllowance(tokenAddress, owner, spender, chainId) {
+    const provider = getProviderAuto(chainId);
+    const contract = new ethers_1.Contract(tokenAddress, ERC20_ABI, provider);
+    return contract.allowance(owner, spender);
+}
+/**
+ * Builds a generic transaction for any contract method.
+ * @param contractAddress - The contract address to interact with
+ * @param abi - The contract ABI array
+ * @param method - The method name to call
+ * @param args - Arguments to pass to the method (default: [])
+ * @param value - Native token value to send with transaction (default: undefined)
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the unsigned transaction object
+ * @example
+ * ```typescript
+ * const tx = await buildTransaction({
+ *   contractAddress: '0xContract...',
+ *   abi: [...],
+ *   method: 'transfer',
+ *   args: ['0xTo...', '1000000000000000000'],
+ *   chainId: '1'
+ * });
+ * ```
+ */
+async function buildTransaction({ contractAddress, abi, method, args = [], value = undefined, chainId }) {
+    const provider = getProviderAuto(chainId);
+    const contract = new ethers_1.Contract(contractAddress, abi, provider);
+    const data = contract.interface.encodeFunctionData(method, args);
+    return {
+        to: contractAddress,
+        data,
+        value
+    };
+}
+/**
+ * Signs an unsigned transaction using Vault (RECOMMENDED).
+ * @param unsignedTx - The unsigned transaction object
+ * @param vault - The vault instance containing the account
+ * @param fromAddress - The sender's address
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the signed transaction as hex string
+ * @example
+ * ```typescript
+ * const signedTx = await signTransactionWithVault(unsignedTx, vault, '0xYourAddress', '1');
+ * ```
+ */
+async function signTransactionWithVault(unsignedTx, vault, fromAddress, chainId) {
+    const privateKey = await vault.getPrivateKeyFor(fromAddress);
+    const provider = (0, chains_1.getProvider)(chainId);
+    const wallet = new ethers_1.Wallet(privateKey, provider);
+    return wallet.signTransaction(unsignedTx);
+}
+/**
+ * Approves a spender to spend tokens on behalf of the owner using Vault (RECOMMENDED).
+ * @param vault - The vault instance containing the owner's account
+ * @param fromAddress - The owner's address
+ * @param tokenAddress - The ERC-20 token contract address
+ * @param spender - The spender's address (e.g., DEX contract address)
+ * @param amount - The amount to approve (string or bigint)
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the transaction response
+ * @example
+ * ```typescript
+ * const receipt = await approveTokenWithVault(vault, '0xOwner...', '0xToken...', '0xSpender...', '1000', '1');
+ * ```
+ */
+async function approveTokenWithVault(vault, fromAddress, tokenAddress, spender, amount, chainId) {
+    const privateKey = await vault.getPrivateKeyFor(fromAddress);
+    const provider = (0, chains_1.getProvider)(chainId);
+    const wallet = new ethers_1.Wallet(privateKey, provider);
+    const contract = new ethers_1.Contract(tokenAddress, ERC20_ABI, wallet);
+    const decimals = await contract.decimals();
+    const parsedAmount = typeof amount === 'string' ? ethers_1.ethers.parseUnits(amount, decimals) : amount;
+    const tx = await contract.approve(spender, parsedAmount);
+    if (typeof tx.wait === 'function') {
+        return tx.wait();
+    }
+    return tx;
+}
+/**
+ * Broadcasts a signed transaction to the network.
+ * @param signedTx - The signed transaction as hex string
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the transaction response
+ * @example
+ * ```typescript
+ * const txResponse = await sendTransaction(signedTx, '1');
+ * console.log('Transaction hash:', txResponse.hash);
+ * ```
+ */
+async function sendTransaction(signedTx, chainId) {
+    const provider = getProviderAuto(chainId);
+    return provider.broadcastTransaction(signedTx);
+}
+/**
+ * Tracks the status of a transaction with polling and callback notifications.
+ * @param txHash - The transaction hash to track
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @param callback - Function called with status updates ('pending', 'confirmed', 'failed')
+ * @param pollInterval - Polling interval in milliseconds (default: 3000)
+ * @example
+ * ```typescript
+ * trackTxStatus('0xTxHash...', '1', (status, receipt) => {
+ *   if (status === 'confirmed') {
+ *     console.log('Transaction confirmed!');
+ *   }
+ * });
+ * ```
+ */
+async function trackTxStatus(txHash, chainId, callback, pollInterval = 3000) {
+    const provider = getProviderAuto(chainId);
+    let done = false;
+    while (!done) {
+        const receipt = await provider.getTransactionReceipt(txHash);
+        if (receipt) {
+            if (receipt.status === 1) {
+                callback('confirmed', receipt);
+            }
+            else {
+                callback('failed', receipt);
+            }
+            done = true;
+        }
+        else {
+            callback('pending');
+            await new Promise(res => setTimeout(res, pollInterval));
+        }
+    }
+}
+/**
+ * Gets the transaction count (nonce) for an address.
+ * This is useful for message signing with nonce and transaction building.
+ * @param address - The address to get nonce for
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to the nonce as number
+ * @example
+ * ```typescript
+ * const nonce = await getNonce('0xYourAddress', '1');
+ * console.log('Current nonce:', nonce);
+ * ```
+ */
+async function getNonce(address, chainId) {
+    const provider = getProviderAuto(chainId);
+    return provider.getTransactionCount(address);
+}
+/**
+ * Signs a message using Vault (RECOMMENDED).
+ * This is equivalent to MetaMask's personal_sign method.
+ * @param message - The message to sign (string or hex string)
+ * @param vault - The vault instance containing the account
+ * @param fromAddress - The signer's address
+ * @returns Promise resolving to the signature as hex string
+ * @example
+ * ```typescript
+ * const signature = await signMessageWithVault('Hello World', vault, '0xYourAddress');
+ * console.log('Signature:', signature);
+ * ```
+ */
+async function signMessageWithVault(message, vault, fromAddress) {
+    const privateKey = await vault.getPrivateKeyFor(fromAddress);
+    const wallet = new ethers_1.Wallet(privateKey);
+    return wallet.signMessage(message);
+}
+/**
+ * Signs a message using private key (DEPRECATED).
+ * ⚠️ **DEPRECATED**: Use signMessageWithVault instead for better security.
+ * @param message - The message to sign (string or hex string)
+ * @param privateKey - The private key to sign with (without 0x prefix)
+ * @returns Promise resolving to the signature as hex string
+ * @example
+ * ```typescript
+ * const signature = await signMessage('Hello World', 'your-private-key');
+ * console.log('Signature:', signature);
+ * ```
+ */
+async function signMessage(message, privateKey) {
+    const wallet = new ethers_1.Wallet(privateKey);
+    return wallet.signMessage(message);
+}
+/**
+ * Verifies a message signature and returns the signer's address.
+ * @param message - The original message that was signed
+ * @param signature - The signature to verify
+ * @returns Promise resolving to the signer's address
+ * @example
+ * ```typescript
+ * const signerAddress = await verifyMessage('Hello World', '0xSignature...');
+ * console.log('Message was signed by:', signerAddress);
+ * ```
+ */
+async function verifyMessage(message, signature) {
+    return ethers_1.ethers.verifyMessage(message, signature);
+}
+/**
+ * Signs a typed data message using Vault (RECOMMENDED).
+ * This is equivalent to MetaMask's eth_signTypedData method.
+ * @param typedData - The typed data object to sign
+ * @param vault - The vault instance containing the account
+ * @param fromAddress - The signer's address
+ * @returns Promise resolving to the signature as hex string
+ * @example
+ * ```typescript
+ * const typedData = {
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' }
+ *     ]
+ *   },
+ *   primaryType: 'Person',
+ *   domain: { name: 'MyApp', version: '1' },
+ *   message: { name: 'Alice', wallet: '0x123...' }
+ * };
+ * const signature = await signTypedDataWithVault(typedData, vault, '0xYourAddress');
+ * ```
+ */
+async function signTypedDataWithVault(typedData, vault, fromAddress) {
+    const privateKey = await vault.getPrivateKeyFor(fromAddress);
+    const wallet = new ethers_1.Wallet(privateKey);
+    return wallet.signTypedData(typedData.domain, typedData.types, typedData.message);
+}
+/**
+ * Signs a typed data message using private key (DEPRECATED).
+ * ⚠️ **DEPRECATED**: Use signTypedDataWithVault instead for better security.
+ * @param typedData - The typed data object to sign
+ * @param privateKey - The private key to sign with (without 0x prefix)
+ * @returns Promise resolving to the signature as hex string
+ * @example
+ * ```typescript
+ * const typedData = {
+ *   types: { Person: [{ name: 'name', type: 'string' }] },
+ *   primaryType: 'Person',
+ *   domain: { name: 'MyApp' },
+ *   message: { name: 'Alice' }
+ * };
+ * const signature = await signTypedData(typedData, 'your-private-key');
+ * ```
+ */
+async function signTypedData(typedData, privateKey) {
+    const wallet = new ethers_1.Wallet(privateKey);
+    return wallet.signTypedData(typedData.domain, typedData.types, typedData.message);
+}
+/**
+ * Verifies a typed data signature and returns the signer's address.
+ * @param typedData - The original typed data that was signed
+ * @param signature - The signature to verify
+ * @returns Promise resolving to the signer's address
+ * @example
+ * ```typescript
+ * const signerAddress = await verifyTypedData(typedData, '0xSignature...');
+ * console.log('Typed data was signed by:', signerAddress);
+ * ```
+ */
+async function verifyTypedData(typedData, signature) {
+    return ethers_1.ethers.verifyTypedData(typedData.domain, typedData.types, typedData.message, signature);
+}
+/**
+ * Signs a message with nonce using Vault (RECOMMENDED).
+ * This includes nonce in the message to prevent replay attacks.
+ * @param message - The message to sign (string or hex string)
+ * @param vault - The vault instance containing the account
+ * @param fromAddress - The signer's address
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to an object containing signature and nonce
+ * @example
+ * ```typescript
+ * const result = await signMessageWithNonce('Hello World', vault, '0xYourAddress', '1');
+ * console.log('Signature:', result.signature);
+ * console.log('Nonce:', result.nonce);
+ * ```
+ */
+async function signMessageWithNonce(message, vault, fromAddress, chainId) {
+    const nonce = await getNonce(fromAddress, chainId);
+    const messageWithNonce = `${message}\nNonce: ${nonce}`;
+    const signature = await signMessageWithVault(messageWithNonce, vault, fromAddress);
+    return { signature, nonce };
+}
+/**
+ * Signs a message with nonce using private key (DEPRECATED).
+ * ⚠️ **DEPRECATED**: Use signMessageWithNonceWithVault instead for better security.
+ * @param message - The message to sign (string or hex string)
+ * @param privateKey - The private key to sign with (without 0x prefix)
+ * @param address - The signer's address (needed to get nonce)
+ * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
+ * @returns Promise resolving to an object containing signature and nonce
+ * @example
+ * ```typescript
+ * const result = await signMessageWithNoncePrivateKey('Hello World', 'your-private-key', '0xYourAddress', '1');
+ * console.log('Signature:', result.signature);
+ * console.log('Nonce:', result.nonce);
+ * ```
+ */
+async function signMessageWithNoncePrivateKey(message, privateKey, address, chainId) {
+    const nonce = await getNonce(address, chainId);
+    const messageWithNonce = `${message}\nNonce: ${nonce}`;
+    const signature = await signMessage(messageWithNonce, privateKey);
+    return { signature, nonce };
+}
+/**
+ * Verifies a message signature with nonce and returns the signer's address.
+ * @param message - The original message that was signed (without nonce)
+ * @param signature - The signature to verify
+ * @param nonce - The nonce that was used in signing
+ * @returns Promise resolving to the signer's address
+ * @example
+ * ```typescript
+ * const signerAddress = await verifyMessageWithNonce('Hello World', '0xSignature...', 5);
+ * console.log('Message was signed by:', signerAddress);
+ * ```
+ */
+async function verifyMessageWithNonce(message, signature, nonce) {
+    const messageWithNonce = `${message}\nNonce: ${nonce}`;
+    return verifyMessage(messageWithNonce, signature);
+}

package/dist/services/nft/MetadataResolver.d.ts

@@ -0,0 +1,57 @@
+import { NFTMetadata } from '../../types/nft';
+/**
+ * Service for resolving NFT metadata from various sources (IPFS, HTTP)
+ */
+export declare class MetadataResolver {
+    private static readonly IPFS_GATEWAYS;
+    private static readonly CACHE_DURATION;
+    private static metadataCache;
+    /**
+     * Resolves metadata from a URI (IPFS or HTTP)
+     * @param uri - The metadata URI to resolve
+     * @returns Promise resolving to NFT metadata
+     */
+    resolveMetadata(uri: string): Promise<NFTMetadata>;
+    /**
+     * Resolves IPFS URI to HTTP URL using multiple gateways
+     * @param ipfsUri - IPFS URI (ipfs://...)
+     * @returns Promise resolving to HTTP URL
+     */
+    private resolveIPFS;
+    /**
+     * Fetches metadata from HTTP URL
+     * @param url - HTTP URL to fetch metadata from
+     * @returns Promise resolving to NFT metadata
+     */
+    private fetchMetadata;
+    /**
+     * Parses raw metadata into standardized format
+     * @param rawData - Raw metadata from contract
+     * @returns Parsed NFT metadata
+     */
+    private parseMetadata;
+    /**
+     * Gets cached metadata if available and not expired
+     * @param uri - Metadata URI
+     * @returns Cached metadata or null if not found/expired
+     */
+    private getCachedMetadata;
+    /**
+     * Caches metadata for future use
+     * @param uri - Metadata URI
+     * @param metadata - Metadata to cache
+     */
+    private cacheMetadata;
+    /**
+     * Clears the metadata cache
+     */
+    static clearCache(): void;
+    /**
+     * Gets cache statistics
+     * @returns Cache statistics
+     */
+    static getCacheStats(): {
+        size: number;
+        entries: number;
+    };
+}

package/dist/services/nft/MetadataResolver.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataResolver = void 0;
+/**
+ * Service for resolving NFT metadata from various sources (IPFS, HTTP)
+ */
+class MetadataResolver {
+    /**
+     * Resolves metadata from a URI (IPFS or HTTP)
+     * @param uri - The metadata URI to resolve
+     * @returns Promise resolving to NFT metadata
+     */
+    async resolveMetadata(uri) {
+        // Check cache first
+        const cached = this.getCachedMetadata(uri);
+        if (cached) {
+            return cached;
+        }
+        let resolvedUri;
+        if (uri.startsWith('ipfs://')) {
+            resolvedUri = await this.resolveIPFS(uri);
+        }
+        else if (uri.startsWith('http://') || uri.startsWith('https://')) {
+            resolvedUri = uri;
+        }
+        else {
+            throw new Error(`Unsupported URI format: ${uri}`);
+        }
+        const metadata = await this.fetchMetadata(resolvedUri);
+        this.cacheMetadata(uri, metadata);
+        return metadata;
+    }
+    /**
+     * Resolves IPFS URI to HTTP URL using multiple gateways
+     * @param ipfsUri - IPFS URI (ipfs://...)
+     * @returns Promise resolving to HTTP URL
+     */
+    async resolveIPFS(ipfsUri) {
+        const ipfsHash = ipfsUri.replace('ipfs://', '');
+        // Try multiple gateways for redundancy
+        for (const gateway of MetadataResolver.IPFS_GATEWAYS) {
+            try {
+                const url = gateway + ipfsHash;
+                const response = await fetch(url, { method: 'HEAD' });
+                if (response.ok) {
+                    return url;
+                }
+            }
+            catch (error) {
+                console.warn(`IPFS gateway ${gateway} failed:`, error);
+                continue;
+            }
+        }
+        throw new Error(`Failed to resolve IPFS URI: ${ipfsUri}`);
+    }
+    /**
+     * Fetches metadata from HTTP URL
+     * @param url - HTTP URL to fetch metadata from
+     * @returns Promise resolving to NFT metadata
+     */
+    async fetchMetadata(url) {
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                    'User-Agent': 'PWC-Wallet-SDK/1.0'
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const rawData = await response.json();
+            return this.parseMetadata(rawData);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch metadata from ${url}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Parses raw metadata into standardized format
+     * @param rawData - Raw metadata from contract
+     * @returns Parsed NFT metadata
+     */
+    parseMetadata(rawData) {
+        // Handle different metadata formats
+        const metadata = {
+            name: rawData.name || rawData.title || 'Unknown NFT',
+            description: rawData.description || '',
+            image: rawData.image || rawData.image_url || '',
+            external_url: rawData.external_url || rawData.externalUrl || undefined,
+            attributes: []
+        };
+        // Parse attributes
+        if (rawData.attributes && Array.isArray(rawData.attributes)) {
+            metadata.attributes = rawData.attributes.map((attr) => ({
+                trait_type: attr.trait_type || attr.traitType || '',
+                value: attr.value || '',
+                display_type: attr.display_type || attr.displayType || undefined
+            }));
+        }
+        // Validate required fields
+        if (!metadata.name || !metadata.image) {
+            throw new Error('Invalid metadata: missing required fields (name, image)');
+        }
+        return metadata;
+    }
+    /**
+     * Gets cached metadata if available and not expired
+     * @param uri - Metadata URI
+     * @returns Cached metadata or null if not found/expired
+     */
+    getCachedMetadata(uri) {
+        const cached = MetadataResolver.metadataCache.get(uri);
+        if (!cached) {
+            return null;
+        }
+        const now = Date.now();
+        if (now - cached.timestamp > MetadataResolver.CACHE_DURATION) {
+            MetadataResolver.metadataCache.delete(uri);
+            return null;
+        }
+        return cached.data;
+    }
+    /**
+     * Caches metadata for future use
+     * @param uri - Metadata URI
+     * @param metadata - Metadata to cache
+     */
+    cacheMetadata(uri, metadata) {
+        MetadataResolver.metadataCache.set(uri, {
+            data: metadata,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Clears the metadata cache
+     */
+    static clearCache() {
+        MetadataResolver.metadataCache.clear();
+    }
+    /**
+     * Gets cache statistics
+     * @returns Cache statistics
+     */
+    static getCacheStats() {
+        return {
+            size: MetadataResolver.metadataCache.size,
+            entries: Array.from(MetadataResolver.metadataCache.values()).length
+        };
+    }
+}
+exports.MetadataResolver = MetadataResolver;
+MetadataResolver.IPFS_GATEWAYS = [
+    'https://ipfs.io/ipfs/',
+    'https://gateway.pinata.cloud/ipfs/',
+    'https://cloudflare-ipfs.com/ipfs/',
+    'https://dweb.link/ipfs/',
+    'https://gateway.ipfs.io/ipfs/'
+];
+MetadataResolver.CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+MetadataResolver.metadataCache = new Map();