neozipkit 0.1.1 → 0.2.1

package/dist/blockchain/ZipKitMinter.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ZipKitMinter - Handles NFT token minting for ZIP files
+ * Minter API for NZIP-NFT smart contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipKitMinter = void 0;
+exports.validatePrivateKey = validatePrivateKey;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+// Network configurations
+const NETWORK_CONFIGS = {
+    'base-sepolia': {
+        name: 'Base Sepolia',
+        rpcUrl: 'https://sepolia.base.org',
+        contractAddress: contracts_1.CONTRACT_CONFIGS[84532].address, // Use real contract address
+        explorerUrl: 'https://sepolia.basescan.org',
+        chainId: 84532
+    },
+    'base-mainnet': {
+        name: 'Base Mainnet',
+        rpcUrl: 'https://mainnet.base.org',
+        contractAddress: contracts_1.CONTRACT_CONFIGS[8453].address, // Use real contract address
+        explorerUrl: 'https://basescan.org',
+        chainId: 8453
+    }
+};
+/**
+ * Blockchain Token Minter for ZIP files
+ */
+class ZipKitMinter {
+    constructor(archiveName, merkleRoot, options) {
+        this.archiveName = archiveName;
+        this.merkleRoot = merkleRoot;
+        this.debug = options.debug || false;
+        // Get network configuration
+        this.networkConfig = NETWORK_CONFIGS[options.network];
+        if (!this.networkConfig) {
+            throw new Error(`Unsupported network: ${options.network}`);
+        }
+        // Initialize provider for the specified network
+        this.provider = new ethers_1.ethers.JsonRpcProvider(this.networkConfig.rpcUrl);
+        // Initialize wallet from private key
+        this.wallet = new ethers_1.ethers.Wallet(options.walletPrivateKey, this.provider);
+        // Initialize contract instance
+        this.contract = new ethers_1.ethers.Contract(this.networkConfig.contractAddress, contracts_1.NZIP_CONTRACT_ABI, this.wallet);
+        if (this.debug) {
+            console.log(`[DEBUG] ZipKitMinter initialized for ${this.networkConfig.name}`);
+            console.log(`[DEBUG] Archive: ${archiveName}, Merkle: ${merkleRoot.substring(0, 10)}...`);
+        }
+    }
+    /**
+     * Get wallet information
+     */
+    async getWalletInfo() {
+        const balance = await this.provider.getBalance(this.wallet.address);
+        const balanceInEth = ethers_1.ethers.formatEther(balance);
+        if (this.debug) {
+            console.log(`[DEBUG] Wallet ${this.wallet.address} balance: ${balanceInEth} ETH`);
+        }
+        return {
+            address: this.wallet.address,
+            balance: balanceInEth,
+            networkName: this.networkConfig.name
+        };
+    }
+    /**
+     * Check for existing tokens with same merkle root and verify ownership
+     */
+    async checkForDuplicates() {
+        try {
+            if (this.debug) {
+                console.log(`[DEBUG] Checking for existing tokens with merkle root: ${this.merkleRoot}`);
+                console.log(`[DEBUG] User wallet address: ${this.wallet.address}`);
+            }
+            // Call contract method to check if merkle root already exists
+            const existingTokenIds = await this.contract.getTokensByMerkleRoot(this.merkleRoot);
+            if (!existingTokenIds || existingTokenIds.length === 0) {
+                if (this.debug) {
+                    console.log(`[DEBUG] No existing tokens found for this merkle root`);
+                }
+                return {
+                    hasExistingTokens: false,
+                    allTokens: [],
+                    userOwnedTokens: [],
+                    othersTokens: []
+                };
+            }
+            if (this.debug) {
+                console.log(`[DEBUG] Found ${existingTokenIds.length} existing token(s)`);
+            }
+            // Check ownership and get token details for each token
+            const allTokens = [];
+            const userOwnedTokens = [];
+            const othersTokens = [];
+            for (const tokenId of existingTokenIds) {
+                const tokenIdStr = tokenId.toString();
+                try {
+                    // Get token owner
+                    const owner = await this.contract.ownerOf(tokenId);
+                    const isOwnedByUser = owner.toLowerCase() === this.wallet.address.toLowerCase();
+                    // Get token data
+                    let tokenData = null;
+                    try {
+                        tokenData = await this.contract.getZipFileInfo(tokenId);
+                    }
+                    catch (e) {
+                        if (this.debug) {
+                            console.log(`[DEBUG] Could not get token data for ${tokenIdStr}: ${e}`);
+                        }
+                    }
+                    const tokenInfo = {
+                        tokenId: tokenIdStr,
+                        owner: owner,
+                        isOwnedByUser: isOwnedByUser,
+                        tokenData: tokenData
+                    };
+                    allTokens.push(tokenInfo);
+                    if (isOwnedByUser) {
+                        userOwnedTokens.push(tokenInfo);
+                        if (this.debug) {
+                            console.log(`[DEBUG] Token ${tokenIdStr} is owned by user`);
+                        }
+                    }
+                    else {
+                        othersTokens.push(tokenInfo);
+                        if (this.debug) {
+                            console.log(`[DEBUG] Token ${tokenIdStr} is owned by ${owner}`);
+                        }
+                    }
+                }
+                catch (e) {
+                    if (this.debug) {
+                        console.log(`[DEBUG] Error checking ownership for token ${tokenIdStr}: ${e}`);
+                    }
+                }
+            }
+            return {
+                hasExistingTokens: true,
+                allTokens,
+                userOwnedTokens,
+                othersTokens
+            };
+        }
+        catch (error) {
+            if (this.debug) {
+                console.log(`[DEBUG] Error checking duplicates: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            // If the contract method doesn't exist or fails, assume no duplicates
+            return {
+                hasExistingTokens: false,
+                allTokens: [],
+                userOwnedTokens: [],
+                othersTokens: []
+            };
+        }
+    }
+    /**
+     * Estimate gas costs for minting
+     */
+    async estimateGasCosts() {
+        const creationTimestamp = Math.floor(Date.now() / 1000);
+        const metadata = this.createTokenMetadataString();
+        // Estimate gas for the minting transaction
+        const gasLimit = await this.contract.publicMintZipFile.estimateGas(this.archiveName, this.merkleRoot, creationTimestamp, '', // ipfsHash
+        metadata);
+        const feeData = await this.provider.getFeeData();
+        const gasPrice = feeData.gasPrice || BigInt(0);
+        const estimatedCost = ethers_1.ethers.formatEther(gasLimit * gasPrice);
+        if (this.debug) {
+            console.log(`[DEBUG] Gas estimate - Limit: ${gasLimit}, Price: ${gasPrice}, Cost: ${estimatedCost} ETH`);
+        }
+        return { gasLimit, gasPrice, estimatedCost };
+    }
+    /**
+     * Create token metadata string
+     */
+    createTokenMetadataString() {
+        const now = new Date();
+        return JSON.stringify({
+            name: `NeoZip Archive: ${this.archiveName}`,
+            description: `Tokenized ZIP archive with cryptographic proof of integrity`,
+            image: '', // Could be a thumbnail or icon
+            archiveName: this.archiveName,
+            merkleRoot: this.merkleRoot,
+            network: this.networkConfig.name,
+            createdAt: now.toISOString(),
+            timestamp: Math.floor(now.getTime() / 1000)
+        });
+    }
+    /**
+     * Create TokenMetadata object from minting result
+     */
+    createTokenMetadata(tokenId, transactionHash, blockNumber) {
+        const now = new Date();
+        return {
+            tokenId,
+            network: this.networkConfig.name,
+            contractAddress: this.networkConfig.contractAddress,
+            merkleRoot: this.merkleRoot,
+            mintDate: now.toLocaleDateString('en-US') + ' at ' + now.toLocaleTimeString('en-US'),
+            creationTimestamp: Math.floor(now.getTime() / 1000),
+            archiveName: this.archiveName,
+            transactionHash,
+            blockNumber
+        };
+    }
+    /**
+     * Mint new token on blockchain
+     */
+    async mintToken() {
+        try {
+            if (this.debug) {
+                console.log(`[DEBUG] Starting token minting process`);
+            }
+            // Generate token ID (could be random or sequential)
+            const tokenId = Math.floor(Math.random() * 1000000).toString();
+            const metadata = this.createTokenMetadataString();
+            const creationTimestamp = Math.floor(Date.now() / 1000);
+            if (this.debug) {
+                console.log(`[DEBUG] Generated token ID: ${tokenId}`);
+                console.log(`[DEBUG] Metadata: ${metadata.substring(0, 100)}...`);
+            }
+            // Call the contract publicMintZipFile function
+            const tx = await this.contract.publicMintZipFile(this.archiveName, this.merkleRoot, creationTimestamp, '', // ipfsHash (empty since we store in ZIP)
+            metadata);
+            if (this.debug) {
+                console.log(`[DEBUG] Transaction submitted: ${tx.hash}`);
+            }
+            // Wait for transaction confirmation
+            const receipt = await tx.wait();
+            if (this.debug) {
+                console.log(`[DEBUG] Transaction confirmed in block: ${receipt.blockNumber}`);
+                console.log(`[DEBUG] Gas used: ${receipt.gasUsed}`);
+            }
+            // Extract actual token ID from contract events
+            let actualTokenId = tokenId; // fallback
+            if (receipt.logs && receipt.logs.length > 0) {
+                try {
+                    const iface = new ethers_1.ethers.Interface(contracts_1.NZIP_CONTRACT_ABI);
+                    for (const log of receipt.logs) {
+                        try {
+                            const parsed = iface.parseLog(log);
+                            if (parsed?.name === 'ZipFileTokenized') {
+                                actualTokenId = parsed.args.tokenId.toString();
+                                if (this.debug) {
+                                    console.log(`[DEBUG] Actual token ID from contract event: ${actualTokenId}`);
+                                }
+                                break;
+                            }
+                        }
+                        catch (e) {
+                            // Ignore parsing errors for non-matching logs
+                        }
+                    }
+                }
+                catch (e) {
+                    if (this.debug) {
+                        console.log(`[DEBUG] Could not parse token ID from logs: ${e}`);
+                    }
+                }
+            }
+            const gasCost = ethers_1.ethers.formatEther(receipt.gasUsed * (receipt.gasPrice || BigInt(0)));
+            return {
+                success: true,
+                message: `Token successfully minted`,
+                tokenId: actualTokenId,
+                transactionHash: tx.hash,
+                contractAddress: this.networkConfig.contractAddress,
+                blockNumber: receipt.blockNumber,
+                walletAddress: this.wallet.address,
+                gasUsed: receipt.gasUsed.toString(),
+                gasCost
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown minting error';
+            if (this.debug) {
+                console.log(`[DEBUG] Minting failed: ${errorMessage}`);
+            }
+            return {
+                success: false,
+                message: errorMessage
+            };
+        }
+    }
+    /**
+     * Main minting process - checks for duplicates, then mints if needed
+     */
+    async processMinting() {
+        try {
+            // Get wallet information
+            const walletInfo = await this.getWalletInfo();
+            // Check for duplicates first (free operation)
+            const duplicateCheck = await this.checkForDuplicates();
+            if (duplicateCheck.hasExistingTokens) {
+                if (this.debug) {
+                    console.log(`[DEBUG] Existing tokens found, user will choose`);
+                }
+                return {
+                    walletInfo,
+                    duplicateCheck
+                };
+            }
+            // Estimate gas costs
+            const gasCosts = await this.estimateGasCosts();
+            // This is where the user would be prompted for confirmation in the calling code
+            // The actual minting happens in a separate call to mintToken()
+            return {
+                walletInfo,
+                duplicateCheck,
+                gasCosts
+            };
+        }
+        catch (error) {
+            throw new Error(`Minting process failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Complete the minting after user confirmation
+     */
+    async completeMinting() {
+        const mintingResult = await this.mintToken();
+        if (mintingResult.success && mintingResult.tokenId && mintingResult.transactionHash) {
+            const tokenMetadata = this.createTokenMetadata(mintingResult.tokenId, mintingResult.transactionHash, mintingResult.blockNumber);
+            return {
+                mintingResult,
+                tokenMetadata
+            };
+        }
+        return { mintingResult };
+    }
+}
+exports.ZipKitMinter = ZipKitMinter;
+/**
+ * Utility function to validate Ethereum private key
+ */
+function validatePrivateKey(privateKey) {
+    try {
+        new ethers_1.ethers.Wallet(privateKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/blockchain/ZipKitNFT.d.ts

@@ -0,0 +1,3 @@
+export { ZipKitMinter, ZipKitVerifier } from '.';
+export type { MintingOptions, MintingResult, DuplicateCheckResult, TokenInfo, WalletInfo, VerificationOptions, VerificationResult, } from '.';
+export type { TokenMetadata } from './types';

package/dist/blockchain/ZipKitNFT.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipKitVerifier = exports.ZipKitMinter = void 0;
+// Re-export NFT classes and types without aliases
+var _1 = require(".");
+Object.defineProperty(exports, "ZipKitMinter", { enumerable: true, get: function () { return _1.ZipKitMinter; } });
+Object.defineProperty(exports, "ZipKitVerifier", { enumerable: true, get: function () { return _1.ZipKitVerifier; } });

package/dist/blockchain/ZipKitOTS.d.ts

@@ -0,0 +1,135 @@
+import ZipEntry from '../shared/ZipEntry';
+declare global {
+    var _bitcore: any;
+}
+export interface TimestampResult {
+    merkleRoot: string | null;
+    ots: ArrayBuffer | null;
+    verified: boolean;
+    results: any | null;
+    error: string | null;
+    attestations: any | null;
+    upgradedOts: ArrayBuffer | null;
+}
+export interface TimestampInfo {
+    message: string;
+    results: string[];
+    attestDate: Date | null;
+    attestHeight: number | null;
+    submittedUri: string | null;
+    otsUpgraded: boolean;
+}
+export interface DeserializeOtsResult {
+    attestStr: string | null;
+    needsUpdateMsg: string | null;
+    attestationValues: any[];
+}
+export interface OtsVerifyResult {
+    status: 'none' | 'valid' | 'pending' | 'error';
+    message?: string;
+    blockHeight?: number;
+    attestedAt?: Date;
+    upgraded?: boolean;
+    upgradedOts?: Buffer;
+}
+/**
+ * Verifies an OpenTimestamps proof against a hash digest.
+ * @param hashDigest - SHA256 hash as hex string to verify
+ * @param ots - OpenTimestamps proof data
+ * @param options - Configuration options
+ * @param options.debug - Enable debug logging
+ * @returns Promise resolving to verification result, error object, or null if inputs invalid
+ */
+export declare function verifyOts(hashDigest: string | null, ots: ArrayBuffer | null, options?: {
+    debug?: boolean;
+}): Promise<TimestampResult | {
+    error: string;
+} | null>;
+/**
+ * Converts a Node.js Buffer to an ArrayBuffer.
+ * @param buf - Buffer to convert
+ * @returns ArrayBuffer with same data
+ */
+export declare function bufferToArrayBuffer(buf: Buffer): ArrayBuffer;
+/**
+ * Finds the OpenTimestamps entry in a ZIP file.
+ * Searches for TIMESTAMP_METADATA first, then TIMESTAMP_SUBMITTED.
+ * @param zip - ZipKit instance to search
+ * @returns ZIP entry containing OTS proof, or null if not found
+ */
+export declare function getOtsEntry(zip: any): any | null;
+/**
+ * Extracts OTS proof data from a ZIP entry.
+ * @param zip - ZipKit instance
+ * @param otsEntry - ZIP entry containing OTS data
+ * @returns Promise resolving to OTS proof buffer, or null if extraction fails
+ */
+export declare function getOtsBuffer(zip: any, otsEntry: any): Promise<Buffer | null>;
+/**
+ * Safely extracts merkle root from a ZIP file.
+ * @param zip - ZipKit instance
+ * @returns Merkle root hash string, or null if not available
+ */
+export declare function getMerkleRootSafe(zip: any): string | null;
+/**
+ * Verifies OpenTimestamps proof within a ZIP file.
+ * Extracts merkle root and OTS proof, then verifies against Bitcoin blockchain.
+ * @param zip - ZipKit instance containing files and OTS proof
+ * @returns Promise resolving to verification result with status: 'none', 'error', 'pending', or 'valid'
+ */
+export declare function verifyOtsZip(zip: any): Promise<OtsVerifyResult>;
+/**
+ * Creates an OpenTimestamps proof for a hash digest.
+ * Submits hash to OpenTimestamps servers for Bitcoin blockchain anchoring.
+ * @param hashDigest - SHA256 hash as hex string to timestamp
+ * @param options - Configuration options
+ * @param options.debug - Enable debug logging
+ * @returns Promise resolving to OTS proof buffer, or null if creation failed
+ */
+export declare function createTimestamp(hashDigest: string | null, options?: {
+    debug?: boolean;
+}): Promise<Buffer | null>;
+/**
+ * Deserializes OpenTimestamps verification result into JSON format.
+ * Extracts blockchain attestation data and transaction details.
+ * @param tsResult - Timestamp verification result to deserialize
+ * @param options - Configuration options
+ * @param options.debug - Enable debug logging
+ * @returns Promise resolving to JSON string with attestation data, or null if failed
+ */
+export declare function deserializeOts(tsResult: TimestampResult, options?: {
+    debug?: boolean;
+}): Promise<string | null>;
+/**
+ * Parses timestamp verification result into readable information.
+ * Formats blockchain attestation data with human-readable messages and dates.
+ * @param verifyResult - Timestamp verification result to parse
+ * @returns Promise resolving to formatted timestamp information
+ */
+export declare function parseVerifyResult(verifyResult: TimestampResult): Promise<TimestampInfo>;
+/**
+ * Creates an HTML certificate for OpenTimestamps verification.
+ * Generates a certificate file documenting the timestamp verification results.
+ * @param fileName - Base name for the ZIP file (used for certificate filename)
+ * @param zipEntries - Array of ZIP entries to include in certificate
+ * @param timestampResult - Verification result to document
+ * @returns Promise resolving to success message with certificate filename, or error message
+ */
+export declare function createCertificateOts(fileName: string, zipEntries: ZipEntry[], timestampResult: TimestampResult): Promise<string>;
+/**
+ * Upgrades OpenTimestamps proof in an existing ZIP file.
+ * Replaces old timestamp metadata with upgraded OTS proof data.
+ * @param zipFilePath - Path to ZIP file to upgrade
+ * @param upgradedOts - Buffer containing upgraded OTS proof
+ * @returns Promise that resolves when upgrade is complete
+ * @throws Error if upgrade fails
+ */
+export declare function upgradeOTS(zipFilePath: string, upgradedOts: Buffer): Promise<void>;
+/**
+ * Creates a ZIP metadata entry containing OpenTimestamps proof.
+ * Creates a special ZIP entry marked as metadata that stores OTS proof data.
+ * @param zipKit - ZipKit instance to add metadata entry to
+ * @param ots - Buffer containing OpenTimestamps proof data
+ * @returns ZIP entry containing OTS metadata, or null if creation failed
+ */
+export declare function createOtsMetadataEntry(zipKit: any, ots: Buffer | null): any | null;