neozipkit 0.1.1

package/dist/server/blockchain/ZipTokenProcessor.js

@@ -0,0 +1,204 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipTokenProcessor = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const WalletManager_1 = require("./WalletManager");
+const NFTMinter_1 = require("./NFTMinter");
+const ZipMetadata_1 = require("./ZipMetadata");
+class ZipTokenProcessor {
+    constructor(zipFile, merkleRoot, options) {
+        this.nftMinter = null;
+        this.walletManager = new WalletManager_1.WalletManager();
+        this.zipTokenData = {
+            zipFile,
+            merkleRoot,
+            fileName: path.basename(zipFile),
+            timestamp: new Date().toISOString()
+        };
+    }
+    /**
+     * Processes the complete ZIP token workflow
+     */
+    async processZipToken(options) {
+        const state = {};
+        try {
+            // Setup wallet if needed
+            if (options.wallet || options.mintToken) {
+                console.log('Setting up wallet...');
+                const walletResult = await this.walletManager.setupWallet(options);
+                state.walletSetup = walletResult;
+                if (!walletResult.success) {
+                    state.error = `Wallet setup failed: ${walletResult.message}`;
+                    return state;
+                }
+                // Initialize NFT minter with wallet and provider
+                this.nftMinter = new NFTMinter_1.NFTMinter(walletResult.wallet, walletResult.provider);
+            }
+            // Mint token if requested
+            if (options.mintToken && this.nftMinter) {
+                console.log('Minting NFT token...');
+                const mintingResult = await this.nftMinter.mintZipFileNFT(this.zipTokenData);
+                state.mintingResult = mintingResult;
+                if (!mintingResult.success) {
+                    state.error = `Minting failed: ${mintingResult.message}`;
+                    return state;
+                }
+                // Validate that we have complete token data for successful minting
+                if (!mintingResult.tokenId || !mintingResult.txHash) {
+                    state.error = `Minting incomplete: Missing token ID or transaction hash`;
+                    return state;
+                }
+                console.log('Preparing token metadata...');
+                // Check if this was an existing token (message contains "existing token")
+                if (mintingResult.message.includes('existing token')) {
+                    console.log('Using existing token from your wallet...');
+                    // Create token info from existing token data
+                    const tokenInfo = await this.createTokenInfoFromExisting(mintingResult, options);
+                    if (!tokenInfo) {
+                        state.error = `Failed to create token metadata from existing token`;
+                        return state;
+                    }
+                    state.tokenInfo = tokenInfo;
+                }
+                else {
+                    // Create token info from new minting
+                    const tokenInfo = this.createTokenInfo(mintingResult, options);
+                    if (!tokenInfo) {
+                        state.error = `Failed to create token metadata`;
+                        return state;
+                    }
+                    state.tokenInfo = tokenInfo;
+                }
+                console.log('\n' + ZipMetadata_1.ZipMetadata.createTokenSummary(state.tokenInfo));
+            }
+            return state;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('Error in ZIP token processing:', error);
+            state.error = `Processing error: ${errorMessage}`;
+            return state;
+        }
+    }
+    /**
+     * Gets the ZIP token data
+     */
+    getZipTokenData() {
+        return this.zipTokenData;
+    }
+    /**
+     * Gets the wallet manager instance
+     */
+    getWalletManager() {
+        return this.walletManager;
+    }
+    /**
+     * Gets the NFT minter instance
+     */
+    getNFTMinter() {
+        return this.nftMinter;
+    }
+    /**
+     * Loads contract deployment information
+     */
+    loadContractInfo() {
+        try {
+            const contractInfoPath = path.join(process.cwd(), 'zipfile-nft-deployment.json');
+            if (!fs.existsSync(contractInfoPath)) {
+                return null;
+            }
+            const contractInfo = JSON.parse(fs.readFileSync(contractInfoPath, 'utf8'));
+            return contractInfo;
+        }
+        catch (error) {
+            console.error('Error loading contract info:', error);
+            return null;
+        }
+    }
+    /**
+     * Creates token information object
+     */
+    createTokenInfo(mintingResult, options) {
+        if (!mintingResult.success || !mintingResult.tokenId || !mintingResult.txHash) {
+            console.error('Cannot create token metadata: minting was not successful or missing token data');
+            return null;
+        }
+        try {
+            // Load contract information
+            const contractInfo = this.loadContractInfo();
+            if (!contractInfo) {
+                console.error('Cannot load contract information for token metadata');
+                return null;
+            }
+            // Create token information with REAL data only
+            const tokenInfo = ZipMetadata_1.ZipMetadata.createTokenInfo(mintingResult.tokenId, mintingResult.txHash, contractInfo, this.zipTokenData.merkleRoot, this.zipTokenData.fileName, options.network, undefined, // blockNumber - will be filled later if needed
+            undefined, // ipfsHash - not implemented yet
+            Math.floor(Date.now() / 1000) // creationTimestamp
+            );
+            return tokenInfo;
+        }
+        catch (error) {
+            console.error('Error creating token metadata:', error);
+            return null;
+        }
+    }
+    /**
+     * Creates token information object from existing token
+     */
+    async createTokenInfoFromExisting(mintingResult, options) {
+        if (!mintingResult.success || !mintingResult.tokenId || !mintingResult.txHash) {
+            console.error('Cannot create token metadata: minting was not successful or missing token data');
+            return null;
+        }
+        try {
+            // Load contract information
+            const contractInfo = this.loadContractInfo();
+            if (!contractInfo) {
+                console.error('Cannot load contract information for token metadata');
+                return null;
+            }
+            // Create token information with REAL data only
+            const tokenInfo = ZipMetadata_1.ZipMetadata.createTokenInfo(mintingResult.tokenId, mintingResult.txHash, contractInfo, this.zipTokenData.merkleRoot, this.zipTokenData.fileName, options.network);
+            return tokenInfo;
+        }
+        catch (error) {
+            console.error('Error creating token metadata:', error);
+            return null;
+        }
+    }
+}
+exports.ZipTokenProcessor = ZipTokenProcessor;

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

@@ -0,0 +1,102 @@
+/**
+ * Contract addresses for different networks
+ */
+export declare const CONTRACT_ADDRESSES: {
+    NZIP_NFT: Record<number, string>;
+};
+/**
+ * Deprecated contract addresses (no longer in use)
+ */
+export declare const DEPRECATED_CONTRACTS: {
+    NZIP_NFT_V1: Record<number, string>;
+};
+/**
+ * Complete NZIP NFT Contract v2.0 ABI
+ * This is the full ABI from Remix compilation used by the current deployment
+ */
+export declare const NZIP_CONTRACT_ABI: ({
+    inputs: never[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+/**
+ * Helper function to get contract address for a chain
+ */
+export declare function getNZipContractAddress(chainId: number): string;
+/**
+ * Network configurations
+ */
+export declare const NETWORK_CONFIG: Record<number, string>;
+/**
+ * Current deployment information
+ */
+export declare const CURRENT_DEPLOYMENT: {
+    version: string;
+    network: string;
+    chainId: number;
+    address: string;
+    deployedAt: string;
+    txHash: string;
+    explorer: string;
+};