neozipkit 0.1.1

package/contracts/deployment.config.example.js

@@ -0,0 +1,25 @@
+/**
+ * NZIP Contract Deployment Configuration
+ * 
+ * Copy this file to deployment.config.js and update with your values
+ * The deployment scripts will automatically load this configuration
+ */
+
+module.exports = {
+  // Wallet Configuration (Required for deployment)
+  // Uncomment and set your private key (without 0x prefix)
+  // PRIVATE_KEY: '17e6f5c34c693cf989a579a80c0a50aad090030242b5edcc4dfed565a4804022',
+  
+  // Network Configuration
+  CHAIN_ID: 84532, // Base Sepolia (testnet)
+  // CHAIN_ID: 8453, // Base Mainnet (production)
+  
+  // Previous contract is now DEPRECATED - do not use:
+  // DEPRECATED: 0xb78CB3bcC788fca38c731b1E9D70CF60b04CA015
+  // EXISTING_CONTRACT: '0xb78CB3bcC788fca38c731b1E9D70CF60b04CA015', // DEPRECATED
+  
+  // Deployment Notes:
+  // 1. Set PRIVATE_KEY to deploy new contracts (required - previous contract deprecated)
+  // 2. Make sure you have ETH for gas fees on the target network
+  // 3. Previous contract is deprecated - you must deploy a new one
+}; 

package/contracts/remix-compile.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Interactive Remix IDE Compilation Guide
+ * 
+ * This script walks you through compiling NZIP contracts using Remix IDE
+ * Usage: node remix-compile.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+console.log('🌐 NZIP Contract - Remix IDE Compilation Guide');
+console.log('==============================================\n');
+
+const contractPath = path.join(__dirname, 'src/NZIP-NFT.sol');
+
+function askQuestion(question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer);
+    });
+  });
+}
+
+async function main() {
+  console.log('This guide will walk you through compiling the NZIP NFT contract using Remix IDE.\n');
+  
+  // Step 1: Introduction
+  console.log('📋 Step 1: Preparation');
+  console.log('======================');
+  console.log('✅ Contract: NZIP NFT v2.0 (Public Contract)');
+  console.log('✅ Target: Production deployment');
+  console.log('✅ Method: Remix IDE (Online)\n');
+  
+  await askQuestion('Press Enter to continue...');
+  console.clear();
+  
+  // Step 2: Open Remix
+  console.log('🌐 Step 2: Open Remix IDE');
+  console.log('=========================');
+  console.log('1. Open your web browser');
+  console.log('2. Go to: https://remix.ethereum.org');
+  console.log('3. Wait for Remix to load completely\n');
+  
+  console.log('💡 Tip: Use Chrome or Firefox for best compatibility\n');
+  
+  const remixOpen = await askQuestion('Have you opened Remix IDE? (y/n): ');
+  if (remixOpen.toLowerCase() !== 'y') {
+    console.log('Please open Remix IDE first, then run this script again.');
+    rl.close();
+    return;
+  }
+  console.clear();
+  
+  // Step 3: Create new file
+  console.log('📄 Step 3: Create Contract File');
+  console.log('===============================');
+  console.log('In Remix IDE:');
+  console.log('1. Look for the "File Explorer" tab (📁 icon on the left)');
+  console.log('2. Right-click in the file explorer');
+  console.log('3. Select "New File"');
+  console.log('4. Name it: NZIP-NFT.sol');
+  console.log('5. Press Enter to create the file\n');
+  
+  await askQuestion('Have you created the NZIP-NFT.sol file? Press Enter when ready...');
+  console.clear();
+  
+  // Step 4: Copy contract source
+  console.log('📝 Step 4: Copy Contract Source Code');
+  console.log('====================================');
+  console.log('I will now display the contract source code.');
+  console.log('Copy ALL of it and paste it into your NZIP-NFT.sol file in Remix.\n');
+  
+  await askQuestion('Ready to see the contract source? Press Enter...');
+  console.log('\n' + '='.repeat(80));
+  console.log('CONTRACT SOURCE CODE - COPY EVERYTHING BELOW:');
+  console.log('='.repeat(80) + '\n');
+  
+  try {
+    const contractContent = fs.readFileSync(contractPath, 'utf8');
+    console.log(contractContent);
+  } catch (err) {
+    console.log('❌ Error reading contract:', err.message);
+    rl.close();
+    return;
+  }
+  
+  console.log('\n' + '='.repeat(80));
+  console.log('END OF CONTRACT SOURCE CODE');
+  console.log('='.repeat(80) + '\n');
+  
+  await askQuestion('Have you copied and pasted the contract into Remix? Press Enter when done...');
+  console.clear();
+  
+  // Step 5: Install dependencies
+  console.log('📦 Step 5: Install OpenZeppelin Dependencies');
+  console.log('============================================');
+  console.log('In Remix IDE:');
+  console.log('1. Click on the "Solidity Compiler" tab (📄 icon on the left)');
+  console.log('2. Remix should automatically detect and install OpenZeppelin dependencies');
+  console.log('3. Look for "@openzeppelin/contracts" in the file explorer');
+  console.log('4. If dependencies don\'t auto-install, Remix will show import errors\n');
+  
+  console.log('💡 If you see import errors:');
+  console.log('• Remix will offer to install dependencies automatically');
+  console.log('• Click "Install" when prompted\n');
+  
+  await askQuestion('Are the OpenZeppelin dependencies installed? Press Enter when ready...');
+  console.clear();
+  
+  // Step 6: Compile
+  console.log('⚙️  Step 6: Compile the Contract');
+  console.log('=================================');
+  console.log('In the Solidity Compiler tab:');
+  console.log('1. Set Compiler Version: 0.8.19 or higher');
+  console.log('2. Enable "Optimization" (recommended)');
+  console.log('3. Click "Compile NZIP-NFT.sol" button');
+  console.log('4. Wait for compilation to complete\n');
+  
+  console.log('✅ Success indicators:');
+  console.log('• Green checkmark appears');
+  console.log('• No error messages');
+  console.log('• "ZipFileNFT" contract appears in compiled contracts list\n');
+  
+  const compiled = await askQuestion('Did the contract compile successfully? (y/n): ');
+  if (compiled.toLowerCase() !== 'y') {
+    console.log('\n❌ Compilation Issues:');
+    console.log('• Check for red error messages in Remix');
+    console.log('• Ensure Solidity version is 0.8.19+');
+    console.log('• Make sure all OpenZeppelin dependencies are installed');
+    console.log('• Copy the contract source again if needed\n');
+    
+    await askQuestion('Fix the issues and press Enter to continue...');
+  }
+  console.clear();
+  
+  // Step 7: Extract compilation artifacts
+  console.log('📋 Step 7: Extract Bytecode and ABI');
+  console.log('===================================');
+  console.log('In Remix IDE:');
+  console.log('1. Stay in the "Solidity Compiler" tab');
+  console.log('2. Look for "ZipFileNFT" in the compiled contracts section');
+  console.log('3. Click on "ZipFileNFT" to expand it');
+  console.log('4. You\'ll see several options - we need two:\n');
+  
+  console.log('📄 For BYTECODE:');
+  console.log('• Click on "ZipFileNFT" contract name');
+  console.log('• Scroll down to find "BYTECODE" section');
+  console.log('• Copy the "object" field (starts with 0x...)');
+  console.log('• This is your CONTRACT_BYTECODE\n');
+  
+  console.log('📄 For ABI:');
+  console.log('• In the same expanded view');
+  console.log('• Look for "ABI" section');
+  console.log('• Copy the entire ABI array');
+  console.log('• This is your CONTRACT_ABI\n');
+  
+  await askQuestion('Have you copied both BYTECODE and ABI? Press Enter when ready...');
+  console.clear();
+  
+  // Step 8: Update deployment script
+  console.log('🔧 Step 8: Update Deployment Script');
+  console.log('===================================');
+  console.log('Now you need to update the deployment script with your compiled data:\n');
+  
+  console.log('📁 File to edit: contracts/deploy/deploy-public-contract.js\n');
+  
+  console.log('🔍 Find these lines and replace:');
+  console.log('1. Look for: const CONTRACT_BYTECODE = "0x608060..."; // PLACEHOLDER');
+  console.log('   Replace with your copied bytecode\n');
+  
+  console.log('2. Look for: const CONTRACT_ABI = [ // PLACEHOLDER ABI');
+  console.log('   Replace with your copied ABI array\n');
+  
+  console.log('💡 Tips:');
+  console.log('• Bytecode should be one long string starting with 0x');
+  console.log('• ABI should be an array of function definitions');
+  console.log('• Keep the semicolons and proper formatting\n');
+  
+  await askQuestion('Have you updated the deployment script? Press Enter when ready...');
+  console.clear();
+  
+  // Step 9: Deploy
+  console.log('🚀 Step 9: Deploy Your Contract');
+  console.log('===============================');
+  console.log('Now you\'re ready to deploy!\n');
+  
+  console.log('📋 Pre-deployment checklist:');
+  console.log('✅ Contract compiled successfully');
+  console.log('✅ Bytecode copied to deployment script');
+  console.log('✅ ABI copied to deployment script');
+  console.log('✅ Wallet has ETH for gas fees\n');
+  
+  console.log('🎯 Deploy commands:');
+  console.log('# Setup deployment configuration (if not done)');
+  console.log('npm run setup-deployment\n');
+  
+  console.log('# Deploy to Base Sepolia (testnet)');
+  console.log('npm run deploy:public\n');
+  
+  console.log('# Deploy to Base Mainnet (production)');
+  console.log('CHAIN_ID=8453 npm run deploy:public\n');
+  
+  console.log('🎉 Congratulations!');
+  console.log('You\'ve successfully compiled your NZIP NFT contract using Remix IDE.');
+  console.log('Your contract is now ready for deployment to the blockchain!\n');
+  
+  console.log('📚 Need help with deployment?');
+  console.log('• Run: npm run setup-deployment');
+  console.log('• Check: contracts/docs/DEPLOYMENT_GUIDE.md');
+  
+  rl.close();
+}
+
+main().catch(console.error); 

package/contracts/setup-deployment.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+/**
+ * Deployment Setup Helper for NZIP Contracts
+ * 
+ * This script helps you set up deployment configuration
+ * Usage: node setup-deployment.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🚀 NZIP Contract Deployment Setup');
+console.log('==================================\n');
+
+// Check current status
+const configPath = path.join(__dirname, 'deployment.config.js');
+const examplePath = path.join(__dirname, 'deployment.config.example.js');
+
+if (fs.existsSync(configPath)) {
+  console.log('✅ deployment.config.js already exists');
+  
+  try {
+    const config = require(configPath);
+    console.log(`📋 Chain ID: ${config.CHAIN_ID || 'Not set'}`);
+    console.log(`📋 Private Key: ${config.PRIVATE_KEY ? '✅ Set' : '❌ Not set'}`);
+    console.log(`📋 Existing Contract: ${config.EXISTING_CONTRACT || 'None'}`);
+  } catch (err) {
+    console.log('⚠️  Config file exists but has errors:', err.message);
+  }
+} else {
+  console.log('📁 Creating deployment.config.js from template...');
+  
+  if (fs.existsSync(examplePath)) {
+    fs.copyFileSync(examplePath, configPath);
+    console.log('✅ Created deployment.config.js');
+    console.log('📝 Edit this file to add your PRIVATE_KEY');
+  } else {
+    console.log('❌ deployment.config.example.js not found');
+  }
+}
+
+console.log('\n🎯 Next Steps:');
+console.log('1. Edit deployment.config.js and uncomment PRIVATE_KEY');
+console.log('2. Add your wallet private key (without 0x prefix)');
+console.log('3. Make sure you have ETH for gas fees');
+console.log('4. Run: npm run deploy:public');
+
+console.log('\n⚠️  Important Notice:');
+console.log('Previous contract is now DEPRECATED: 0xb78CB3bcC788fca38c731b1E9D70CF60b04CA015');
+console.log('You must deploy a new contract for production use!'); 

package/contracts/src/NZIP-NFT-Private.sol

@@ -0,0 +1,350 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title NZIP NFT Private Contract v2.0
+ * @dev Private NFT contract for tokenizing ZIP files with blockchain metadata
+ * Features:
+ * - Blockchain metadata (block number, timestamps)
+ * - Multiple tokens allowed for same content (differentiated by timestamp)
+ * - PRIVATE access control - only token owners can verify their tokens
+ * - Enhanced events with blockchain context
+ * - Selective authorization system for third-party verification
+ * - Improved input validation and error handling
+ * - Removed unreliable block hash storage
+ * 
+ * Version: 2.0 (New Production Contract - Previous contract deprecated)
+ * Network: Base Sepolia (for testing) / Base Mainnet (for production)
+ * 
+ * Privacy Model: Owner-controlled verification with optional authorization
+ */
+contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
+    
+    // Counter for token IDs
+    uint256 private _tokenIdCounter;
+    
+    // Struct to store ZIP file information - Latest Enhanced Version
+    struct ZipFileInfo {
+        // File identification
+        string fileName;           // Original ZIP file name
+        string merkleRootHash;     // Merkle root hash of the ZIP contents (PRIVATE)
+        string ipfsHash;           // IPFS hash where the ZIP file is stored (PRIVATE)
+        address creator;           // Address that created/minted this token
+        
+        // Timestamps (grouped together)
+        uint256 creationTimestamp; // Timestamp when the ZIP was created (user-provided)
+        uint256 tokenizationTime;  // Timestamp when the NFT was minted (block.timestamp)
+        
+        // Blockchain metadata
+        uint256 blockNumber;       // Block number when the token was minted
+        // Note: Block hash removed - blockhash(block.number) always returns 0
+    }
+    
+    // PRIVATE storage mappings - not accessible by public
+    mapping(uint256 => ZipFileInfo) private zipFileInfo;
+    
+    // Mapping from composite key (merkleRoot + timestamp) to token ID
+    // This prevents duplicate tokens with same content AND same timestamp
+    mapping(bytes32 => uint256) private compositeKeyToTokenId;
+    
+    // Authorization system - token owners can authorize specific addresses for verification
+    mapping(uint256 => mapping(address => bool)) public authorizedVerifiers;
+    
+    // Events - Enhanced with blockchain metadata (but verification still requires authorization)
+    // Note: merkleRootHash included for verification - privacy handled via access control
+    // Note: ipfsHash excluded from event for privacy
+    // Note: Block hash removed - not reliably available during execution
+    event ZipFileTokenized(
+        uint256 indexed tokenId,
+        address indexed creator,
+        string fileName,
+        string merkleRootHash,
+        uint256 creationTimestamp,
+        uint256 tokenizationTime,
+        uint256 blockNumber
+    );
+    
+    event VerifierAuthorized(
+        uint256 indexed tokenId,
+        address indexed authorizedAddress,
+        bool authorized
+    );
+    
+    // Custom errors
+    error NotTokenOwner(uint256 tokenId, address caller);
+    error NotAuthorized(uint256 tokenId, address caller);
+    error TokenDoesNotExist(uint256 tokenId);
+    error ZipFileAlreadyTokenized(string merkleRootHash, uint256 timestamp);
+    
+    // Access control modifier
+    modifier onlyTokenOwner(uint256 tokenId) {
+        if (ownerOf(tokenId) != msg.sender) {
+            revert NotTokenOwner(tokenId, msg.sender);
+        }
+        _;
+    }
+    
+    // Access control modifier for authorized verifiers
+    modifier onlyAuthorized(uint256 tokenId) {
+        address owner = ownerOf(tokenId);
+        if (owner != msg.sender && !authorizedVerifiers[tokenId][msg.sender]) {
+            revert NotAuthorized(tokenId, msg.sender);
+        }
+        _;
+    }
+    
+    constructor() ERC721("NeoZip File NFT Private v2", "NZIPPRV") Ownable(msg.sender) {}
+    
+    /**
+     * @dev Get the contract version
+     * @return version The version string of this contract
+     */
+    function getVersion() public pure returns (string memory) {
+        return "2.0.0";
+    }
+    
+    /**
+     * @dev Generate composite key from merkle root and timestamp
+     * @param merkleRootHash The merkle root hash
+     * @param creationTimestamp The creation timestamp
+     * @return The composite key
+     */
+    function generateCompositeKey(
+        string memory merkleRootHash, 
+        uint256 creationTimestamp
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encodePacked(merkleRootHash, creationTimestamp));
+    }
+    
+    /**
+     * @dev Public minting function for ZIP files
+     * @param fileName Name of the ZIP file
+     * @param merkleRootHash Merkle root hash of the ZIP contents
+     * @param creationTimestamp Timestamp when the ZIP was created
+     * @param ipfsHash IPFS hash where the ZIP is stored
+     * @param metadataURI URI for the token metadata
+     * @return The newly minted token ID
+     */
+    function publicMintZipFile(
+        string memory fileName,
+        string memory merkleRootHash,
+        uint256 creationTimestamp,
+        string memory ipfsHash,
+        string memory metadataURI
+    ) public returns (uint256) {
+        // Input validation
+        require(bytes(fileName).length > 0, "File name cannot be empty");
+        require(bytes(merkleRootHash).length > 0, "Merkle root hash cannot be empty");
+        require(creationTimestamp > 0, "Creation timestamp must be greater than 0");
+        
+        // Generate composite key to check for duplicates
+        bytes32 compositeKey = generateCompositeKey(merkleRootHash, creationTimestamp);
+        
+        // Check if this exact combination already exists
+        if (compositeKeyToTokenId[compositeKey] != 0) {
+            revert ZipFileAlreadyTokenized(merkleRootHash, creationTimestamp);
+        }
+        
+        // Increment token counter
+        _tokenIdCounter++;
+        uint256 tokenId = _tokenIdCounter;
+        
+        // Mint the NFT to the caller
+        _safeMint(msg.sender, tokenId);
+        
+        // Set token URI if provided
+        if (bytes(metadataURI).length > 0) {
+            _setTokenURI(tokenId, metadataURI);
+        }
+        
+        // Store the ZIP file information with blockchain metadata
+        zipFileInfo[tokenId] = ZipFileInfo({
+            fileName: fileName,
+            merkleRootHash: merkleRootHash,
+            ipfsHash: ipfsHash,
+            creator: msg.sender,
+            creationTimestamp: creationTimestamp,
+            tokenizationTime: block.timestamp,
+            blockNumber: block.number
+        });
+        
+        // Store the composite key mapping
+        compositeKeyToTokenId[compositeKey] = tokenId;
+        
+        // Emit event with merkleRootHash for verification (ipfsHash excluded for privacy)
+        emit ZipFileTokenized(
+            tokenId,
+            msg.sender,
+            fileName,
+            merkleRootHash,
+            creationTimestamp,
+            block.timestamp,
+            block.number
+        );
+        
+        return tokenId;
+    }
+    
+    /**
+     * @dev Get ZIP file information for a token - OWNER OR AUTHORIZED ONLY
+     * @param tokenId The token ID to query
+     * @return ZipFileInfo struct containing all file and blockchain metadata
+     */
+    function getZipFileInfo(uint256 tokenId) external view onlyAuthorized(tokenId) returns (ZipFileInfo memory) {
+        if (_ownerOf(tokenId) == address(0)) {
+            revert TokenDoesNotExist(tokenId);
+        }
+        return zipFileInfo[tokenId];
+    }
+    
+    /**
+     * @dev Get basic public information about a token (safe for public viewing)
+     * @param tokenId The token ID to query
+     * @return fileName The file name
+     * @return creator The creator address
+     * @return tokenizationTime When the token was minted
+     * @return blockNumber Block number when minted
+     */
+    function getPublicTokenInfo(uint256 tokenId) external view returns (
+        string memory fileName,
+        address creator,
+        uint256 tokenizationTime,
+        uint256 blockNumber
+    ) {
+        if (_ownerOf(tokenId) == address(0)) {
+            revert TokenDoesNotExist(tokenId);
+        }
+        
+        ZipFileInfo memory info = zipFileInfo[tokenId];
+        return (info.fileName, info.creator, info.tokenizationTime, info.blockNumber);
+    }
+    
+    /**
+     * @dev Check if a ZIP file is already tokenized (for minting validation)
+     * @param merkleRootHash The merkle root hash to check
+     * @param creationTimestamp The creation timestamp to check
+     * @return exists Whether the combination exists
+     * @return tokenId The token ID if it exists (0 if not)
+     * Note: This is public for minting validation, but doesn't reveal token details
+     */
+    function isZipFileTokenized(
+        string memory merkleRootHash, 
+        uint256 creationTimestamp
+    ) external view returns (bool exists, uint256 tokenId) {
+        bytes32 compositeKey = generateCompositeKey(merkleRootHash, creationTimestamp);
+        tokenId = compositeKeyToTokenId[compositeKey];
+        exists = tokenId != 0;
+    }
+    
+    /**
+     * @dev Verify that a token matches the provided merkle root - OWNER OR AUTHORIZED ONLY
+     * @param tokenId The token ID to verify
+     * @param providedMerkleRoot The merkle root to check against
+     * @return isValid Whether the token matches the provided merkle root
+     */
+    function verifyZipFile(uint256 tokenId, string memory providedMerkleRoot) 
+        external view onlyAuthorized(tokenId) returns (bool isValid) {
+        if (_ownerOf(tokenId) == address(0)) {
+            revert TokenDoesNotExist(tokenId);
+        }
+        
+        return keccak256(abi.encodePacked(zipFileInfo[tokenId].merkleRootHash)) == 
+               keccak256(abi.encodePacked(providedMerkleRoot));
+    }
+    
+    /**
+     * @dev Authorize or revoke access for a specific address to verify this token
+     * @param tokenId The token ID to manage access for
+     * @param authorizedAddress The address to authorize or revoke
+     * @param authorized Whether to grant or revoke access
+     */
+    function authorizeVerifier(
+        uint256 tokenId, 
+        address authorizedAddress, 
+        bool authorized
+    ) external onlyTokenOwner(tokenId) {
+        authorizedVerifiers[tokenId][authorizedAddress] = authorized;
+        emit VerifierAuthorized(tokenId, authorizedAddress, authorized);
+    }
+    
+    /**
+     * @dev Check if an address is authorized to verify a specific token
+     * @param tokenId The token ID to check
+     * @param verifierAddress The address to check authorization for
+     * @return Whether the address is authorized
+     */
+    function isAuthorizedVerifier(uint256 tokenId, address verifierAddress) 
+        external view returns (bool) {
+        return authorizedVerifiers[tokenId][verifierAddress];
+    }
+    
+    /**
+     * @dev Get blockchain metadata for a token - OWNER OR AUTHORIZED ONLY
+     * @param tokenId The token ID to query
+     * @return blockNumber Block number when token was minted
+     * @return tokenizationTime Exact timestamp when token was minted
+     */
+    function getBlockchainMetadata(uint256 tokenId) external view onlyAuthorized(tokenId) returns (
+        uint256 blockNumber,
+        uint256 tokenizationTime
+    ) {
+        if (_ownerOf(tokenId) == address(0)) {
+            revert TokenDoesNotExist(tokenId);
+        }
+        ZipFileInfo memory info = zipFileInfo[tokenId];
+        return (info.blockNumber, info.tokenizationTime);
+    }
+    
+    /**
+     * @dev Get the current total supply of tokens
+     * @return The total number of tokens minted
+     */
+    function totalSupply() public view returns (uint256) {
+        return _tokenIdCounter;
+    }
+    
+    /**
+     * @dev Get the balance of tokens for an address
+     * @param owner The address to query
+     * @return The number of tokens owned by the address
+     */
+    function balanceOf(address owner) public view override(ERC721, IERC721) returns (uint256) {
+        require(owner != address(0), "ERC721: address zero is not a valid owner");
+        return super.balanceOf(owner);
+    }
+    
+    /**
+     * @dev Get all token IDs owned by a specific address (for owner's dashboard)
+     * @param owner The address to get tokens for
+     * @return tokenIds Array of token IDs owned by the address
+     */
+    function getTokensByOwner(address owner) external view returns (uint256[] memory) {
+        uint256 balance = balanceOf(owner);
+        uint256[] memory result = new uint256[](balance);
+        
+        uint256 counter = 0;
+        for (uint256 i = 1; i <= _tokenIdCounter; i++) {
+            if (_ownerOf(i) == owner) {
+                result[counter] = i;
+                counter++;
+                if (counter >= balance) break;
+            }
+        }
+        
+        return result;
+    }
+    
+    // Override required by Solidity
+    function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
+        return super.tokenURI(tokenId);
+    }
+    
+    // Override required by Solidity
+    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721URIStorage) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+}