neozipkit 0.2.1 → 0.3.0

package/dist/blockchain/ZipKitMinter.js

@@ -1,347 +0,0 @@
-#!/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

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

package/dist/blockchain/ZipKitNFT.js

@@ -1,7 +0,0 @@
-"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/ZipKitVerifier.d.ts

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-/**
- * ZipKitVerifier - Handles NFT token verification for ZIP files
- * Verifier API for NZIP-NFT smart contract.
- */
-import type { TokenMetadata } from './types';
-export interface VerificationOptions {
-    debug?: boolean;
-    skipHash?: boolean;
-}
-export interface VerificationResult {
-    success: boolean;
-    message: string;
-    tokenMetadata?: TokenMetadata;
-    verificationDetails?: {
-        tokenId: string;
-        network: string;
-        contractAddress: string;
-        merkleRoot: string;
-        mintDate: string;
-        calculatedMerkleRoot?: string;
-        declaredMerkleRoot?: string;
-        merkleRootMatch?: boolean;
-        onChainValid?: boolean;
-    };
-    errorDetails?: {
-        errorType: 'METADATA_ERROR' | 'MERKLE_ERROR' | 'NETWORK_ERROR' | 'CONTRACT_ERROR';
-        networkName?: string;
-        rpcUrl?: string;
-        contractAddress?: string;
-        tokenId?: string;
-        merkleRoot?: string;
-    };
-}
-/**
- * Blockchain Token Verifier for ZIP files
- */
-export declare class ZipKitVerifier {
-    private debug;
-    constructor(options?: VerificationOptions);
-    /**
-     * Extract and validate token metadata from ZIP
-     */
-    extractTokenMetadata(tokenBuffer: Buffer): Promise<{
-        success: boolean;
-        metadata?: TokenMetadata;
-        error?: string;
-    }>;
-    /**
-     * Map network name to RPC configuration
-     */
-    private getNetworkConfig;
-    /**
-     * Perform merkle root comparison
-     */
-    private compareMerkleRoots;
-    /**
-     * Verify token against blockchain
-     */
-    verifyOnChain(tokenId: string, contractAddress: string, networkConfig: any, merkleRoot: string): Promise<{
-        success: boolean;
-        isValid?: boolean;
-        error?: string;
-    }>;
-    /**
-     * Complete verification process
-     */
-    verifyToken(tokenMetadata: TokenMetadata, calculatedMerkleRoot: string | null, options?: VerificationOptions): Promise<VerificationResult>;
-}