neozipkit 0.1.1

package/contracts/src/ZipFileNFT-DEPRECATED-Enhanced.sol

@@ -0,0 +1,289 @@
+// 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 ZipFileNFT Enhanced
+ * @dev Enhanced NFT contract for tokenizing ZIP files with comprehensive blockchain metadata
+ * Version 2.0 - Includes block number, block hash, and reorganized timestamp structure
+ * Allows multiple tokens for the same content by using timestamp as a differentiator
+ */
+contract ZipFileNFTEnhanced is ERC721, ERC721URIStorage, Ownable {
+    
+    // Counter for token IDs
+    uint256 private _tokenIdCounter;
+    
+    // Struct to store ZIP file information - Enhanced Version 2.0
+    struct ZipFileInfo {
+        // File identification
+        string fileName;           // Original ZIP file name
+        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)
+        uint256 creationTimestamp; // Timestamp when the ZIP was created (user-provided)
+        uint256 tokenizationTime;  // Timestamp when the NFT was minted (block.timestamp)
+        
+        // Blockchain metadata (grouped with timestamps)
+        uint256 blockNumber;       // Block number when the token was minted
+        bytes32 blockHash;         // Block hash when the token was minted
+    }
+    
+    // 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) public compositeKeyToTokenId;
+    
+    // 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,
+        bytes32 blockHash
+    );
+    
+    constructor() ERC721("NeoZip File NFT Enhanced", "NZIP") Ownable(msg.sender) {}
+    
+    /**
+     * @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
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(merkleRootHash, creationTimestamp));
+    }
+    
+    /**
+     * @dev Mint a new NFT representing a ZIP file with timestamp
+     * @param to Address to mint the token to
+     * @param fileName Original 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 file is stored
+     * @param tokenURI Metadata URI for the token
+     * @return tokenId The ID of the newly minted token
+     */
+    function mintZipFileToken(
+        address to,
+        string memory fileName,
+        string memory merkleRootHash,
+        uint256 creationTimestamp,
+        string memory ipfsHash,
+        string memory tokenURI
+    ) public returns (uint256) {
+        require(bytes(merkleRootHash).length > 0, "Merkle root hash cannot be empty");
+        require(bytes(fileName).length > 0, "File name cannot be empty");
+        require(creationTimestamp > 0, "Creation timestamp must be greater than 0");
+        
+        // Generate composite key
+        bytes32 compositeKey = _generateCompositeKey(merkleRootHash, creationTimestamp);
+        
+        // Check that this specific combination hasn't been tokenized before
+        require(compositeKeyToTokenId[compositeKey] == 0, "ZIP file with this timestamp already tokenized");
+        
+        uint256 tokenId = _tokenIdCounter;
+        _tokenIdCounter++;
+        
+        // Mint the token
+        _safeMint(to, tokenId);
+        _setTokenURI(tokenId, tokenURI);
+        
+        // Store ZIP file information with enhanced blockchain metadata
+        zipFileInfo[tokenId] = ZipFileInfo({
+            fileName: fileName,
+            merkleRootHash: merkleRootHash,
+            ipfsHash: ipfsHash,
+            creator: msg.sender,
+            creationTimestamp: creationTimestamp,
+            tokenizationTime: block.timestamp,
+            blockNumber: block.number,
+            blockHash: blockhash(block.number)
+        });
+        
+        // Map composite key to token ID for duplicate prevention
+        compositeKeyToTokenId[compositeKey] = tokenId;
+        
+        // Emit enhanced event with blockchain metadata
+        emit ZipFileTokenized(
+            tokenId, 
+            to, 
+            fileName, 
+            merkleRootHash, 
+            creationTimestamp, 
+            ipfsHash, 
+            block.timestamp, 
+            block.number, 
+            blockhash(block.number)
+        );
+        
+        return tokenId;
+    }
+    
+    /**
+     * @dev Public minting function with timestamp
+     * @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 file is stored
+     * @param tokenURI Metadata URI for the token
+     * @return tokenId The ID of the newly minted token
+     */
+    function publicMintZipFile(
+        string memory fileName,
+        string memory merkleRootHash,
+        uint256 creationTimestamp,
+        string memory ipfsHash,
+        string memory tokenURI
+    ) public returns (uint256) {
+        return mintZipFileToken(
+            msg.sender,
+            fileName,
+            merkleRootHash,
+            creationTimestamp,
+            ipfsHash,
+            tokenURI
+        );
+    }
+    
+    /**
+     * @dev Verify a ZIP file against its token
+     * @param tokenId Token ID to verify
+     * @param providedMerkleRoot Merkle root to verify against
+     * @return isValid Whether the provided hash matches the stored one
+     */
+    function verifyZipFile(
+        uint256 tokenId,
+        string memory providedMerkleRoot
+    ) public view returns (bool isValid) {
+        require(_ownerOf(tokenId) != address(0), "Token does not exist");
+        
+        ZipFileInfo memory info = zipFileInfo[tokenId];
+        
+        isValid = keccak256(abi.encodePacked(info.merkleRootHash)) == keccak256(abi.encodePacked(providedMerkleRoot));
+        
+        return isValid;
+    }
+    
+    /**
+     * @dev Get information about a ZIP file token - Enhanced version
+     * @param tokenId Token ID to query
+     * @return info Complete ZipFileInfo struct with blockchain metadata
+     */
+    function getZipFileInfo(uint256 tokenId) public view returns (ZipFileInfo memory info) {
+        require(_ownerOf(tokenId) != address(0), "Token does not exist");
+        return zipFileInfo[tokenId];
+    }
+    
+    /**
+     * @dev Check if a ZIP file with specific timestamp has been tokenized
+     * @param merkleRootHash Merkle root to check
+     * @param creationTimestamp Creation timestamp to check
+     * @return exists Whether a token exists for this combination
+     * @return tokenId The token ID if it exists (0 if not)
+     */
+    function isZipFileTokenized(
+        string memory merkleRootHash, 
+        uint256 creationTimestamp
+    ) public view returns (bool exists, uint256 tokenId) {
+        bytes32 compositeKey = _generateCompositeKey(merkleRootHash, creationTimestamp);
+        tokenId = compositeKeyToTokenId[compositeKey];
+        exists = (tokenId != 0);
+        return (exists, tokenId);
+    }
+    
+    /**
+     * @dev Get all tokens for a specific merkle root (regardless of timestamp)
+     * @param merkleRootHash Merkle root to search for
+     * @return tokenIds Array of token IDs that match this merkle root
+     */
+    function getTokensByMerkleRoot(string memory merkleRootHash) public view returns (uint256[] memory tokenIds) {
+        uint256 totalSupply = _tokenIdCounter;
+        uint256[] memory tempTokenIds = new uint256[](totalSupply);
+        uint256 count = 0;
+        
+        for (uint256 i = 0; i < totalSupply; i++) {
+            if (_ownerOf(i) != address(0)) {
+                ZipFileInfo memory info = zipFileInfo[i];
+                if (keccak256(abi.encodePacked(info.merkleRootHash)) == keccak256(abi.encodePacked(merkleRootHash))) {
+                    tempTokenIds[count] = i;
+                    count++;
+                }
+            }
+        }
+        
+        // Create properly sized array
+        tokenIds = new uint256[](count);
+        for (uint256 i = 0; i < count; i++) {
+            tokenIds[i] = tempTokenIds[i];
+        }
+        
+        return tokenIds;
+    }
+    
+    /**
+     * @dev Get the current token ID counter
+     * @return The next token ID that will be minted
+     */
+    function getCurrentTokenId() public view returns (uint256) {
+        return _tokenIdCounter;
+    }
+    
+    /**
+     * @dev Get total number of tokens minted
+     * @return Total supply of tokens
+     */
+    function totalSupply() public view returns (uint256) {
+        return _tokenIdCounter;
+    }
+    
+    /**
+     * @dev Update IPFS hash for a token (only by token owner)
+     * @param tokenId Token ID to update
+     * @param ipfsHash New IPFS hash
+     */
+    function updateIpfsHash(uint256 tokenId, string memory ipfsHash) public {
+        require(ownerOf(tokenId) == msg.sender, "Only token owner can update IPFS hash");
+        zipFileInfo[tokenId].ipfsHash = ipfsHash;
+    }
+    
+    /**
+     * @dev Get blockchain metadata for a token
+     * @param tokenId Token ID to query
+     * @return blockNumber Block number when token was minted
+     * @return blockHash Block hash when token was minted
+     * @return tokenizationTime Exact timestamp when token was minted
+     */
+    function getBlockchainMetadata(uint256 tokenId) public view returns (
+        uint256 blockNumber,
+        bytes32 blockHash,
+        uint256 tokenizationTime
+    ) {
+        require(_ownerOf(tokenId) != address(0), "Token does not exist");
+        ZipFileInfo memory info = zipFileInfo[tokenId];
+        return (info.blockNumber, info.blockHash, info.tokenizationTime);
+    }
+    
+    // Override required by Solidity
+    function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
+        return super.tokenURI(tokenId);
+    }
+    
+    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721URIStorage) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+} 

package/dist/browser/CertificateGeneratorBrowser.d.ts

@@ -0,0 +1,75 @@
+import { ZipEntry } from '../shared/ZipKit';
+import { BlockchainVerification } from './TokenVerifierBrowser';
+export interface TokenInfo {
+    tokenId: string;
+    contractAddress: string;
+    network: string;
+    transactionHash: string;
+    wallet?: string;
+    timestamp?: number;
+    note?: string;
+}
+export interface WalletInfo {
+    address: string;
+    network: string;
+    balance?: string;
+    ensName?: string;
+}
+export interface ZipFileInfo {
+    filename: string;
+    size: number;
+    date: string;
+    hash: string;
+}
+/**
+ * Browser-compatible certificate generator class
+ */
+export declare class CertificateGeneratorBrowser {
+    /**
+     * Generates a certificate HTML document for tokenized ZIP files
+     */
+    createTokenCertificate(tokenInfo: TokenInfo, zipFile: string, blockchainVerification: BlockchainVerification, walletInfo?: WalletInfo, zipFiles?: ZipFileInfo[], options?: {
+        narrow?: boolean;
+        includeQR?: boolean;
+    }): string;
+    /**
+     * Saves a certificate as a downloadable file (browser-compatible)
+     */
+    saveCertificate(fileName: string, certificateHTML: string): void;
+    /**
+     * Generate token information section
+     */
+    private generateTokenSection;
+    /**
+     * Generate blockchain verification section
+     */
+    private generateVerificationSection;
+    /**
+     * Generate wallet information section
+     */
+    private generateWalletSection;
+    /**
+     * Generate files table
+     */
+    private generateFilesTable;
+    /**
+     * Get the HTML template for certificates
+     */
+    private getCertificateTemplate;
+    /**
+     * Prepares file information from ZIP entries for certificate generation
+     */
+    prepareZipFileInfo(zipEntries: ZipEntry[]): ZipFileInfo[];
+    /**
+     * Formats the date from a ZIP entry
+     */
+    private formatEntryDate;
+}
+/**
+ * Creates a new CertificateGeneratorBrowser instance
+ */
+export declare function createCertificateGenerator(): CertificateGeneratorBrowser;
+/**
+ * Convenience function to generate a certificate
+ */
+export declare function generateTokenCertificate(tokenInfo: TokenInfo, zipFile: string, blockchainVerification: BlockchainVerification, walletInfo?: WalletInfo, zipFiles?: ZipFileInfo[]): string;