pwc-sdk-wallet 0.6.3

package/dist/services/nft/NFTService.js

@@ -0,0 +1,910 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTService = void 0;
+const ethers_1 = require("ethers");
+const ChainService_1 = require("../../chain/ChainService");
+const SolanaChainService_1 = require("../../chain/SolanaChainService");
+const chains_1 = require("../../config/chains");
+const TokenUtils_1 = require("../TokenUtils");
+/**
+ * Standard ERC-721 NFT interface ABI
+ */
+const ERC721_ABI = [
+    "function name() view returns (string)",
+    "function symbol() view returns (string)",
+    "function ownerOf(uint256 tokenId) view returns (address)",
+    "function tokenURI(uint256 tokenId) view returns (string)",
+    "function balanceOf(address owner) view returns (uint256)",
+    "function totalSupply() view returns (uint256)",
+    "function transferFrom(address from, address to, uint256 tokenId)",
+    "function approve(address to, uint256 tokenId)",
+    "function setApprovalForAll(address operator, bool approved)",
+    "function getApproved(uint256 tokenId) view returns (address)",
+    "function isApprovedForAll(address owner, address operator) view returns (bool)",
+    "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+];
+/**
+ * Standard ERC-1155 NFT interface ABI
+ */
+const ERC1155_ABI = [
+    "function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)",
+    "function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)",
+    "function balanceOf(address account, uint256 id) view returns (uint256)",
+    "function balanceOfBatch(address[] accounts, uint256[] ids) view returns (uint256[])",
+    "function setApprovalForAll(address operator, bool approved)",
+    "function isApprovedForAll(address account, address operator) view returns (bool)",
+    "function uri(uint256 id) view returns (string)",
+    "function name() view returns (string)",
+    "function symbol() view returns (string)",
+    "function exists(uint256 id) view returns (bool)",
+    "event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)",
+    "event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)",
+    "event ApprovalForAll(address indexed account, address indexed operator, bool approved)"
+];
+/**
+ * Pure blockchain NFT service
+ * Reads all data directly from smart contracts without third-party APIs
+ */
+class NFTService {
+    /**
+     * Creates a new NFTService instance.
+     * @param chainId - The chain ID to operate on
+     * @param vault - Optional vault instance for write operations
+     * @param fromAddress - Optional sender address for write operations
+     */
+    constructor(chainId, vault, fromAddress) {
+        this.chainId = chainId;
+        this.vault = vault;
+        // Note: Chain service will be initialized lazily when needed
+        // or explicitly via initializeForWrite() method
+    }
+    /**
+     * Initialize chain service for write operations
+     * @param vault - The vault instance
+     * @param fromAddress - The sender's address
+     */
+    async initializeChainService(vault, fromAddress) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        const privateKey = await vault.getPrivateKeyFor(fromAddress);
+        if (chainConfig.type === 'solana') {
+            this.chainService = new SolanaChainService_1.SolanaChainService(privateKey, chainConfig);
+        }
+        else {
+            this.chainService = new ChainService_1.ChainService(privateKey, chainConfig);
+        }
+    }
+    /**
+     * Initialize chain service for write operations after construction
+     * @param vault - The vault instance
+     * @param fromAddress - The sender's address
+     */
+    async initializeForWrite(vault, fromAddress) {
+        this.vault = vault;
+        await this.initializeChainService(vault, fromAddress);
+    }
+    /**
+     * Gets comprehensive NFT detail by reading directly from blockchain.
+     * @param contractAddress - NFT contract address
+     * @param tokenId - Token ID (string)
+     * @param options - Optional parameters for additional data
+     * @param options.includeMetadata - Whether to fetch and include metadata (default: false)
+     * @param options.includeHistory - Whether to fetch transaction history (default: false)
+     * @param options.includeCollection - Whether to fetch collection information (default: false)
+     * @returns Promise resolving to extended NFT detail
+     * @example
+     * ```typescript
+     * const nftDetail = await nftService.getNFTDetail(
+     *   '0xContract...',
+     *   '123',
+     *   { includeMetadata: true, includeHistory: true }
+     * );
+     * console.log('NFT:', nftDetail.name, 'Owner:', nftDetail.owner);
+     * ```
+     */
+    async getNFTDetail(contractAddress, tokenId, options = {}) {
+        try {
+            // 1. Get on-chain data
+            const onChainData = await this.getOnChainData(contractAddress, tokenId);
+            // 2. Resolve metadata from tokenURI
+            let metadata;
+            if (options.includeMetadata && onChainData.tokenURI) {
+                metadata = await this.resolveMetadata(onChainData.tokenURI);
+            }
+            // 3. Get transaction history (on-chain events)
+            let transactionHistory = [];
+            if (options.includeHistory) {
+                transactionHistory = await this.getTransactionHistory(contractAddress, tokenId);
+            }
+            // 4. Get collection info
+            let collection;
+            if (options.includeCollection) {
+                collection = await this.getCollectionInfo(contractAddress);
+            }
+            const nftDetail = {
+                contractAddress,
+                tokenId,
+                name: metadata?.name || `NFT #${tokenId}`,
+                description: metadata?.description,
+                image: metadata?.image,
+                attributes: metadata?.attributes,
+                owner: onChainData.owner,
+                tokenType: onChainData.tokenType,
+                chainId: this.chainId,
+                tokenUri: onChainData.tokenURI,
+                createdAt: onChainData.createdAt,
+                lastTransferAt: onChainData.lastTransferAt,
+                metadata,
+                collection,
+                transactionHistory,
+                metadataSource: onChainData.tokenURI?.startsWith('ipfs://') ? 'ipfs' : 'http',
+                lastUpdated: Date.now()
+            };
+            return nftDetail;
+        }
+        catch (error) {
+            throw new Error(`Failed to get NFT detail: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Gets on-chain NFT data directly from smart contract
+     * @param contractAddress - NFT contract address
+     * @param tokenId - Token ID
+     * @returns Promise resolving to on-chain data
+     */
+    async getOnChainData(contractAddress, tokenId) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'solana') {
+            return this.getSolanaOnChainData(contractAddress, tokenId);
+        }
+        else {
+            return this.getEVMOnChainData(contractAddress, tokenId);
+        }
+    }
+    /**
+     * Gets EVM NFT on-chain data
+     * @param contractAddress - NFT contract address
+     * @param tokenId - Token ID
+     * @returns Promise resolving to on-chain data
+     */
+    async getEVMOnChainData(contractAddress, tokenId) {
+        const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        // Try ERC-721 first
+        try {
+            const contract = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+            const [owner, tokenURI, name, symbol] = await Promise.all([
+                contract.ownerOf(tokenId),
+                contract.tokenURI(tokenId),
+                contract.name().catch(() => 'Unknown'),
+                contract.symbol().catch(() => 'UNKNOWN')
+            ]);
+            return {
+                owner,
+                tokenURI,
+                name,
+                symbol,
+                tokenType: 'ERC-721',
+                createdAt: await this.getMintTimestamp(contractAddress, tokenId),
+                lastTransferAt: await this.getLastTransferTimestamp(contractAddress, tokenId)
+            };
+        }
+        catch (error) {
+            // Try ERC-1155 if ERC-721 fails
+            try {
+                const contract = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+                const [uri, name, symbol] = await Promise.all([
+                    contract.uri(tokenId),
+                    contract.name().catch(() => 'Unknown'),
+                    contract.symbol().catch(() => 'UNKNOWN')
+                ]);
+                // For ERC-1155, we need to check if token exists
+                const exists = await contract.exists(tokenId);
+                if (!exists) {
+                    throw new Error('Token does not exist');
+                }
+                return {
+                    owner: 'Multiple Owners', // ERC-1155 can have multiple owners for same token
+                    tokenURI: uri,
+                    name,
+                    symbol,
+                    tokenType: 'ERC-1155',
+                    createdAt: await this.getMintTimestamp(contractAddress, tokenId),
+                    lastTransferAt: await this.getLastTransferTimestamp(contractAddress, tokenId)
+                };
+            }
+            catch (erc1155Error) {
+                throw new Error('Contract is not a valid ERC-721 or ERC-1155 NFT');
+            }
+        }
+    }
+    /**
+     * Gets Solana NFT on-chain data
+     * @param contractAddress - NFT mint address
+     * @param tokenId - Token ID (not used for Solana)
+     * @returns Promise resolving to on-chain data
+     */
+    async getSolanaOnChainData(contractAddress, tokenId) {
+        // For Solana, contractAddress is the mint address
+        const mintAddress = contractAddress;
+        // This would need Solana-specific implementation
+        // For now, return basic structure
+        return {
+            owner: 'Unknown', // Would get from Solana program
+            tokenURI: '', // Would get from metadata account
+            name: 'Solana NFT',
+            symbol: 'SOL-NFT',
+            tokenType: 'SPL-NFT',
+            createdAt: Date.now(),
+            lastTransferAt: Date.now()
+        };
+    }
+    /**
+     * Resolves metadata from tokenURI (IPFS or HTTP)
+     * @param tokenURI - Token URI
+     * @returns Promise resolving to metadata
+     */
+    async resolveMetadata(tokenURI) {
+        try {
+            let url = tokenURI;
+            // Handle IPFS URLs
+            if (tokenURI.startsWith('ipfs://')) {
+                url = tokenURI.replace('ipfs://', 'https://ipfs.io/ipfs/');
+            }
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch metadata: ${response.statusText}`);
+            }
+            const metadata = await response.json();
+            // Validate required fields
+            if (!metadata.name) {
+                throw new Error('Metadata missing required field: name');
+            }
+            return metadata;
+        }
+        catch (error) {
+            throw new Error(`Failed to resolve metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Gets transaction history from blockchain events
+     * @param contractAddress - NFT contract address
+     * @param tokenId - Token ID
+     * @returns Promise resolving to transaction history
+     */
+    async getTransactionHistory(contractAddress, tokenId) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'evm') {
+            const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+            if (!provider) {
+                return [];
+            }
+            // Try ERC-721 first
+            try {
+                const contract721 = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+                // Get Transfer events for this token
+                const filter = contract721.filters.Transfer(null, null, tokenId);
+                const events = await contract721.queryFilter(filter, 0, 'latest');
+                return events.map(event => {
+                    const eventLog = event;
+                    return {
+                        hash: event.transactionHash,
+                        from: eventLog.args?.[0] || '',
+                        to: eventLog.args?.[1] || '',
+                        blockNumber: event.blockNumber,
+                        timestamp: Date.now(), // Would need to get from block
+                        type: eventLog.args?.[0] === '0x0000000000000000000000000000000000000000' ? 'mint' : 'transfer'
+                    };
+                });
+            }
+            catch (error) {
+                // Try ERC-1155 if ERC-721 fails
+                try {
+                    const contract1155 = new ethers_1.Contract(contractAddress, [
+                        ...ERC1155_ABI,
+                        "event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)",
+                        "event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)"
+                    ], provider);
+                    // Get TransferSingle events for this token
+                    const singleFilter = contract1155.filters.TransferSingle(null, null, null, tokenId);
+                    const singleEvents = await contract1155.queryFilter(singleFilter, 0, 'latest');
+                    // Get TransferBatch events that include this token
+                    const batchFilter = contract1155.filters.TransferBatch(null, null, null);
+                    const batchEvents = await contract1155.queryFilter(batchFilter, 0, 'latest');
+                    const events = [];
+                    // Process TransferSingle events
+                    singleEvents.forEach(event => {
+                        const eventLog = event;
+                        events.push({
+                            hash: event.transactionHash,
+                            from: eventLog.args?.[1] || '', // from
+                            to: eventLog.args?.[2] || '', // to
+                            blockNumber: event.blockNumber,
+                            timestamp: Date.now(),
+                            type: eventLog.args?.[1] === '0x0000000000000000000000000000000000000000' ? 'mint' : 'transfer'
+                        });
+                    });
+                    // Process TransferBatch events that include this token
+                    batchEvents.forEach(event => {
+                        const eventLog = event;
+                        const ids = eventLog.args?.[3] || []; // token IDs
+                        const values = eventLog.args?.[4] || []; // amounts
+                        const tokenIndex = ids.findIndex((id) => id.toString() === tokenId);
+                        if (tokenIndex !== -1) {
+                            events.push({
+                                hash: event.transactionHash,
+                                from: eventLog.args?.[1] || '', // from
+                                to: eventLog.args?.[2] || '', // to
+                                blockNumber: event.blockNumber,
+                                timestamp: Date.now(),
+                                type: eventLog.args?.[1] === '0x0000000000000000000000000000000000000000' ? 'mint' : 'transfer'
+                            });
+                        }
+                    });
+                    return events;
+                }
+                catch (erc1155Error) {
+                    // If both fail, return empty array
+                    return [];
+                }
+            }
+        }
+        return [];
+    }
+    /**
+     * Gets collection information from contract
+     * @param contractAddress - NFT contract address
+     * @returns Promise resolving to collection info
+     */
+    async getCollectionInfo(contractAddress) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'evm') {
+            const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+            if (!provider) {
+                throw new Error('Provider not available');
+            }
+            // Try ERC-721 first
+            try {
+                const contract721 = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+                const [name, symbol, totalSupply] = await Promise.all([
+                    contract721.name().catch(() => 'Unknown Collection'),
+                    contract721.symbol().catch(() => 'UNKNOWN'),
+                    contract721.totalSupply().catch(() => 0)
+                ]);
+                return {
+                    contractAddress,
+                    name,
+                    symbol,
+                    tokenType: 'ERC-721',
+                    chainId: this.chainId,
+                    totalSupply: Number(totalSupply)
+                };
+            }
+            catch (error) {
+                // Try ERC-1155 if ERC-721 fails
+                try {
+                    const contract1155 = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+                    const [name, symbol] = await Promise.all([
+                        contract1155.name().catch(() => 'Unknown Collection'),
+                        contract1155.symbol().catch(() => 'UNKNOWN')
+                    ]);
+                    // ERC-1155 doesn't have totalSupply, so we can't get it easily
+                    return {
+                        contractAddress,
+                        name,
+                        symbol,
+                        tokenType: 'ERC-1155',
+                        chainId: this.chainId
+                        // totalSupply not available for ERC-1155
+                    };
+                }
+                catch (erc1155Error) {
+                    // If both fail, return basic info
+                    return {
+                        contractAddress,
+                        name: 'Unknown Collection',
+                        symbol: 'UNKNOWN',
+                        tokenType: 'ERC-721', // Default fallback
+                        chainId: this.chainId
+                    };
+                }
+            }
+        }
+        return {
+            contractAddress,
+            name: 'Solana Collection',
+            tokenType: 'SPL-NFT',
+            chainId: this.chainId
+        };
+    }
+    /**
+     * Gets NFT balance for an address from a specific contract.
+     * Supports both ERC-721 and ERC-1155 contracts.
+     * @param address - Wallet address to check balance for
+     * @param contractAddress - NFT contract address
+     * @param tokenId - (Optional) Token ID for ERC-1155 contracts
+     * @returns Promise resolving to NFT balance information
+     * @example
+     * ```typescript
+     * // For ERC-721
+     * const balance = await nftService.getNFTBalance('0xAccount...', '0xContract...');
+     * console.log('ERC-721 Count:', balance.count);
+     *
+     * // For ERC-1155
+     * const balance = await nftService.getNFTBalance('0xAccount...', '0xContract...', '123');
+     * console.log('ERC-1155 Balance:', balance.count);
+     * ```
+     */
+    async getNFTBalance(address, contractAddress, tokenId) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'evm') {
+            const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+            if (!provider) {
+                throw new Error('Provider not available');
+            }
+            // Try ERC-721 first
+            try {
+                const contract721 = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+                const balance = await contract721.balanceOf(address);
+                // Get token IDs owned by this address (simplified for now)
+                const tokenIds = [];
+                // This would require additional logic to get all token IDs
+                // For now, return basic balance info
+                return {
+                    contractAddress,
+                    tokenIds,
+                    count: Number(balance),
+                    tokenType: 'ERC-721',
+                    chainId: this.chainId
+                };
+            }
+            catch (error) {
+                // Try ERC-1155 if ERC-721 fails
+                try {
+                    const contract1155 = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+                    if (tokenId) {
+                        // Get balance for specific token ID
+                        const exists = await contract1155.exists(tokenId).catch(() => true);
+                        if (!exists) {
+                            return {
+                                contractAddress,
+                                tokenIds: [],
+                                count: 0,
+                                tokenType: 'ERC-1155',
+                                chainId: this.chainId
+                            };
+                        }
+                        const balance = await contract1155.balanceOf(address, tokenId);
+                        return {
+                            contractAddress,
+                            tokenIds: [tokenId],
+                            count: Number(balance),
+                            tokenType: 'ERC-1155',
+                            chainId: this.chainId
+                        };
+                    }
+                    else {
+                        // For ERC-1155 without tokenId, we can't get total count easily
+                        // Return basic info indicating it's ERC-1155
+                        return {
+                            contractAddress,
+                            tokenIds: [],
+                            count: 0,
+                            tokenType: 'ERC-1155',
+                            chainId: this.chainId
+                        };
+                    }
+                }
+                catch (erc1155Error) {
+                    throw new Error('Contract is not a valid ERC-721 or ERC-1155 NFT');
+                }
+            }
+        }
+        return {
+            contractAddress,
+            tokenIds: [],
+            count: 0,
+            tokenType: 'SPL-NFT',
+            chainId: this.chainId
+        };
+    }
+    /**
+     * Gets ERC-1155 token balance for a specific address and token ID.
+     * @param address - Wallet address to check balance for
+     * @param contractAddress - ERC-1155 contract address
+     * @param tokenId - Token ID to check balance for
+     * @returns Promise resolving to the balance amount as bigint
+     * @example
+     * ```typescript
+     * const balance = await nftService.getERC1155Balance('0xAccount...', '0xContract...', '123');
+     * console.log('ERC-1155 Balance:', balance.toString());
+     * ```
+     */
+    async getERC1155Balance(address, contractAddress, tokenId) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'solana') {
+            throw new Error('ERC-1155 is not supported on Solana');
+        }
+        const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        try {
+            const contract = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+            // Check if token exists
+            const exists = await contract.exists(tokenId).catch(() => true); // fallback true if not implemented
+            if (!exists) {
+                return BigInt(0); // Token doesn't exist, return 0 balance
+            }
+            // Get balance for specific token ID
+            const balance = await contract.balanceOf(address, tokenId);
+            return balance;
+        }
+        catch (error) {
+            throw new Error(`Failed to get ERC-1155 balance: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Gets all ERC-1155 token balances for an address from a specific contract.
+     * @param address - Wallet address to check balances for
+     * @param contractAddress - ERC-1155 contract address
+     * @param tokenIds - Array of token IDs to check
+     * @returns Promise resolving to array of balance objects
+     * @example
+     * ```typescript
+     * const balances = await nftService.getERC1155Balances('0xAccount...', '0xContract...', ['123', '456', '789']);
+     * balances.forEach(balance => {
+     *   console.log(`Token ${balance.tokenId}: ${balance.amount.toString()}`);
+     * });
+     * ```
+     */
+    async getERC1155Balances(address, contractAddress, tokenIds) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'solana') {
+            throw new Error('ERC-1155 is not supported on Solana');
+        }
+        const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        try {
+            const contract = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+            // Get balances for all token IDs in parallel
+            const balancePromises = tokenIds.map(async (tokenId) => {
+                try {
+                    const exists = await contract.exists(tokenId).catch(() => true);
+                    if (!exists) {
+                        return { tokenId, amount: BigInt(0) };
+                    }
+                    const balance = await contract.balanceOf(address, tokenId);
+                    return { tokenId, amount: balance };
+                }
+                catch (error) {
+                    console.warn(`Failed to get balance for token ${tokenId}:`, error);
+                    return { tokenId, amount: BigInt(0) };
+                }
+            });
+            const balances = await Promise.all(balancePromises);
+            return balances;
+        }
+        catch (error) {
+            throw new Error(`Failed to get ERC-1155 balances: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Gets mint timestamp from blockchain
+     * @param contractAddress - NFT contract address
+     * @param tokenId - Token ID
+     * @returns Promise resolving to mint timestamp
+     */
+    async getMintTimestamp(contractAddress, tokenId) {
+        // This would require querying the first Transfer event for this token
+        // For now, return current timestamp
+        return Date.now();
+    }
+    /**
+     * Gets last transfer timestamp from blockchain
+     * @param contractAddress - NFT contract address
+     * @param tokenId - Token ID
+     * @returns Promise resolving to last transfer timestamp
+     */
+    async getLastTransferTimestamp(contractAddress, tokenId) {
+        // This would require querying the last Transfer event for this token
+        // For now, return current timestamp
+        return Date.now();
+    }
+    /**
+     * Estimates gas cost for transferring an NFT
+     * @param fromAddress - The sender's address
+     * @param toAddress - The recipient's address
+     * @param contractAddress - The NFT contract address
+     * @param tokenId - The token ID to transfer
+     * @param amount - (Optional) Amount to transfer (for ERC-1155, default 1 for ERC-721)
+     * @returns Promise resolving to the estimated gas cost as bigint
+     * @example
+     * ```typescript
+     * const gasEstimate = await nftService.estimateGasForTransfer(
+     *   '0xSender...',
+     *   '0xRecipient...',
+     *   '0xContract...',
+     *   '123'
+     * );
+     * console.log('Estimated gas:', gasEstimate.toString());
+     * ```
+     */
+    async estimateGasForTransfer(fromAddress, toAddress, contractAddress, tokenId, amount = "1") {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'solana') {
+            // For Solana, return a fixed estimate (would need Solana-specific implementation)
+            return BigInt(5000); // Placeholder value
+        }
+        const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        // Try ERC-721 first
+        try {
+            const contract721 = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+            // Check if token exists as ERC-721
+            await contract721.ownerOf(tokenId); // Throws if not ERC-721
+            // Estimate gas for ERC-721 transfer
+            return await contract721.transferFrom.estimateGas(fromAddress, toAddress, tokenId);
+        }
+        catch (e) {
+            // Try ERC-1155
+            try {
+                const contract1155 = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+                // Check if token exists as ERC-1155
+                const exists = await contract1155.exists(tokenId).catch(() => true); // fallback true if not implemented
+                if (!exists)
+                    throw new Error('ERC-1155 token does not exist');
+                // Parse amount to ensure it's a valid number
+                const parsedAmount = amount ? amount.toString() : "1";
+                // For ERC-1155 gas estimation, we need to use a wallet with private key
+                // to pass the "caller is not owner nor approved" check
+                if (!this.vault) {
+                    // If no vault available, return a reasonable estimate
+                    console.warn('No vault available for ERC-1155 gas estimation. Returning estimated value.');
+                    return BigInt(65000); // Conservative estimate for ERC-1155 transfer
+                }
+                try {
+                    // Create contract with wallet for gas estimation
+                    const contractWithWallet = await this.createContractWithWallet(contractAddress, ERC1155_ABI, fromAddress);
+                    // Estimate gas for ERC-1155 transfer with wallet
+                    return await contractWithWallet.safeTransferFrom.estimateGas(fromAddress, toAddress, tokenId, parsedAmount, '0x');
+                }
+                catch (walletError) {
+                    // If wallet estimation fails, return conservative estimate
+                    console.warn('Wallet-based gas estimation failed, returning conservative estimate:', walletError);
+                    return BigInt(65000); // Conservative estimate for ERC-1155 transfer
+                }
+            }
+            catch (erc1155Error) {
+                console.error('ERC-1155 gas estimation error:', erc1155Error);
+                throw new Error(`Contract is not a valid ERC-721 or ERC-1155 NFT: ${erc1155Error instanceof Error ? erc1155Error.message : 'Unknown error'}`);
+            }
+        }
+    }
+    /**
+     * Estimates gas cost for various NFT operations
+     * @param operation - The operation to estimate gas for
+     * @param contractAddress - The NFT contract address
+     * @param params - Operation-specific parameters
+     * @returns Promise resolving to the estimated gas cost as bigint
+     * @example
+     * ```typescript
+     * // Estimate gas for transfer
+     * const transferGas = await nftService.estimateGas('transfer', contractAddress, {
+     *   fromAddress: '0xSender...',
+     *   toAddress: '0xRecipient...',
+     *   tokenId: '123'
+     * });
+     *
+     * // Estimate gas for approve
+     * const approveGas = await nftService.estimateGas('approve', contractAddress, {
+     *   toAddress: '0xSpender...',
+     *   tokenId: '123'
+     * });
+     * ```
+     */
+    async estimateGas(operation, contractAddress, params) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'solana') {
+            // For Solana, return a fixed estimate (would need Solana-specific implementation)
+            return BigInt(5000); // Placeholder value
+        }
+        const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        // Try ERC-721 first
+        try {
+            const contract721 = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+            switch (operation) {
+                case 'transfer':
+                    if (!params.fromAddress || !params.tokenId) {
+                        throw new Error('fromAddress and tokenId are required for transfer operation');
+                    }
+                    // Check if token exists as ERC-721
+                    await contract721.ownerOf(params.tokenId);
+                    return await contract721.transferFrom.estimateGas(params.fromAddress, params.toAddress, params.tokenId);
+                case 'approve':
+                    if (!params.tokenId) {
+                        throw new Error('tokenId is required for approve operation');
+                    }
+                    return await contract721.approve.estimateGas(params.toAddress, params.tokenId);
+                case 'setApprovalForAll':
+                    if (params.approved === undefined) {
+                        throw new Error('approved parameter is required for setApprovalForAll operation');
+                    }
+                    return await contract721.setApprovalForAll.estimateGas(params.toAddress, params.approved);
+                default:
+                    throw new Error(`Unsupported operation: ${operation}`);
+            }
+        }
+        catch (e) {
+            // Try ERC-1155
+            try {
+                const contract1155 = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+                switch (operation) {
+                    case 'transfer':
+                        if (!params.fromAddress || !params.tokenId) {
+                            throw new Error('fromAddress and tokenId are required for transfer operation');
+                        }
+                        const amount = params.amount || "1";
+                        // Check if token exists as ERC-1155
+                        const exists = await contract1155.exists(params.tokenId).catch(() => true);
+                        if (!exists)
+                            throw new Error('ERC-1155 token does not exist');
+                        // For ERC-1155 gas estimation, we need to use a wallet with private key
+                        if (!this.vault) {
+                            console.warn('No vault available for ERC-1155 gas estimation. Returning estimated value.');
+                            return BigInt(65000); // Conservative estimate for ERC-1155 transfer
+                        }
+                        try {
+                            // Create contract with wallet for gas estimation
+                            const contractWithWallet = await this.createContractWithWallet(contractAddress, ERC1155_ABI, params.fromAddress);
+                            return await contractWithWallet.safeTransferFrom.estimateGas(params.fromAddress, params.toAddress, params.tokenId, amount, '0x');
+                        }
+                        catch (walletError) {
+                            console.warn('Wallet-based gas estimation failed, returning conservative estimate:', walletError);
+                            return BigInt(65000); // Conservative estimate for ERC-1155 transfer
+                        }
+                    case 'approve':
+                    case 'setApprovalForAll':
+                        throw new Error(`Operation ${operation} not supported for ERC-1155`);
+                    default:
+                        throw new Error(`Unsupported operation: ${operation}`);
+                }
+            }
+            catch (erc1155Error) {
+                throw new Error('Contract is not a valid ERC-721 or ERC-1155 NFT');
+            }
+        }
+    }
+    /**
+     * Transfers an NFT using Vault (RECOMMENDED). Supports both ERC-721 and ERC-1155.
+     * @param fromAddress - The sender's address
+     * @param toAddress - The recipient's address
+     * @param contractAddress - The NFT contract address
+     * @param tokenId - The token ID to transfer
+     * @param amount - (Optional) Amount to transfer (for ERC-1155, default 1 for ERC-721)
+     * @returns Promise resolving to the transaction response
+     */
+    async transferNFTWithVault(fromAddress, toAddress, contractAddress, tokenId, amount = "1") {
+        // Check if vault is available
+        if (!this.vault) {
+            throw new Error('Vault not available. Please either:\n' +
+                '1. Use the constructor with vault: new NFTService(chainId, vault)\n' +
+                '2. Call initializeForWrite(vault, fromAddress) before using this method');
+        }
+        // Try ERC-721 first
+        try {
+            const contract721 = await this.createContractWithWallet(contractAddress, ERC721_ABI, fromAddress);
+            // Check if token exists as ERC-721
+            await contract721.ownerOf(tokenId); // Throws if not ERC-721
+            return await contract721.transferFrom(fromAddress, toAddress, tokenId);
+        }
+        catch (e) {
+            // Try ERC-1155
+            const contract1155 = await this.createContractWithWallet(contractAddress, ERC1155_ABI, fromAddress);
+            // Check if token exists as ERC-1155
+            const exists = await contract1155.exists(tokenId).catch(() => true); // fallback true if not implemented
+            if (!exists)
+                throw new Error('ERC-1155 token does not exist');
+            return await contract1155.safeTransferFrom(fromAddress, toAddress, tokenId, amount, '0x');
+        }
+    }
+    /**
+     * @deprecated Use transferNFTWithVault instead for better security
+     * Transfers an NFT from one address to another. Supports both ERC-721 and ERC-1155.
+     * @param fromAddress - The sender's address
+     * @param toAddress - The recipient's address
+     * @param contractAddress - The NFT contract address
+     * @param tokenId - The token ID to transfer
+     * @param amount - (Optional) Amount to transfer (for ERC-1155, default 1 for ERC-721)
+     * @returns Promise resolving to the transaction response
+     */
+    async transferNFT(fromAddress, toAddress, contractAddress, tokenId, amount = "1") {
+        if (!this.chainService) {
+            throw new Error('Chain service not initialized. Please either:\n' +
+                '1. Use the constructor with vault: new NFTService(chainId, vault)\n' +
+                '2. Call initializeForWrite(vault, fromAddress) before using this method\n' +
+                '3. Use transferNFTWithVault(fromAddress, toAddress, contractAddress, tokenId) instead (recommended)');
+        }
+        const provider = (0, chains_1.getProvider)(this.chainId);
+        // Try ERC-721 first
+        try {
+            const contract721 = new ethers_1.Contract(contractAddress, ERC721_ABI, provider);
+            await contract721.ownerOf(tokenId);
+            return await contract721.transferFrom(fromAddress, toAddress, tokenId);
+        }
+        catch (e) {
+            // Try ERC-1155
+            const contract1155 = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+            const exists = await contract1155.exists(tokenId).catch(() => true);
+            if (!exists)
+                throw new Error('ERC-1155 token does not exist');
+            return await contract1155.safeTransferFrom(fromAddress, toAddress, tokenId, amount, '0x');
+        }
+    }
+    /**
+     * Checks if an address is owner or approved for ERC-1155 token
+     * @param address - Address to check
+     * @param contractAddress - ERC-1155 contract address
+     * @param tokenId - Token ID
+     * @returns Promise resolving to boolean indicating if address can transfer
+     */
+    async canTransferERC1155(address, contractAddress, tokenId) {
+        const chainConfig = (0, chains_1.getChainConfig)(this.chainId);
+        if (chainConfig.type === 'solana') {
+            throw new Error('ERC-1155 is not supported on Solana');
+        }
+        const provider = (0, TokenUtils_1.getProviderAuto)(this.chainId);
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        try {
+            const contract = new ethers_1.Contract(contractAddress, ERC1155_ABI, provider);
+            // Check if token exists
+            const exists = await contract.exists(tokenId).catch(() => true);
+            if (!exists) {
+                return false;
+            }
+            // Check balance
+            const balance = await contract.balanceOf(address, tokenId);
+            if (balance > 0) {
+                return true; // Owner can transfer
+            }
+            // Check if address is approved for all tokens
+            const isApprovedForAll = await contract.isApprovedForAll(address, address);
+            return isApprovedForAll;
+        }
+        catch (error) {
+            console.error('Error checking ERC-1155 transfer permissions:', error);
+            return false;
+        }
+    }
+    /**
+     * Creates a contract instance with wallet for gas estimation
+     * @param contractAddress - Contract address
+     * @param abi - Contract ABI
+     * @param fromAddress - Address to use for signing
+     * @returns Promise resolving to contract instance with wallet
+     */
+    async createContractWithWallet(contractAddress, abi, fromAddress) {
+        if (!this.vault) {
+            throw new Error('Vault not available for wallet-based operations');
+        }
+        // Initialize chain service if not already done
+        if (!this.chainService) {
+            await this.initializeChainService(this.vault, fromAddress);
+        }
+        const provider = (0, chains_1.getProvider)(this.chainId);
+        const privateKey = await this.vault.getPrivateKeyFor(fromAddress);
+        const wallet = new ethers_1.ethers.Wallet(privateKey, provider);
+        return new ethers_1.Contract(contractAddress, abi, wallet);
+    }
+}
+exports.NFTService = NFTService;