neozipkit 0.2.1 → 0.3.0

package/contracts/scripts/compile-and-extract.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Compile and Extract Script for NeoZip NFT Contract
+ * 
+ * This script:
+ * 1. Compiles the NZIP-NFT.sol contract using Hardhat
+ * 2. Extracts the ABI and bytecode from compilation artifacts
+ * 3. Writes ABI.txt and Bytecode.txt in the contracts directory
+ * 
+ * Usage:
+ *   node scripts/compile-and-extract.js
+ *   or
+ *   yarn compile:extract
+ */
+
+const hre = require("hardhat");
+const fs = require("fs");
+const path = require("path");
+
+async function main() {
+  console.log("=".repeat(70));
+  console.log("🔨 Compiling NeoZip NFT Contract");
+  console.log("=".repeat(70));
+  console.log();
+
+  try {
+    // Compile the contract
+    console.log("📦 Compiling contracts...");
+    await hre.run("compile");
+    console.log("✅ Compilation successful!");
+    console.log();
+
+    // Get the contract artifact
+    const contractName = "ZipFileNFTPublic";
+    
+    // Read the build info to get the exact artifact
+    // Hardhat stores artifacts in artifacts/src/<source-file>/<contract-name>.json
+    const artifactPath = path.join(__dirname, "..", "artifacts", "src", "NZIP-NFT.sol", `${contractName}.json`);
+    
+    if (!fs.existsSync(artifactPath)) {
+      throw new Error(`Artifact not found at ${artifactPath}. Make sure the contract compiled successfully.`);
+    }
+
+    const artifact = JSON.parse(fs.readFileSync(artifactPath, "utf8"));
+    
+    // Extract ABI
+    const abi = artifact.abi;
+    if (!abi || abi.length === 0) {
+      throw new Error("ABI not found in artifact");
+    }
+
+    // Extract bytecode (deployment bytecode, not creation code)
+    let bytecode = artifact.bytecode;
+    if (!bytecode || bytecode === "0x") {
+      throw new Error("Bytecode not found in artifact");
+    }
+
+    // Remove 0x prefix if present (deploy-interactive.js handles adding it)
+    if (bytecode.startsWith("0x")) {
+      bytecode = bytecode.slice(2);
+    }
+
+    // Write to compiled files (NOT the deployment files)
+    // ABI.txt and Bytecode.txt are the DEPLOYED versions and must not be overwritten
+    const abiPath = path.join(__dirname, "..", "ABI-compiled.txt");
+    const bytecodePath = path.join(__dirname, "..", "Bytecode-compiled.txt");
+    
+    fs.writeFileSync(abiPath, JSON.stringify(abi, null, "\t"), "utf8");
+    console.log(`✅ ABI written to: ${path.relative(process.cwd(), abiPath)}`);
+    console.log(`   ⚠️  Note: This is the COMPILED ABI, not the deployed ABI.txt`);
+
+    fs.writeFileSync(bytecodePath, bytecode, "utf8");
+    console.log(`✅ Bytecode written to: ${path.relative(process.cwd(), bytecodePath)}`);
+    console.log(`   ⚠️  Note: This is the COMPILED bytecode, not the deployed Bytecode.txt`);
+    console.log();
+
+    // Display summary
+    console.log("=".repeat(70));
+    console.log("📊 Compilation Summary");
+    console.log("=".repeat(70));
+    console.log(`Contract: ${contractName}`);
+    console.log(`ABI Functions: ${abi.filter(item => item.type === "function").length}`);
+    console.log(`Bytecode Length: ${bytecode.length} characters (${Math.floor(bytecode.length / 2)} bytes)`);
+    console.log();
+    console.log("⚠️  IMPORTANT: These are COMPILED files, not the deployed files!");
+    console.log("   - ABI-compiled.txt: Newly compiled ABI");
+    console.log("   - Bytecode-compiled.txt: Newly compiled bytecode");
+    console.log();
+    console.log("   The deployed files (ABI.txt and Bytecode.txt) were NOT modified.");
+    console.log("   To use the new compilation for deployment:");
+    console.log("   1. Review the compiled files");
+    console.log("   2. If correct, manually copy them to ABI.txt and Bytecode.txt");
+    console.log("   3. Then use deploy-interactive.js to deploy");
+    console.log();
+
+  } catch (error) {
+    console.error();
+    console.error("❌ Error during compilation:");
+    console.error(error.message);
+    if (error.stack) {
+      console.error();
+      console.error("Stack trace:");
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run the script
+main()
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+

package/contracts/scripts/verify-contract.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+/**
+ * Contract Verification Script for NeoZip NFT Contract
+ * 
+ * This script verifies a deployed contract on the appropriate blockchain scanner
+ * using Hardhat's verify plugin and Etherscan API V2.
+ * 
+ * Usage:
+ *   node scripts/verify-contract.js <contractAddress> <network>
+ *   or
+ *   yarn verify <contractAddress> <network>
+ * 
+ * Examples:
+ *   node scripts/verify-contract.js 0x1234...5678 arbitrumSepolia
+ *   node scripts/verify-contract.js 0x1234...5678 sepolia
+ *   node scripts/verify-contract.js 0x1234...5678 baseSepolia
+ * 
+ * Supported Networks:
+ *   - ethereum (Ethereum Mainnet)
+ *   - sepolia (Ethereum Sepolia)
+ *   - base (Base Mainnet)
+ *   - baseSepolia (Base Sepolia)
+ *   - arbitrum (Arbitrum One)
+ *   - arbitrumSepolia (Arbitrum Sepolia)
+ *   - polygon (Polygon Mainnet)
+ *   - polygonSepolia (Polygon Sepolia)
+ */
+
+const hre = require("hardhat");
+const path = require("path");
+
+// Network name mapping (user-friendly to Hardhat network names)
+const NETWORK_MAP = {
+  "eth": "ethereum",
+  "ethereum": "ethereum",
+  "eth-sepolia": "sepolia",
+  "sepolia": "sepolia",
+  "base": "base",
+  "base-sepolia": "baseSepolia",
+  "baseSepolia": "baseSepolia",
+  "arbitrum": "arbitrum",
+  "arbitrum-one": "arbitrum",
+  "arbitrum-sepolia": "arbitrumSepolia",
+  "arbitrumSepolia": "arbitrumSepolia",
+  "polygon": "polygon",
+  "polygon-sepolia": "polygonSepolia",
+  "polygonSepolia": "polygonSepolia",
+  "amoy": "polygonSepolia"
+};
+
+function getNetworkName(userInput) {
+  const normalized = userInput.toLowerCase().trim();
+  return NETWORK_MAP[normalized] || normalized;
+}
+
+function validateAddress(address) {
+  if (!address || typeof address !== "string") {
+    return false;
+  }
+  // Basic Ethereum address validation
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+
+async function main() {
+  console.log("=".repeat(70));
+  console.log("🔍 NeoZip NFT Contract Verification");
+  console.log("=".repeat(70));
+  console.log();
+
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  
+  if (args.length < 2) {
+    console.error("❌ Error: Missing required arguments");
+    console.error();
+    console.error("Usage: node scripts/verify-contract.js <contractAddress> <network>");
+    console.error();
+    console.error("Examples:");
+    console.error("  node scripts/verify-contract.js 0x1234...5678 arbitrumSepolia");
+    console.error("  node scripts/verify-contract.js 0x1234...5678 sepolia");
+    console.error();
+    console.error("Supported networks:");
+    console.error("  - ethereum, sepolia");
+    console.error("  - base, baseSepolia");
+    console.error("  - arbitrum, arbitrumSepolia");
+    console.error("  - polygon, polygonSepolia");
+    console.error();
+    process.exit(1);
+  }
+
+  const contractAddress = args[0];
+  const networkInput = args[1];
+  const networkName = getNetworkName(networkInput);
+
+  // Validate contract address
+  if (!validateAddress(contractAddress)) {
+    console.error(`❌ Error: Invalid contract address: ${contractAddress}`);
+    console.error("   Address must be a valid Ethereum address (0x followed by 40 hex characters)");
+    process.exit(1);
+  }
+
+  // Check if network is configured
+  const networks = hre.config.networks;
+  if (!networks[networkName]) {
+    console.error(`❌ Error: Network '${networkName}' is not configured in hardhat.config.js`);
+    console.error();
+    console.error("Available networks:");
+    Object.keys(networks).forEach(net => {
+      console.error(`  - ${net}`);
+    });
+    process.exit(1);
+  }
+
+  // Check for API key
+  const apiKey = hre.config.etherscan?.apiKey?.[networkName] || 
+                 hre.config.etherscan?.apiKey?.mainnet ||
+                 process.env.ETHERSCAN_API_KEY;
+
+  if (!apiKey) {
+    console.error("❌ Error: Etherscan API key not found");
+    console.error();
+    console.error("Please set one of the following:");
+    console.error("  - ETHERSCAN_API_KEY environment variable");
+    console.error("  - etherscan.apiKey in hardhat.config.js");
+    console.error();
+    console.error("Get your API key from:");
+    console.error("  https://etherscan.io/apis (works for all Etherscan-based explorers)");
+    process.exit(1);
+  }
+
+  console.log(`📋 Contract Address: ${contractAddress}`);
+  console.log(`🌐 Network: ${networkName}`);
+  console.log();
+
+  try {
+    console.log("🔍 Verifying contract on blockchain scanner...");
+    console.log("   This may take a few moments...");
+    console.log();
+
+    // Verify the contract
+    // The contract has no constructor arguments
+    await hre.run("verify:verify", {
+      address: contractAddress,
+      network: networkName
+    });
+
+    console.log();
+    console.log("=".repeat(70));
+    console.log("✅ Contract verified successfully!");
+    console.log("=".repeat(70));
+    console.log();
+
+    // Get explorer URL
+    const networkConfig = networks[networkName];
+    let explorerUrl = "";
+    
+    if (networkName === "sepolia") {
+      explorerUrl = `https://sepolia.etherscan.io/address/${contractAddress}`;
+    } else if (networkName === "ethereum") {
+      explorerUrl = `https://etherscan.io/address/${contractAddress}`;
+    } else if (networkName === "baseSepolia") {
+      explorerUrl = `https://sepolia.basescan.org/address/${contractAddress}`;
+    } else if (networkName === "base") {
+      explorerUrl = `https://basescan.org/address/${contractAddress}`;
+    } else if (networkName === "arbitrumSepolia") {
+      explorerUrl = `https://sepolia.arbiscan.io/address/${contractAddress}`;
+    } else if (networkName === "arbitrum") {
+      explorerUrl = `https://arbiscan.io/address/${contractAddress}`;
+    } else if (networkName === "polygonSepolia") {
+      explorerUrl = `https://amoy.polygonscan.com/address/${contractAddress}`;
+    } else if (networkName === "polygon") {
+      explorerUrl = `https://polygonscan.com/address/${contractAddress}`;
+    }
+
+    if (explorerUrl) {
+      console.log(`🔗 View contract on explorer:`);
+      console.log(`   ${explorerUrl}`);
+      console.log();
+    }
+
+  } catch (error) {
+    console.error();
+    console.error("❌ Verification failed:");
+    
+    if (error.message.includes("Already Verified")) {
+      console.error("   Contract is already verified on the explorer.");
+      console.error("   This is not an error - the contract is already public.");
+    } else if (error.message.includes("bytecode")) {
+      console.error("   Bytecode mismatch detected.");
+      console.error("   This usually means:");
+      console.error("   1. The contract was compiled with different settings");
+      console.error("   2. The contract source code has changed");
+      console.error("   3. The deployed bytecode doesn't match the source");
+      console.error();
+      console.error("   Solution:");
+      console.error("   1. Recompile the contract: yarn compile:extract");
+      console.error("   2. Redeploy with the new bytecode");
+      console.error("   3. Or verify using the exact compiler settings used for deployment");
+    } else {
+      console.error(`   ${error.message}`);
+    }
+    
+    if (error.stack && !error.message.includes("Already Verified")) {
+      console.error();
+      console.error("Stack trace:");
+      console.error(error.stack);
+    }
+    
+    process.exit(1);
+  }
+}
+
+// Run the script
+main()
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error("Unexpected error:", error);
+    process.exit(1);
+  });
+

package/contracts/src/{NZIP-NFT-Private.sol → NZIP-NFT-v2.0.sol}

@@ -6,33 +6,31 @@ 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
+ * @title NZIP NFT Contract v2.0
+ * @dev Main NFT contract for tokenizing ZIP files with blockchain metadata
  * Features:
- * - Blockchain metadata (block number, timestamps)
+ * - 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
+ * - Structured data organization for better maintainability
  * - Improved input validation and error handling
  * - Removed unreliable block hash storage
  * 
  * Version: 2.0 (New Production Contract - Previous contract deprecated)
+ * Previous Contract: 0xb78CB3bcC788fca38c731b1E9D70CF60b04CA015 (DEPRECATED)
  * Network: Base Sepolia (for testing) / Base Mainnet (for production)
- * 
- * Privacy Model: Owner-controlled verification with optional authorization
  */
-contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
+contract ZipFileNFT is ERC721, ERC721URIStorage, Ownable {
     
     // Counter for token IDs
     uint256 private _tokenIdCounter;
     
-    // Struct to store ZIP file information - Latest Enhanced Version
+    // Struct to store ZIP file information - Latest 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)
+        string merkleRootHash;     // Merkle root hash of the ZIP contents
+        string ipfsHash;           // IPFS hash where the ZIP file is stored
         address creator;           // Address that created/minted this token
         
         // Timestamps (grouped together)
@@ -41,63 +39,28 @@ contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
         
         // 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 token ID to ZIP file information
+    mapping(uint256 => ZipFileInfo) public 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;
+    mapping(bytes32 => uint256) public compositeKeyToTokenId;
     
-    // 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
+    // Events - Enhanced with blockchain metadata
     event ZipFileTokenized(
         uint256 indexed tokenId,
         address indexed creator,
         string fileName,
         string merkleRootHash,
         uint256 creationTimestamp,
+        string ipfsHash,
         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) {}
+    constructor() ERC721("NeoZip File NFT v2", "NZIP") Ownable(msg.sender) {}
     
     /**
      * @dev Get the contract version
@@ -145,9 +108,7 @@ contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
         bytes32 compositeKey = generateCompositeKey(merkleRootHash, creationTimestamp);
         
         // Check if this exact combination already exists
-        if (compositeKeyToTokenId[compositeKey] != 0) {
-            revert ZipFileAlreadyTokenized(merkleRootHash, creationTimestamp);
-        }
+        require(compositeKeyToTokenId[compositeKey] == 0, "ZIP file with this content and timestamp already tokenized");
         
         // Increment token counter
         _tokenIdCounter++;
@@ -175,13 +136,14 @@ contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
         // Store the composite key mapping
         compositeKeyToTokenId[compositeKey] = tokenId;
         
-        // Emit event with merkleRootHash for verification (ipfsHash excluded for privacy)
+        // Emit event with blockchain metadata
         emit ZipFileTokenized(
             tokenId,
             msg.sender,
             fileName,
             merkleRootHash,
             creationTimestamp,
+            ipfsHash,
             block.timestamp,
             block.number
         );
@@ -190,46 +152,21 @@ contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
     }
     
     /**
-     * @dev Get ZIP file information for a token - OWNER OR AUTHORIZED ONLY
+     * @dev Get ZIP file information for a token
      * @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);
-        }
+    function getZipFileInfo(uint256 tokenId) external view returns (ZipFileInfo memory) {
+        require(_ownerOf(tokenId) != address(0), "Token does not exist");
         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)
+     * @dev Check if a ZIP file is already tokenized
      * @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, 
@@ -241,62 +178,46 @@ contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
     }
     
     /**
-     * @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
+     * @dev Get all token IDs for a specific merkle root (across all timestamps)
+     * @param merkleRoot The merkle root to search for
+     * @return tokenIds Array of token IDs with this merkle root
      */
-    function verifyZipFile(uint256 tokenId, string memory providedMerkleRoot) 
-        external view onlyAuthorized(tokenId) returns (bool isValid) {
-        if (_ownerOf(tokenId) == address(0)) {
-            revert TokenDoesNotExist(tokenId);
+    function getTokensByMerkleRoot(string memory merkleRoot) external view returns (uint256[] memory) {
+        // Create dynamic array to collect matching tokens
+        uint256[] memory tempTokens = new uint256[](_tokenIdCounter);
+        uint256 count = 0;
+        
+        // Search through all tokens
+        for (uint256 i = 1; i <= _tokenIdCounter; i++) {
+            if (_ownerOf(i) != address(0)) { // Token exists
+                if (keccak256(abi.encodePacked(zipFileInfo[i].merkleRootHash)) == 
+                    keccak256(abi.encodePacked(merkleRoot))) {
+                    tempTokens[count] = i;
+                    count++;
+                }
+            }
         }
         
-        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];
+        // Create result array with exact size
+        uint256[] memory result = new uint256[](count);
+        for (uint256 i = 0; i < count; i++) {
+            result[i] = tempTokens[i];
+        }
+        
+        return result;
     }
     
     /**
-     * @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
+     * @dev Verify that a token matches the provided merkle root
+     * @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 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);
+    function verifyZipFile(uint256 tokenId, string memory providedMerkleRoot) external view returns (bool isValid) {
+        require(_ownerOf(tokenId) != address(0), "Token does not exist");
+        
+        return keccak256(abi.encodePacked(zipFileInfo[tokenId].merkleRootHash)) == 
+               keccak256(abi.encodePacked(providedMerkleRoot));
     }
     
     /**
@@ -318,24 +239,18 @@ contract ZipFileNFTPrivate is ERC721, ERC721URIStorage, Ownable {
     }
     
     /**
-     * @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
+     * @dev Get blockchain metadata for a token
+     * @param tokenId The token ID to query
+     * @return blockNumber Block number when token was minted
+     * @return tokenizationTime Exact timestamp when token was minted
      */
-    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;
+    function getBlockchainMetadata(uint256 tokenId) public view returns (
+        uint256 blockNumber,
+        uint256 tokenizationTime
+    ) {
+        require(_ownerOf(tokenId) != address(0), "Token does not exist");
+        ZipFileInfo memory info = zipFileInfo[tokenId];
+        return (info.blockNumber, info.tokenizationTime);
     }
     
     // Override required by Solidity