@ckbfs/api 1.2.3 → 1.2.5

package/dist/utils/file.js

@@ -1,8 +1,42 @@
 "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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierType = void 0;
 exports.readFile = readFile;
 exports.readFileAsText = readFileAsText;
 exports.readFileAsUint8Array = readFileAsUint8Array;
@@ -12,6 +46,18 @@ exports.splitFileIntoChunks = splitFileIntoChunks;
 exports.combineChunksToFile = combineChunksToFile;
 exports.getFileContentFromChain = getFileContentFromChain;
 exports.saveFileFromChain = saveFileFromChain;
+exports.decodeWitnessContent = decodeWitnessContent;
+exports.decodeMultipleWitnessContents = decodeMultipleWitnessContents;
+exports.extractFileFromWitnesses = extractFileFromWitnesses;
+exports.decodeFileFromWitnessData = decodeFileFromWitnessData;
+exports.saveFileFromWitnessData = saveFileFromWitnessData;
+exports.parseIdentifier = parseIdentifier;
+exports.getFileContentFromChainByIdentifier = getFileContentFromChainByIdentifier;
+exports.getFileContentFromChainByTypeId = getFileContentFromChainByTypeId;
+exports.saveFileFromChainByIdentifier = saveFileFromChainByIdentifier;
+exports.saveFileFromChainByTypeId = saveFileFromChainByTypeId;
+exports.decodeFileFromChainByIdentifier = decodeFileFromChainByIdentifier;
+exports.decodeFileFromChainByTypeId = decodeFileFromChainByTypeId;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 /**
@@ -31,7 +77,7 @@ function readFile(filePath) {
  * @returns String containing the file contents
  */
 function readFileAsText(filePath) {
-    return fs_1.default.readFileSync(filePath, 'utf-8');
+    return fs_1.default.readFileSync(filePath, "utf-8");
 }
 /**
  * Reads a file as Uint8Array from the file system
@@ -63,27 +109,27 @@ function writeFile(filePath, data) {
 function getContentType(filePath) {
     const extension = path_1.default.extname(filePath).toLowerCase();
     const mimeTypes = {
-        '.txt': 'text/plain',
-        '.html': 'text/html',
-        '.htm': 'text/html',
-        '.css': 'text/css',
-        '.js': 'application/javascript',
-        '.json': 'application/json',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.png': 'image/png',
-        '.gif': 'image/gif',
-        '.svg': 'image/svg+xml',
-        '.pdf': 'application/pdf',
-        '.mp3': 'audio/mpeg',
-        '.mp4': 'video/mp4',
-        '.wav': 'audio/wav',
-        '.xml': 'application/xml',
-        '.zip': 'application/zip',
-        '.md': 'text/markdown',
-        '.markdown': 'text/markdown',
+        ".txt": "text/plain",
+        ".html": "text/html",
+        ".htm": "text/html",
+        ".css": "text/css",
+        ".js": "application/javascript",
+        ".json": "application/json",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".svg": "image/svg+xml",
+        ".pdf": "application/pdf",
+        ".mp3": "audio/mpeg",
+        ".mp4": "video/mp4",
+        ".wav": "audio/wav",
+        ".xml": "application/xml",
+        ".zip": "application/zip",
+        ".md": "text/markdown",
+        ".markdown": "text/markdown",
     };
-    return mimeTypes[extension] || 'application/octet-stream';
+    return mimeTypes[extension] || "application/octet-stream";
 }
 /**
  * Splits a file into chunks of a specific size
@@ -105,7 +151,7 @@ function splitFileIntoChunks(filePath, chunkSize) {
  * @param outputPath The path to write the combined file to
  */
 function combineChunksToFile(chunks, outputPath) {
-    const combinedBuffer = Buffer.concat(chunks.map(chunk => Buffer.from(chunk)));
+    const combinedBuffer = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
     writeFile(outputPath, combinedBuffer);
 }
 /**
@@ -115,12 +161,12 @@ function combineChunksToFile(chunks, outputPath) {
  */
 function safelyDecode(buffer) {
     if (!buffer)
-        return '[Unknown]';
+        return "[Unknown]";
     try {
         if (buffer instanceof Uint8Array) {
             return new TextDecoder().decode(buffer);
         }
-        else if (typeof buffer === 'string') {
+        else if (typeof buffer === "string") {
             return buffer;
         }
         else {
@@ -128,7 +174,7 @@ function safelyDecode(buffer) {
         }
     }
     catch (e) {
-        return '[Decode Error]';
+        return "[Decode Error]";
     }
 }
 /**
@@ -151,7 +197,8 @@ async function getFileContentFromChain(client, outPoint, ckbfsData) {
         throw new Error(`Transaction ${currentOutPoint.txHash} not found`);
     }
     // Get content from witnesses
-    const indexes = currentData.indexes || (currentData.index !== undefined ? [currentData.index] : []);
+    const indexes = currentData.indexes ||
+        (currentData.index !== undefined ? [currentData.index] : []);
     if (indexes.length > 0) {
         // Get content from each witness index
         for (const idx of indexes) {
@@ -160,9 +207,9 @@ async function getFileContentFromChain(client, outPoint, ckbfsData) {
                 continue;
             }
             const witnessHex = tx.transaction.witnesses[idx];
-            const witness = Buffer.from(witnessHex.slice(2), 'hex'); // Remove 0x prefix
+            const witness = Buffer.from(witnessHex.slice(2), "hex"); // Remove 0x prefix
             // Extract content (skip CKBFS header + version byte)
-            if (witness.length >= 6 && witness.slice(0, 5).toString() === 'CKBFS') {
+            if (witness.length >= 6 && witness.slice(0, 5).toString() === "CKBFS") {
                 const content = witness.slice(6);
                 contentPieces.unshift(content); // Add to beginning of array (we're going backwards)
             }
@@ -183,7 +230,8 @@ async function getFileContentFromChain(client, outPoint, ckbfsData) {
                 continue;
             }
             // Get content from backlink witnesses
-            const backIndexes = backlink.indexes || (backlink.index !== undefined ? [backlink.index] : []);
+            const backIndexes = backlink.indexes ||
+                (backlink.index !== undefined ? [backlink.index] : []);
             if (backIndexes.length > 0) {
                 // Get content from each witness index
                 for (const idx of backIndexes) {
@@ -192,9 +240,10 @@ async function getFileContentFromChain(client, outPoint, ckbfsData) {
                         continue;
                     }
                     const witnessHex = backTx.transaction.witnesses[idx];
-                    const witness = Buffer.from(witnessHex.slice(2), 'hex'); // Remove 0x prefix
+                    const witness = Buffer.from(witnessHex.slice(2), "hex"); // Remove 0x prefix
                     // Extract content (skip CKBFS header + version byte)
-                    if (witness.length >= 6 && witness.slice(0, 5).toString() === 'CKBFS') {
+                    if (witness.length >= 6 &&
+                        witness.slice(0, 5).toString() === "CKBFS") {
                         const content = witness.slice(6);
                         contentPieces.unshift(content); // Add to beginning of array (we're going backwards)
                     }
@@ -231,3 +280,522 @@ function saveFileFromChain(content, ckbfsData, outputPath) {
     console.log(`Size: ${content.length} bytes`);
     return filePath;
 }
+/**
+ * Decodes content from a single CKBFS witness
+ * @param witnessHex The witness data in hex format (with or without 0x prefix)
+ * @returns Object containing the decoded content and metadata, or null if not a valid CKBFS witness
+ */
+function decodeWitnessContent(witnessHex) {
+    try {
+        // Remove 0x prefix if present
+        const hexData = witnessHex.startsWith("0x")
+            ? witnessHex.slice(2)
+            : witnessHex;
+        const witness = Buffer.from(hexData, "hex");
+        // Check if it's a valid CKBFS witness
+        if (witness.length < 6) {
+            return null;
+        }
+        // Check CKBFS header
+        const header = witness.slice(0, 5).toString();
+        if (header !== "CKBFS") {
+            return null;
+        }
+        // Extract content (skip CKBFS header + version byte)
+        const content = witness.slice(6);
+        return {
+            content,
+            isValid: true,
+        };
+    }
+    catch (error) {
+        console.warn("Error decoding witness content:", error);
+        return null;
+    }
+}
+/**
+ * Decodes and combines content from multiple CKBFS witnesses
+ * @param witnessHexArray Array of witness data in hex format
+ * @param preserveOrder Whether to preserve the order of witnesses (default: true)
+ * @returns Combined content from all valid CKBFS witnesses
+ */
+function decodeMultipleWitnessContents(witnessHexArray, preserveOrder = true) {
+    const contentPieces = [];
+    for (let i = 0; i < witnessHexArray.length; i++) {
+        const witnessHex = witnessHexArray[i];
+        const decoded = decodeWitnessContent(witnessHex);
+        if (decoded && decoded.isValid) {
+            if (preserveOrder) {
+                contentPieces.push(decoded.content);
+            }
+            else {
+                contentPieces.unshift(decoded.content);
+            }
+        }
+        else {
+            console.warn(`Witness at index ${i} is not a valid CKBFS witness`);
+        }
+    }
+    return Buffer.concat(contentPieces);
+}
+/**
+ * Extracts complete file content from witnesses using specified indexes
+ * @param witnesses Array of all witnesses from a transaction
+ * @param indexes Array of witness indexes that contain CKBFS content
+ * @returns Combined content from the specified witness indexes
+ */
+function extractFileFromWitnesses(witnesses, indexes) {
+    const relevantWitnesses = [];
+    for (const idx of indexes) {
+        if (idx >= witnesses.length) {
+            console.warn(`Witness index ${idx} out of range (total witnesses: ${witnesses.length})`);
+            continue;
+        }
+        relevantWitnesses.push(witnesses[idx]);
+    }
+    return decodeMultipleWitnessContents(relevantWitnesses, true);
+}
+/**
+ * Decodes file content directly from witness data without blockchain queries
+ * @param witnessData Object containing witness information
+ * @returns Object containing the decoded file content and metadata
+ */
+function decodeFileFromWitnessData(witnessData) {
+    const { witnesses, indexes, filename, contentType } = witnessData;
+    // Normalize indexes to array
+    const indexArray = Array.isArray(indexes) ? indexes : [indexes];
+    // Extract content from witnesses
+    const content = extractFileFromWitnesses(witnesses, indexArray);
+    return {
+        content,
+        filename,
+        contentType,
+        size: content.length,
+    };
+}
+/**
+ * Saves decoded file content directly from witness data
+ * @param witnessData Object containing witness information
+ * @param outputPath Optional path to save the file
+ * @returns The path where the file was saved
+ */
+function saveFileFromWitnessData(witnessData, outputPath) {
+    const decoded = decodeFileFromWitnessData(witnessData);
+    // Determine output path
+    const filename = decoded.filename || "decoded_file";
+    const filePath = outputPath || filename;
+    // Ensure directory exists
+    const directory = path_1.default.dirname(filePath);
+    if (!fs_1.default.existsSync(directory)) {
+        fs_1.default.mkdirSync(directory, { recursive: true });
+    }
+    // Write file
+    fs_1.default.writeFileSync(filePath, decoded.content);
+    console.log(`File saved to: ${filePath}`);
+    console.log(`Size: ${decoded.size} bytes`);
+    console.log(`Content type: ${decoded.contentType || "unknown"}`);
+    return filePath;
+}
+/**
+ * Identifier types for CKBFS cells
+ */
+var IdentifierType;
+(function (IdentifierType) {
+    IdentifierType["TypeID"] = "typeId";
+    IdentifierType["OutPoint"] = "outPoint";
+    IdentifierType["Unknown"] = "unknown";
+})(IdentifierType || (exports.IdentifierType = IdentifierType = {}));
+/**
+ * Detects and parses different CKBFS identifier formats
+ * @param identifier The identifier string to parse
+ * @returns Parsed identifier information
+ */
+function parseIdentifier(identifier) {
+    const trimmed = identifier.trim();
+    // Type 1: Pure TypeID hex string (with or without 0x prefix)
+    if (trimmed.match(/^(0x)?[a-fA-F0-9]{64}$/)) {
+        const typeId = trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+        return {
+            type: IdentifierType.TypeID,
+            typeId,
+            original: identifier,
+        };
+    }
+    // Type 2: CKBFS URI with TypeID
+    if (trimmed.startsWith("ckbfs://")) {
+        const content = trimmed.slice(8); // Remove "ckbfs://"
+        // Check if it's TypeID format (64 hex characters)
+        if (content.match(/^[a-fA-F0-9]{64}$/)) {
+            return {
+                type: IdentifierType.TypeID,
+                typeId: `0x${content}`,
+                original: identifier,
+            };
+        }
+        // Type 3: CKBFS URI with transaction hash and index (txhash + 'i' + index)
+        const outPointMatch = content.match(/^([a-fA-F0-9]{64})i(\d+)$/);
+        if (outPointMatch) {
+            const [, txHash, indexStr] = outPointMatch;
+            return {
+                type: IdentifierType.OutPoint,
+                txHash: `0x${txHash}`,
+                index: parseInt(indexStr, 10),
+                original: identifier,
+            };
+        }
+    }
+    // Unknown format
+    return {
+        type: IdentifierType.Unknown,
+        original: identifier,
+    };
+}
+/**
+ * Resolves a CKBFS cell using any supported identifier format
+ * @param client The CKB client to use for blockchain queries
+ * @param identifier The identifier (TypeID, CKBFS URI, or outPoint URI)
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the found cell and transaction info, or null if not found
+ */
+async function resolveCKBFSCell(client, identifier, options = {}) {
+    const { network = "testnet", version = "20241025.db973a8e8032", useTypeID = false, } = options;
+    const parsedId = parseIdentifier(identifier);
+    try {
+        if (parsedId.type === IdentifierType.TypeID && parsedId.typeId) {
+            // Use existing TypeID resolution logic
+            const cellInfo = await findCKBFSCellByTypeId(client, parsedId.typeId, network, version, useTypeID);
+            if (cellInfo) {
+                return {
+                    ...cellInfo,
+                    parsedId,
+                };
+            }
+        }
+        else if (parsedId.type === IdentifierType.OutPoint &&
+            parsedId.txHash &&
+            parsedId.index !== undefined) {
+            // Resolve using transaction hash and index
+            const txWithStatus = await client.getTransaction(parsedId.txHash);
+            if (!txWithStatus || !txWithStatus.transaction) {
+                console.warn(`Transaction ${parsedId.txHash} not found`);
+                return null;
+            }
+            // Import Transaction class dynamically
+            const { Transaction } = await Promise.resolve().then(() => __importStar(require("@ckb-ccc/core")));
+            const tx = Transaction.from(txWithStatus.transaction);
+            // Check if the index is valid
+            if (parsedId.index >= tx.outputs.length) {
+                console.warn(`Output index ${parsedId.index} out of range for transaction ${parsedId.txHash}`);
+                return null;
+            }
+            const output = tx.outputs[parsedId.index];
+            // Verify it's a CKBFS cell by checking if it has a type script
+            if (!output.type) {
+                console.warn(`Output at index ${parsedId.index} is not a CKBFS cell (no type script)`);
+                return null;
+            }
+            // Create a mock cell object similar to what findSingletonCellByType returns
+            const cell = {
+                outPoint: {
+                    txHash: parsedId.txHash,
+                    index: parsedId.index,
+                },
+                output,
+            };
+            return {
+                cell,
+                transaction: txWithStatus.transaction,
+                outPoint: {
+                    txHash: parsedId.txHash,
+                    index: parsedId.index,
+                },
+                parsedId,
+            };
+        }
+        console.warn(`Unable to resolve identifier: ${identifier} (type: ${parsedId.type})`);
+        return null;
+    }
+    catch (error) {
+        console.error(`Error resolving CKBFS cell for identifier ${identifier}:`, error);
+        return null;
+    }
+}
+/**
+ * Finds a CKBFS cell by TypeID
+ * @param client The CKB client to use for blockchain queries
+ * @param typeId The TypeID (args) of the CKBFS cell to find
+ * @param network The network type (mainnet or testnet)
+ * @param version The protocol version to use
+ * @param useTypeID Whether to use type ID instead of code hash for script matching
+ * @returns Promise resolving to the found cell and transaction info, or null if not found
+ */
+async function findCKBFSCellByTypeId(client, typeId, network = "testnet", version = "20241025.db973a8e8032", useTypeID = false) {
+    try {
+        // Import constants dynamically to avoid circular dependencies
+        const { getCKBFSScriptConfig, NetworkType, ProtocolVersion } = await Promise.resolve().then(() => __importStar(require("./constants")));
+        // Get CKBFS script config
+        const networkType = network === "mainnet" ? NetworkType.Mainnet : NetworkType.Testnet;
+        const protocolVersion = version === "20240906.ce6724722cf6"
+            ? ProtocolVersion.V1
+            : ProtocolVersion.V2;
+        const config = getCKBFSScriptConfig(networkType, protocolVersion, useTypeID);
+        // Create the script to search for
+        const script = {
+            codeHash: config.codeHash,
+            hashType: config.hashType,
+            args: typeId.startsWith("0x") ? typeId : `0x${typeId}`,
+        };
+        // Find the cell by type script
+        const cell = await client.findSingletonCellByType(script, true);
+        if (!cell) {
+            return null;
+        }
+        // Get the transaction that contains this cell
+        const txHash = cell.outPoint.txHash;
+        const txWithStatus = await client.getTransaction(txHash);
+        if (!txWithStatus || !txWithStatus.transaction) {
+            throw new Error(`Transaction ${txHash} not found`);
+        }
+        return {
+            cell,
+            transaction: txWithStatus.transaction,
+            outPoint: {
+                txHash: cell.outPoint.txHash,
+                index: cell.outPoint.index,
+            },
+        };
+    }
+    catch (error) {
+        console.warn(`Error finding CKBFS cell by TypeID ${typeId}:`, error);
+        return null;
+    }
+}
+/**
+ * Retrieves complete file content from the blockchain using any supported identifier
+ * @param client The CKB client to use for blockchain queries
+ * @param identifier The identifier (TypeID hex, CKBFS TypeID URI, or CKBFS outPoint URI)
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the complete file content and metadata
+ */
+async function getFileContentFromChainByIdentifier(client, identifier, options = {}) {
+    const { network = "testnet", version = "20241025.db973a8e8032", useTypeID = false, } = options;
+    try {
+        // Resolve the CKBFS cell using any supported identifier format
+        const cellInfo = await resolveCKBFSCell(client, identifier, {
+            network,
+            version,
+            useTypeID,
+        });
+        if (!cellInfo) {
+            console.warn(`CKBFS cell with identifier ${identifier} not found`);
+            return null;
+        }
+        const { cell, transaction, outPoint, parsedId } = cellInfo;
+        // Import Transaction class dynamically
+        const { Transaction } = await Promise.resolve().then(() => __importStar(require("@ckb-ccc/core")));
+        const tx = Transaction.from(transaction);
+        // Get output data from the cell
+        const outputIndex = outPoint.index;
+        const outputData = tx.outputsData[outputIndex];
+        if (!outputData) {
+            throw new Error(`Output data not found for cell at index ${outputIndex}`);
+        }
+        // Import required modules dynamically
+        const { ccc } = await Promise.resolve().then(() => __importStar(require("@ckb-ccc/core")));
+        const { CKBFSData } = await Promise.resolve().then(() => __importStar(require("./molecule")));
+        const { ProtocolVersion } = await Promise.resolve().then(() => __importStar(require("./constants")));
+        // Parse the output data
+        const rawData = outputData.startsWith("0x")
+            ? ccc.bytesFrom(outputData.slice(2), "hex")
+            : Buffer.from(outputData, "hex");
+        // Try to unpack CKBFS data with both protocol versions
+        let ckbfsData;
+        let protocolVersion = version;
+        try {
+            ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V2);
+        }
+        catch (error) {
+            try {
+                ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V1);
+                protocolVersion = "20240906.ce6724722cf6";
+            }
+            catch (v1Error) {
+                throw new Error(`Failed to unpack CKBFS data with both versions: V2(${error}), V1(${v1Error})`);
+            }
+        }
+        console.log(`Found CKBFS file: ${ckbfsData.filename}`);
+        console.log(`Content type: ${ckbfsData.contentType}`);
+        console.log(`Protocol version: ${protocolVersion}`);
+        // Use existing function to get complete file content
+        const content = await getFileContentFromChain(client, outPoint, ckbfsData);
+        return {
+            content,
+            filename: ckbfsData.filename,
+            contentType: ckbfsData.contentType,
+            checksum: ckbfsData.checksum,
+            size: content.length,
+            backLinks: ckbfsData.backLinks || [],
+            parsedId,
+        };
+    }
+    catch (error) {
+        console.error(`Error retrieving file by identifier ${identifier}:`, error);
+        throw error;
+    }
+}
+/**
+ * Retrieves complete file content from the blockchain using TypeID (legacy function)
+ * @param client The CKB client to use for blockchain queries
+ * @param typeId The TypeID (args) of the CKBFS cell
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the complete file content and metadata
+ */
+async function getFileContentFromChainByTypeId(client, typeId, options = {}) {
+    const result = await getFileContentFromChainByIdentifier(client, typeId, options);
+    if (result) {
+        const { parsedId, ...fileData } = result;
+        return fileData;
+    }
+    return null;
+}
+/**
+ * Saves file content retrieved from blockchain by identifier to disk
+ * @param client The CKB client to use for blockchain queries
+ * @param identifier The identifier (TypeID hex, CKBFS TypeID URI, or CKBFS outPoint URI)
+ * @param outputPath Optional path to save the file (defaults to filename from CKBFS data)
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the path where the file was saved, or null if file not found
+ */
+async function saveFileFromChainByIdentifier(client, identifier, outputPath, options = {}) {
+    try {
+        // Get file content by identifier
+        const fileData = await getFileContentFromChainByIdentifier(client, identifier, options);
+        if (!fileData) {
+            console.warn(`File with identifier ${identifier} not found`);
+            return null;
+        }
+        // Determine output path
+        const filePath = outputPath || fileData.filename;
+        // Ensure directory exists
+        const directory = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(directory)) {
+            fs_1.default.mkdirSync(directory, { recursive: true });
+        }
+        // Write file
+        fs_1.default.writeFileSync(filePath, fileData.content);
+        console.log(`File saved to: ${filePath}`);
+        console.log(`Size: ${fileData.size} bytes`);
+        console.log(`Content type: ${fileData.contentType}`);
+        console.log(`Checksum: ${fileData.checksum}`);
+        return filePath;
+    }
+    catch (error) {
+        console.error(`Error saving file by identifier ${identifier}:`, error);
+        throw error;
+    }
+}
+/**
+ * Saves file content retrieved from blockchain by TypeID to disk (legacy function)
+ * @param client The CKB client to use for blockchain queries
+ * @param typeId The TypeID (args) of the CKBFS cell
+ * @param outputPath Optional path to save the file (defaults to filename from CKBFS data)
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the path where the file was saved, or null if file not found
+ */
+async function saveFileFromChainByTypeId(client, typeId, outputPath, options = {}) {
+    return await saveFileFromChainByIdentifier(client, typeId, outputPath, options);
+}
+/**
+ * Decodes file content directly from identifier using witness decoding (new method)
+ * @param client The CKB client to use for blockchain queries
+ * @param identifier The identifier (TypeID hex, CKBFS TypeID URI, or CKBFS outPoint URI)
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the decoded file content and metadata, or null if not found
+ */
+async function decodeFileFromChainByIdentifier(client, identifier, options = {}) {
+    const { network = "testnet", version = "20241025.db973a8e8032", useTypeID = false, } = options;
+    try {
+        // Resolve the CKBFS cell using any supported identifier format
+        const cellInfo = await resolveCKBFSCell(client, identifier, {
+            network,
+            version,
+            useTypeID,
+        });
+        if (!cellInfo) {
+            console.warn(`CKBFS cell with identifier ${identifier} not found`);
+            return null;
+        }
+        const { cell, transaction, outPoint, parsedId } = cellInfo;
+        // Import required modules dynamically
+        const { Transaction, ccc } = await Promise.resolve().then(() => __importStar(require("@ckb-ccc/core")));
+        const { CKBFSData } = await Promise.resolve().then(() => __importStar(require("./molecule")));
+        const { ProtocolVersion } = await Promise.resolve().then(() => __importStar(require("./constants")));
+        const tx = Transaction.from(transaction);
+        // Get output data from the cell
+        const outputIndex = outPoint.index;
+        const outputData = tx.outputsData[outputIndex];
+        if (!outputData) {
+            throw new Error(`Output data not found for cell at index ${outputIndex}`);
+        }
+        // Parse the output data
+        const rawData = outputData.startsWith("0x")
+            ? ccc.bytesFrom(outputData.slice(2), "hex")
+            : Buffer.from(outputData, "hex");
+        // Try to unpack CKBFS data with both protocol versions
+        let ckbfsData;
+        let protocolVersion = version;
+        try {
+            ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V2);
+        }
+        catch (error) {
+            try {
+                ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V1);
+                protocolVersion = "20240906.ce6724722cf6";
+            }
+            catch (v1Error) {
+                throw new Error(`Failed to unpack CKBFS data with both versions: V2(${error}), V1(${v1Error})`);
+            }
+        }
+        console.log(`Found CKBFS file: ${ckbfsData.filename}`);
+        console.log(`Content type: ${ckbfsData.contentType}`);
+        console.log(`Using direct witness decoding method`);
+        // Get witness indexes from CKBFS data
+        const indexes = ckbfsData.indexes ||
+            (ckbfsData.index !== undefined ? [ckbfsData.index] : []);
+        // Use direct witness decoding method
+        const content = decodeFileFromWitnessData({
+            witnesses: tx.witnesses,
+            indexes: indexes,
+            filename: ckbfsData.filename,
+            contentType: ckbfsData.contentType,
+        });
+        return {
+            content: content.content,
+            filename: ckbfsData.filename,
+            contentType: ckbfsData.contentType,
+            checksum: ckbfsData.checksum,
+            size: content.size,
+            backLinks: ckbfsData.backLinks || [],
+            parsedId,
+        };
+    }
+    catch (error) {
+        console.error(`Error decoding file by identifier ${identifier}:`, error);
+        throw error;
+    }
+}
+/**
+ * Decodes file content directly from TypeID using witness decoding (legacy function)
+ * @param client The CKB client to use for blockchain queries
+ * @param typeId The TypeID (args) of the CKBFS cell
+ * @param options Optional configuration for network, version, and useTypeID
+ * @returns Promise resolving to the decoded file content and metadata, or null if not found
+ */
+async function decodeFileFromChainByTypeId(client, typeId, options = {}) {
+    const result = await decodeFileFromChainByIdentifier(client, typeId, options);
+    if (result) {
+        const { parsedId, ...fileData } = result;
+        return fileData;
+    }
+    return null;
+}