neozipkit 0.1.1

package/dist/server/blockchain/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export { WalletManager } from './WalletManager';
+export { NFTMinter } from './NFTMinter';
+export { ZipTokenProcessor } from './ZipTokenProcessor';
+export { ZipMetadata } from './ZipMetadata';
+export { checkForTokenization, TokenVerificationOptions, TokenVerificationResult } from './TokenVerifier';
+export { queryBlockchainForExistingToken, queryWalletTokens, ExistingTokenInfo, TokenQueryOptions } from './TokenQuerier';
+export { WalletAnalyzer, TokenInfo, NZipTokenDetails, WalletBasicInfo, TokenScanResult, CommonTokenConfig } from './WalletAnalyzer';
+export { WalletFormatter } from './WalletFormatter';

package/dist/server/blockchain/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletFormatter = exports.WalletAnalyzer = exports.queryWalletTokens = exports.queryBlockchainForExistingToken = exports.checkForTokenization = exports.ZipMetadata = exports.ZipTokenProcessor = exports.NFTMinter = exports.WalletManager = void 0;
+// Export all types
+__exportStar(require("./types"), exports);
+// Export wallet management
+var WalletManager_1 = require("./WalletManager");
+Object.defineProperty(exports, "WalletManager", { enumerable: true, get: function () { return WalletManager_1.WalletManager; } });
+// Export NFT minting
+var NFTMinter_1 = require("./NFTMinter");
+Object.defineProperty(exports, "NFTMinter", { enumerable: true, get: function () { return NFTMinter_1.NFTMinter; } });
+// Export main processor
+var ZipTokenProcessor_1 = require("./ZipTokenProcessor");
+Object.defineProperty(exports, "ZipTokenProcessor", { enumerable: true, get: function () { return ZipTokenProcessor_1.ZipTokenProcessor; } });
+// Export ZIP metadata utilities
+var ZipMetadata_1 = require("./ZipMetadata");
+Object.defineProperty(exports, "ZipMetadata", { enumerable: true, get: function () { return ZipMetadata_1.ZipMetadata; } });
+// Export token verification utilities
+var TokenVerifier_1 = require("./TokenVerifier");
+Object.defineProperty(exports, "checkForTokenization", { enumerable: true, get: function () { return TokenVerifier_1.checkForTokenization; } });
+// Export token querying utilities
+var TokenQuerier_1 = require("./TokenQuerier");
+Object.defineProperty(exports, "queryBlockchainForExistingToken", { enumerable: true, get: function () { return TokenQuerier_1.queryBlockchainForExistingToken; } });
+Object.defineProperty(exports, "queryWalletTokens", { enumerable: true, get: function () { return TokenQuerier_1.queryWalletTokens; } });
+// Export wallet analysis utilities
+var WalletAnalyzer_1 = require("./WalletAnalyzer");
+Object.defineProperty(exports, "WalletAnalyzer", { enumerable: true, get: function () { return WalletAnalyzer_1.WalletAnalyzer; } });
+// Export wallet formatting utilities
+var WalletFormatter_1 = require("./WalletFormatter");
+Object.defineProperty(exports, "WalletFormatter", { enumerable: true, get: function () { return WalletFormatter_1.WalletFormatter; } });

package/dist/server/blockchain/test-certificate.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Test/Demo script for CertificateToken functionality
+ *
+ * This demonstrates how to generate certificates for tokenized ZIP files
+ * independently of the neozipkit integration.
+ */
+export {};

package/dist/server/blockchain/test-certificate.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Test/Demo script for CertificateToken functionality
+ *
+ * This demonstrates how to generate certificates for tokenized ZIP files
+ * independently of the neozipkit integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const CertificateToken_1 = require("./CertificateToken");
+const constants_1 = require("./constants");
+// Example token information
+const sampleTokenInfo = {
+    tokenId: "10",
+    contractAddress: constants_1.CURRENT_DEPLOYMENT.address, // NZIP NFT Contract v2.0
+    network: "Base Sepolia",
+    transactionHash: "0x403331e67051b70c92af413ad9424e70f4e4cacb5512a2f6e6af46a6cb198340",
+    wallet: "0x1234567890123456789012345678901234567890",
+    timestamp: Math.floor(Date.now() / 1000),
+    note: "Test tokenized ZIP file for demonstration"
+};
+// Example blockchain verification results
+const sampleVerification = {
+    merkleRootMatches: true,
+    blockchainMerkleRoot: "abc123def456789012345678901234567890123456789012345678901234567890",
+    calculatedMerkleRoot: "abc123def456789012345678901234567890123456789012345678901234567890",
+    verificationStatus: 'PASSED',
+    verificationTime: Math.floor(Date.now() / 1000),
+    blockNumber: 12345678
+};
+// Example wallet information
+const sampleWalletInfo = {
+    address: "0x1234567890123456789012345678901234567890",
+    network: "Base Sepolia",
+    balance: "1.234 ETH",
+    ensName: "demo.eth"
+};
+// Example file information
+const sampleFiles = [
+    {
+        filename: "README.md",
+        size: 1024,
+        date: "2025-01-10 12:00:00 UTC",
+        hash: "a1b2c3d4e5f6789012345678901234567890123456789012345678901234567890"
+    },
+    {
+        filename: "document.pdf",
+        size: 2048576,
+        date: "2025-01-10 11:30:00 UTC",
+        hash: "b2c3d4e5f6a7890123456789012345678901234567890123456789012345678901"
+    },
+    {
+        filename: "image.jpg",
+        size: 512000,
+        date: "2025-01-10 10:15:00 UTC",
+        hash: "c3d4e5f6a7b8901234567890123456789012345678901234567890123456789012"
+    }
+];
+function testCertificateGeneration() {
+    console.log('🧪 Testing Certificate Generation...');
+    console.log('=====================================');
+    try {
+        // Test with full information
+        console.log('1. Generating certificate with full information...');
+        const fullCertificate = (0, CertificateToken_1.createTokenCertificate)(sampleTokenInfo, 'test-archive.zip', sampleVerification, sampleWalletInfo, sampleFiles);
+        const fullCertPath = (0, CertificateToken_1.saveCertificate)('test-archive.zip', fullCertificate, './certificates');
+        console.log(`✅ Full certificate saved: ${fullCertPath}`);
+        // Test with minimal information
+        console.log('\n2. Generating certificate with minimal information...');
+        const minimalVerification = {
+            merkleRootMatches: false,
+            blockchainMerkleRoot: "different123456789012345678901234567890123456789012345678901234567890",
+            calculatedMerkleRoot: "calculated123456789012345678901234567890123456789012345678901234567890",
+            verificationStatus: 'FAILED'
+        };
+        const minimalCertificate = (0, CertificateToken_1.createTokenCertificate)(sampleTokenInfo, 'minimal-archive.zip', minimalVerification);
+        const minimalCertPath = (0, CertificateToken_1.saveCertificate)('minimal-archive.zip', minimalCertificate, './blockchain/output');
+        console.log(`✅ Minimal certificate saved: ${minimalCertPath}`);
+        // Test with unavailable verification
+        console.log('\n3. Generating certificate with unavailable verification...');
+        const unavailableVerification = {
+            merkleRootMatches: false,
+            blockchainMerkleRoot: "N/A",
+            calculatedMerkleRoot: "calculated123456789012345678901234567890123456789012345678901234567890",
+            verificationStatus: 'UNAVAILABLE'
+        };
+        const unavailableCertificate = (0, CertificateToken_1.createTokenCertificate)(sampleTokenInfo, 'unavailable-archive.zip', unavailableVerification, sampleWalletInfo);
+        const unavailableCertPath = (0, CertificateToken_1.saveCertificate)('unavailable-archive.zip', unavailableCertificate, './blockchain/output');
+        console.log(`✅ Unavailable verification certificate saved: ${unavailableCertPath}`);
+        console.log('\n🎉 All certificate tests completed successfully!');
+        console.log('Check the ./blockchain/output directory for generated certificates.');
+    }
+    catch (error) {
+        console.error('❌ Error during certificate generation:', error);
+    }
+}
+// Run the test
+if (require.main === module) {
+    testCertificateGeneration();
+}

package/dist/server/blockchain/types.d.ts

@@ -0,0 +1,69 @@
+import { ethers } from 'ethers';
+export interface NFTAttribute {
+    trait_type: string;
+    value: string;
+}
+export interface NFTMetadata {
+    name: string;
+    description: string;
+    image: string;
+    attributes: NFTAttribute[];
+}
+export interface WalletInfo {
+    address: string;
+    privateKey: string;
+    mnemonic: string;
+}
+export interface NetworkConfig {
+    name: string;
+    rpcUrl: string;
+    chainId: number;
+    explorerUrl: string;
+}
+export interface WalletSetupResult {
+    wallet: ethers.Wallet | null;
+    provider: ethers.JsonRpcProvider | null;
+    success: boolean;
+    message?: string;
+}
+export interface ContractInfo {
+    address: string;
+    abi: any[];
+    network: string;
+    deployer: string;
+    deploymentTime: string;
+}
+export interface MintingResult {
+    success: boolean;
+    message: string;
+    tokenId?: string;
+    txHash?: string;
+    creationTimestamp?: number;
+}
+export interface ZipTokenData {
+    zipFile: string;
+    merkleRoot: string;
+    fileName: string;
+    timestamp: string;
+}
+export interface MintingOptions {
+    wallet?: string;
+    network: string;
+    mintToken: boolean;
+}
+export interface NZipTokenInfo {
+    version: string;
+    tokenId: string;
+    contractAddress: string;
+    network: string;
+    networkChainId: number;
+    transactionHash: string;
+    merkleRoot: string;
+    fileName: string;
+    mintedAt: string;
+    creationTimestamp?: number;
+    blockNumber?: number;
+    ipfsHash?: string;
+}
+export declare const NETWORKS: Record<string, NetworkConfig>;
+export declare const NFT_METADATA_TEMPLATE: NFTMetadata;

package/dist/server/blockchain/types.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFT_METADATA_TEMPLATE = exports.NETWORKS = void 0;
+// Network configuration
+exports.NETWORKS = {
+    'base': {
+        name: 'Base Mainnet',
+        rpcUrl: 'https://mainnet.base.org',
+        chainId: 8453,
+        explorerUrl: 'https://basescan.org'
+    },
+    'base-sepolia': {
+        name: 'Base Sepolia',
+        rpcUrl: 'https://sepolia.base.org',
+        chainId: 84532,
+        explorerUrl: 'https://sepolia.basescan.org'
+    },
+    'base-goerli': {
+        name: 'Base Goerli',
+        rpcUrl: 'https://goerli.base.org',
+        chainId: 84531,
+        explorerUrl: 'https://goerli.basescan.org'
+    },
+    'localhost': {
+        name: 'Localhost',
+        rpcUrl: 'http://localhost:8545',
+        chainId: 31337,
+        explorerUrl: 'http://localhost:8545'
+    }
+};
+// Token metadata constants - use TOKENIZED_METADATA from constants/Headers
+// NFT Metadata template
+exports.NFT_METADATA_TEMPLATE = {
+    name: "NeoZip Archive Token",
+    description: "This NFT represents ownership of a timestamped and verified ZIP archive on Base",
+    image: "", // Will be set to IPFS hash of thumbnail
+    attributes: [
+        {
+            trait_type: "Archive Hash",
+            value: "" // Will be set to the Merkle root hash of the archive
+        },
+        {
+            trait_type: "Creation Date",
+            value: "" // Will be set to timestamp
+        },
+        {
+            trait_type: "Blockchain",
+            value: "Base" // Specify Base as the blockchain
+        }
+    ]
+};

package/dist/server/platform/server/ZipKitServer.d.ts

@@ -0,0 +1,105 @@
+/**
+ * ZipKitServer
+ * Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+ *
+ * Server-side implementation of ZipKit that passes through all functions
+ * directly to the parent ZipKit class. This class provides a consistent interface
+ * for server environments and ensures all ZipKit functionality is available.
+ */
+import ZipKit, { CompressOptions, ZipEntry } from '../../../shared/ZipKit';
+import { TimestampResult } from '../servercomponents/ZipKitOTS';
+import * as Headers from '../../../shared/constants/Headers';
+export * from '../../../shared/ZipKit';
+export { Headers };
+/**
+ * This implementation is optimized for server environments and handles all
+ * ZIP operations including compression, extraction, encryption, and file management.
+ */
+export default class ZipKitServer extends ZipKit {
+    /**
+     * Creates a new ZipKitServer instance
+     *
+     * Initializes the parent ZipKit class and logs environment support information
+     * for diagnostic purposes.
+     */
+    constructor();
+    /**
+     * Loads a ZIP file from the filesystem for updating/creating operations
+     *
+     * Attempts to read an existing ZIP file, but creates a new empty archive if
+     * the file doesn't exist. This method is used when adding or updating entries
+     * in an archive, handling both new and existing ZIP files gracefully.
+     *
+     * @param zipFile - Path to the ZIP file to load or create
+     */
+    loadZipFile(zipFile: string): void;
+    /**
+     * Loads a ZIP file from the filesystem for extraction and listing operations
+     *
+     * Reads an existing ZIP file and throws an error if the file doesn't exist.
+     * Use this method when working with existing archives that need to be extracted.
+     *
+     * @param zipFile - Path to the ZIP file to load
+     * @throws Error if the file doesn't exist or can't be read
+     */
+    loadUnzipFile(zipFile: string): void;
+    /**
+     * Adds a single file to the ZIP archive
+     * @param filename - Path to the file to be added
+     * @param comment - Optional comment for the file entry
+     *
+     * Handles:
+     * - Creating/updating ZipEntry objects
+     * - Setting file attributes and timestamps
+     * - Respecting freshen (-f) and update (-u) flags
+     * - Setting compression method
+     */
+    addFile(filename: string, freshen?: boolean, update?: boolean): void;
+    /**
+     * Processes files to be added to the ZIP archive
+     * Creates ZipEntry objects for each file and initiates the compression process
+     */
+    addFiles(files: string[], freshen?: boolean, update?: boolean): number;
+    /**
+     * Creates a ZIP file with optional OpenTimestamps (OTS) metadata
+     *
+     * This method creates a ZIP file with optional OpenTimestamps (OTS) metadata,
+     * which includes a timestamp of the ZIP file's contents on the Bitcoin blockchain.
+     *
+     * @param zipFile - The path to the ZIP file to create
+     * @param compressOptions - The compression options for the ZIP file
+     * @returns void - The method triggers a download of the ZIP file
+     */
+    createZip(zipFile: string, compressOptions: CompressOptions): Promise<void>;
+    /**
+     * Creates a ZIP file with OpenTimestamps (OTS) metadata
+     *
+     * This method creates a ZIP file with OpenTimestamps (OTS) metadata, which
+     * includes a timestamp of the ZIP file's contents on the Bitcoin blockchain.
+     *
+     * @param zipFile - The path to the ZIP file to create
+     * @param compressOptions - The compression options for the ZIP file
+     * @returns void - The method triggers a download of the ZIP file
+     */
+    createZipOTS(zipFile: string, compressOptions: CompressOptions): Promise<void>;
+    /**
+     * Removes specified files from the ZIP archive
+     * Deletes matching ZipEntry objects and rebuilds the archive if any files were removed
+     */
+    deleteFiles(delFiles: string[]): number;
+    /**
+     * Upgrades a timestamp in an existing ZIP file
+     *
+     * This method takes an existing ZIP file and upgrades its timestamp by:
+     * 1. Loading the original ZIP file
+     * 2. Removing any existing timestamp metadata entries
+     * 3. Adding a new timestamp metadata entry with the upgraded OTS proof
+     * 4. Creating a new ZIP file with the updated timestamp
+     *
+     * @param zipFile - The original ZIP file to upgrade
+     * @param upgradedOts - The upgraded OpenTimestamps proof as an ArrayBuffer
+     * @returns void - The method triggers a download of the upgraded ZIP file
+     */
+    upgradeOTS(fileName: string, upgradedOts: Buffer): Promise<void>;
+    createCertificateOTS(fileName: string, zipEntries: ZipEntry[], timestampResult: TimestampResult): Promise<string>;
+}