@ckbfs/api 1.0.2 → 1.2.0

package/.cursor/rules/typescript.mdc

@@ -0,0 +1,49 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+
+  You are an expert in TypeScript, Node.js, Next.js App Router, React, Shadcn UI, Radix UI and Tailwind.
+  
+  Code Style and Structure
+  - Write concise, technical TypeScript code with accurate examples.
+  - Use functional and declarative programming patterns; avoid classes.
+  - Prefer iteration and modularization over code duplication.
+  - Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
+  - Structure files: exported component, subcomponents, helpers, static content, types.
+  
+  Naming Conventions
+  - Use lowercase with dashes for directories (e.g., components/auth-wizard).
+  - Favor named exports for components.
+  
+  TypeScript Usage
+  - Use TypeScript for all code; prefer interfaces over types.
+  - Avoid enums; use maps instead.
+  - Use functional components with TypeScript interfaces.
+  
+  Syntax and Formatting
+  - Use the "function" keyword for pure functions.
+  - Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
+  - Use declarative JSX.
+  
+  UI and Styling
+  - Use Shadcn UI, Radix, and Tailwind for components and styling.
+  - Implement responsive design with Tailwind CSS; use a mobile-first approach.
+  
+  Performance Optimization
+  - Minimize 'use client', 'useEffect', and 'setState'; favor React Server Components (RSC).
+  - Wrap client components in Suspense with fallback.
+  - Use dynamic loading for non-critical components.
+  - Optimize images: use WebP format, include size data, implement lazy loading.
+  
+  Key Conventions
+  - Use 'nuqs' for URL search parameter state management.
+  - Optimize Web Vitals (LCP, CLS, FID).
+  - Limit 'use client':
+    - Favor server components and Next.js SSR.
+    - Use only for Web API access in small components.
+    - Avoid for data fetching or state management.
+  
+  Follow Next.js docs for Data Fetching, Rendering, and Routing.
+  

package/README.md

@@ -108,12 +108,18 @@ npm run example:publish
 npm run example:append -- --txhash=0x123456...
 # OR
 PUBLISH_TX_HASH=0x123456... npm run example:append
+
+# Run the retrieve file example (download a file from blockchain)
+npm run example:retrieve -- --txhash=0x123456... --output=./downloaded-file.txt
+# OR
+CKBFS_TX_HASH=0x123456... npm run example:retrieve
 ```
 
 ### Example Files
 
 - `examples/publish.ts` - Shows how to publish a file to CKBFS
 - `examples/append.ts` - Shows how to append to a previously published file
+- `examples/retrieve.ts` - Shows how to retrieve a complete file from the blockchain
 
 To run the examples, first set your CKB private key:
 

package/append.txt

@@ -1 +1 @@
-This is content to append to the previously published file.
+This is content to append to the previously published file.

package/dist/utils/molecule.d.ts

@@ -62,7 +62,7 @@ export type BackLinkType = {
     checksum: number;
 };
 export type CKBFSDataType = {
-    index?: number[];
+    index?: number[] | number;
     indexes?: number[];
     checksum: number;
     contentType: Uint8Array;

package/dist/utils/molecule.js

@@ -41,9 +41,18 @@ exports.CKBFSDataV2 = codec_1.molecule.table({
     filename: base_1.blockchain.Bytes,
     backLinks: exports.BackLinksV2,
 }, ["indexes", "checksum", "contentType", "filename", "backLinks"]);
-// Helper function to safely get either index or indexes
+// Helper function to safely get either index or indexes as array
 function getIndexes(data) {
-    return data.indexes || data.index || [];
+    if (Array.isArray(data.indexes)) {
+        return data.indexes;
+    }
+    if (Array.isArray(data.index)) {
+        return data.index;
+    }
+    if (typeof data.index === 'number') {
+        return [data.index];
+    }
+    return [];
 }
 // Helper function to safely get either index or indexes from BackLinkType
 function getBackLinkIndex(bl) {
@@ -69,31 +78,78 @@ function getBackLinkIndexes(bl) {
 exports.CKBFSData = {
     pack: (data, version = constants_1.ProtocolVersion.V2) => {
         if (version === constants_1.ProtocolVersion.V1) {
-            // V1 formatting
+            // For V1, we need a single number index
+            let indexValue = [];
+            // Handle the various ways index might be specified
+            if (typeof data.index === 'number') {
+                // Single number
+                indexValue = [data.index];
+            }
+            else if (Array.isArray(data.index) && data.index.length > 0) {
+                // Array of numbers, use as is
+                indexValue = data.index;
+            }
+            else if (Array.isArray(data.indexes) && data.indexes.length > 0) {
+                // Try using indexes field if index is not available
+                indexValue = data.indexes;
+            }
+            // Map backlinks to V1 format - ensure each one has a single index
+            const v1Backlinks = data.backLinks.map(bl => {
+                let singleIndex = 0;
+                if (typeof bl.index === 'number') {
+                    singleIndex = bl.index;
+                }
+                else if (Array.isArray(bl.indexes) && bl.indexes.length > 0) {
+                    singleIndex = bl.indexes[0];
+                }
+                return {
+                    txHash: bl.txHash,
+                    index: singleIndex,
+                    checksum: bl.checksum
+                };
+            });
             return exports.CKBFSDataV1.pack({
-                index: getIndexes(data),
+                index: indexValue,
                 checksum: data.checksum,
                 contentType: data.contentType,
                 filename: data.filename,
-                backLinks: data.backLinks.map(bl => ({
-                    txHash: bl.txHash,
-                    index: getBackLinkIndex(bl),
-                    checksum: bl.checksum,
-                })),
+                backLinks: v1Backlinks
             });
         }
         else {
-            // V2 formatting
+            // V2 format - use indexes as an array
+            let indexesArray = [];
+            // Handle different index specification formats
+            if (Array.isArray(data.indexes) && data.indexes.length > 0) {
+                indexesArray = data.indexes;
+            }
+            else if (Array.isArray(data.index) && data.index.length > 0) {
+                indexesArray = data.index;
+            }
+            else if (typeof data.index === 'number') {
+                indexesArray = [data.index];
+            }
+            // Map backlinks to V2 format - ensure each one has indexes array
+            const v2Backlinks = data.backLinks.map(bl => {
+                let indexesValue = [];
+                if (Array.isArray(bl.indexes) && bl.indexes.length > 0) {
+                    indexesValue = bl.indexes;
+                }
+                else if (typeof bl.index === 'number') {
+                    indexesValue = [bl.index];
+                }
+                return {
+                    txHash: bl.txHash,
+                    indexes: indexesValue,
+                    checksum: bl.checksum
+                };
+            });
             return exports.CKBFSDataV2.pack({
-                indexes: getIndexes(data),
+                indexes: indexesArray,
                 checksum: data.checksum,
                 contentType: data.contentType,
                 filename: data.filename,
-                backLinks: data.backLinks.map(bl => ({
-                    txHash: bl.txHash,
-                    indexes: getBackLinkIndexes(bl),
-                    checksum: bl.checksum,
-                })),
+                backLinks: v2Backlinks
             });
         }
     },

package/dist/utils/transaction.js

@@ -46,7 +46,7 @@ function createCKBFSCell(options) {
  * @returns Promise resolving to the created transaction
  */
 async function createPublishTransaction(signer, options) {
-    const { contentChunks, contentType, filename, lock, feeRate, network = constants_1.DEFAULT_NETWORK, version = constants_1.DEFAULT_VERSION, useTypeID = false } = options;
+    const { contentChunks, contentType, filename, lock, capacity, feeRate, network = constants_1.DEFAULT_NETWORK, version = constants_1.DEFAULT_VERSION, useTypeID = false } = options;
     // Calculate checksum for the combined content
     const textEncoder = new TextEncoder();
     const combinedContent = Buffer.concat(contentChunks);
@@ -84,6 +84,8 @@ async function createPublishTransaction(signer, options) {
     }
     // Get CKBFS script config
     const config = (0, constants_1.getCKBFSScriptConfig)(network, version, useTypeID);
+    const preCkbfsTypeScript = new core_1.Script(ensureHexPrefix(config.codeHash), config.hashType, "0x0000000000000000000000000000000000000000000000000000000000000000");
+    const ckbfsCellSize = BigInt(outputData.length + preCkbfsTypeScript.occupiedSize + lock.occupiedSize + 8) * 100000000n;
     // Create pre transaction without cell deps initially
     const preTx = core_1.Transaction.from({
         outputs: [
@@ -93,7 +95,8 @@ async function createPublishTransaction(signer, options) {
                 lock,
                 network,
                 version,
-                useTypeID
+                useTypeID,
+                capacity: ckbfsCellSize || capacity
             })
         ],
         witnesses: [
@@ -154,7 +157,8 @@ async function createAppendTransaction(signer, options) {
     // Get CKBFS script config early to use version info
     const config = (0, constants_1.getCKBFSScriptConfig)(network, version);
     // Create CKBFS witnesses - this may vary between V1 and V2
-    const ckbfsWitnesses = (0, witness_1.createChunkedCKBFSWitnesses)(contentChunks);
+    // Pass the version to ensure the correct witness format
+    const ckbfsWitnesses = (0, witness_1.createChunkedCKBFSWitnesses)(contentChunks, 0, version);
     // Combine the new content chunks
     const combinedContent = Buffer.concat(contentChunks);
     // Instead of calculating a new checksum from scratch, update the existing checksum
@@ -166,42 +170,81 @@ async function createAppendTransaction(signer, options) {
     let newBackLink;
     if (version === constants_1.ProtocolVersion.V1) {
         // V1 format: Use index field (single number)
+        // In V1, BackLink.index should be a single number (not an array)
+        let singleIndex = 0;
+        if (data.index) {
+            if (Array.isArray(data.index) && data.index.length > 0) {
+                singleIndex = data.index[0];
+            }
+            else if (typeof data.index === 'number') {
+                singleIndex = data.index;
+            }
+        }
         newBackLink = {
             txHash: outPoint.txHash,
-            index: data.index && data.index.length > 0 ? data.index[0] : 0,
+            index: singleIndex,
             checksum: data.checksum,
         };
     }
     else {
         // V2 format: Use indexes field (array of numbers)
+        const indices = [];
+        if (data.indexes && Array.isArray(data.indexes)) {
+            indices.push(...data.indexes);
+        }
+        else if (data.index) {
+            if (Array.isArray(data.index)) {
+                indices.push(...data.index);
+            }
+            else if (typeof data.index === 'number') {
+                indices.push(data.index);
+            }
+        }
         newBackLink = {
             txHash: outPoint.txHash,
-            indexes: data.indexes || data.index || [],
+            indexes: indices,
             checksum: data.checksum,
         };
     }
-    // Update backlinks
+    // Update backlinks - preserve the existing backlinks
     const backLinks = [...(data.backLinks || []), newBackLink];
-    // Define indices based on version
-    let outputData;
     // Calculate the actual witness indices where our content is placed
     // Index 0 is reserved for the secp256k1 witness for signing
     // So our CKBFS data starts at index 1
     const contentStartIndex = 1;
     const witnessIndices = Array.from({ length: contentChunks.length }, (_, i) => contentStartIndex + i);
+    // Define indices based on version
+    let outputData;
     if (version === constants_1.ProtocolVersion.V1) {
-        // In V1, use the first index where content is placed
-        // (even if we have multiple witnesses, V1 only supports a single index)
+        // In V1, index should be a single number (not an array)
+        // Rule 13 for V1: Output CKBFS Cell's index cannot be null
         outputData = molecule_1.CKBFSData.pack({
-            index: [contentStartIndex],
+            index: witnessIndices[0], // Use the first witness index as a single number
             checksum: contentChecksum,
             contentType: data.contentType,
             filename: data.filename,
-            backLinks,
+            backLinks: backLinks.map(bl => {
+                // Ensure V1 format backlinks use a single index number
+                let singleIndex = 0;
+                // Handle existing index field
+                if (typeof bl.index === 'number') {
+                    singleIndex = bl.index;
+                }
+                // Try to extract from indexes array if available
+                else if (bl.indexes && Array.isArray(bl.indexes) && bl.indexes.length > 0) {
+                    singleIndex = bl.indexes[0];
+                }
+                return {
+                    txHash: bl.txHash,
+                    index: singleIndex,
+                    checksum: bl.checksum
+                };
+            }),
         }, version);
     }
     else {
         // In V2, use all the indices where content is placed
+        // Rule 13 for V2: Output CKBFS Cell's indexes cannot be empty
         outputData = molecule_1.CKBFSData.pack({
             indexes: witnessIndices,
             checksum: contentChecksum,

package/dist/utils/witness.d.ts

@@ -34,6 +34,7 @@ export declare function isCKBFSWitness(witness: Uint8Array): boolean;
  * Creates an array of witnesses for a CKBFS transaction from content chunks
  * @param contentChunks Array of content chunks
  * @param version Optional version byte (default is 0)
+ * @param protocolVersion Optional protocol version (default is V2)
  * @returns Array of Uint8Array witnesses
  */
-export declare function createChunkedCKBFSWitnesses(contentChunks: Uint8Array[], version?: number): Uint8Array[];
+export declare function createChunkedCKBFSWitnesses(contentChunks: Uint8Array[], version?: number, protocolVersion?: string): Uint8Array[];

package/dist/utils/witness.js

@@ -65,8 +65,9 @@ function isCKBFSWitness(witness) {
  * Creates an array of witnesses for a CKBFS transaction from content chunks
  * @param contentChunks Array of content chunks
  * @param version Optional version byte (default is 0)
+ * @param protocolVersion Optional protocol version (default is V2)
  * @returns Array of Uint8Array witnesses
  */
-function createChunkedCKBFSWitnesses(contentChunks, version = 0) {
+function createChunkedCKBFSWitnesses(contentChunks, version = 0, protocolVersion) {
     return contentChunks.map(chunk => createCKBFSWitness(chunk, version));
 }

package/example.txt

@@ -1 +1 @@
-This is a sample file for testing CKBFS.
+Hello, CKBFS! This is a sample file published using 20240906.ce6724722cf6 protocol.

package/examples/append.ts

@@ -1,5 +1,5 @@
 import { CKBFS, NetworkType, ProtocolVersion, CKBFSDataType, extractCKBFSWitnessContent, isCKBFSWitness, CKBFSData } from '../src/index';
-import { Script, ClientPublicTestnet, Transaction } from "@ckb-ccc/core";
+import { Script, ClientPublicTestnet, Transaction, ccc } from "@ckb-ccc/core";
 
 // Replace with your actual private key
 const privateKey = process.env.CKB_PRIVATE_KEY || 'your-private-key-here';
@@ -77,25 +77,30 @@ async function getCellInfoFromTransaction(txHash: string): Promise<{
     // Parse the output data as CKBFS data
     // First remove 0x prefix if present
     const rawData = outputData.startsWith('0x') 
-      ? Buffer.from(outputData.slice(2), 'hex') 
+      ? ccc.bytesFrom(outputData.slice(2), 'hex')
       : Buffer.from(outputData, 'hex');
-      
-    // For demonstration purposes, we'll manually create a CKBFSDataType object
-    // In a real app, you would properly decode the rawData from molecule format
-    const sampleDataFields = {
-      index: [1],
-      checksum: 12345,
-      contentType: new TextEncoder().encode('text/plain'),
-      filename: new TextEncoder().encode('example.txt'),
-      backLinks: []
-    };
     
-    // Use this as our data
-    const ckbfsData: CKBFSDataType = sampleDataFields;
+    // Actually unpack the raw data using CKBFSData.unpack
+    // Use the same protocol version as configured in the SDK
+    const version = ProtocolVersion.V2; // Use V2 as configured in SDK initialization
+    console.log(`Using protocol version ${version} for unpacking cell data`);
     
-    console.log(`CKBFS data processed`);
-    console.log(`Using filename: ${new TextDecoder().decode(ckbfsData.filename)}`);
-    console.log(`Using content type: ${new TextDecoder().decode(ckbfsData.contentType)}`);
+    let ckbfsData: CKBFSDataType;
+    try {
+      ckbfsData = CKBFSData.unpack(rawData, version);
+      
+      // Log the actual cell data for transparency
+      console.log('Successfully unpacked CKBFS cell data:');
+      console.log(`- Checksum: ${ckbfsData.checksum}`);
+      console.log(`- File: ${ckbfsData.filename}`);
+      console.log(`- Content Type: ${ckbfsData.contentType}`);
+      console.log(`- Index: ${ckbfsData.index}`);
+      console.log(`- Indexes: ${ckbfsData.indexes}`);
+      console.log(`- Backlinks count: ${ckbfsData.backLinks?.length || 0}`);
+    } catch (error) {
+      console.error('Error unpacking CKBFS data:', error);
+      throw new Error(`Failed to unpack CKBFS data: ${error}`);
+    }
     
     return {
       outPoint: {
@@ -110,42 +115,8 @@ async function getCellInfoFromTransaction(txHash: string): Promise<{
   } catch (error) {
     console.error('Error retrieving transaction data:', error);
     
-    // Fallback to simulated data for demonstration purposes
-    console.warn('FALLBACK: Using simulated data for demonstration');
-    
-    // Get lock script for this account
-    const lock = await ckbfs.getLock();
-    
-    // Get CKBFS script config
-    const config = ckbfs.getCKBFSConfig();
-    
-    // Create sample data for demonstration
-    const sampleData: CKBFSDataType = {
-      index: [1],
-      checksum: 12345, // Sample checksum number
-      contentType: new TextEncoder().encode('text/plain'),
-      filename: new TextEncoder().encode('example.txt'),
-      backLinks: []
-    };
-    
-    // Create the type script
-    const typeArgs = '0x3cc03661013140855e756c032ce83bc270a7ca3f1f3b76ec21a8ea0155ac3a7c';
-    const typeScript = new Script(
-      ensureHexPrefix(config.codeHash),
-      config.hashType as any,
-      typeArgs
-    );
-    
-    return {
-      outPoint: {
-        txHash,
-        index: 0
-      },
-      type: typeScript,
-      lock,
-      capacity: 200n * 100000000n,
-      data: sampleData
-    };
+    // If we can't get or parse the real data, we should fail - not use mock data
+    throw new Error(`Failed to retrieve or parse cell data: ${error}`);
   }
 }
 

package/examples/retrieve.ts

@@ -0,0 +1,115 @@
+import { CKBFS, NetworkType, ProtocolVersion, getFileContentFromChain, saveFileFromChain } from '../src/index';
+import { ClientPublicTestnet } from "@ckb-ccc/core";
+
+// Replace with your actual private key (or leave this default if just reading)
+const privateKey = process.env.CKB_PRIVATE_KEY || 'your-private-key-here';
+
+// Parse command line arguments for transaction hash
+const txHashArg = process.argv.find(arg => arg.startsWith('--txhash='));
+const outputArg = process.argv.find(arg => arg.startsWith('--output='));
+
+const txHash = txHashArg ? txHashArg.split('=')[1] : process.env.CKBFS_TX_HASH || '';
+const outputPath = outputArg ? outputArg.split('=')[1] : undefined;
+
+if (!txHash) {
+  console.error('Please provide a transaction hash using --txhash=<tx_hash> or the CKBFS_TX_HASH environment variable');
+  process.exit(1);
+}
+
+// Initialize the SDK (read-only is fine for retrieval)
+const ckbfs = new CKBFS(
+  privateKey,
+  NetworkType.Testnet,
+  {
+    version: ProtocolVersion.V2,
+    useTypeID: false
+  }
+);
+
+// Initialize CKB client for testnet
+const client = new ClientPublicTestnet();
+
+/**
+ * Example of retrieving a file from CKBFS
+ */
+async function retrieveExample() {
+  try {
+    console.log(`Retrieving CKBFS file from transaction: ${txHash}`);
+    
+    // Get transaction details
+    const txWithStatus = await client.getTransaction(txHash);
+    if (!txWithStatus || !txWithStatus.transaction) {
+      throw new Error(`Transaction ${txHash} not found`);
+    }
+    
+    // Find index of the CKBFS cell in outputs (assuming it's the first one with a type script)
+    const tx = txWithStatus.transaction;
+    let ckbfsCellIndex = 0;
+    
+    // Get cell data
+    const outputData = tx.outputsData[ckbfsCellIndex];
+    if (!outputData) {
+      throw new Error('Output data not found');
+    }
+    
+    // Get cell info for retrieval
+    const outPoint = {
+      txHash,
+      index: ckbfsCellIndex
+    };
+    
+    // Import necessary components from index
+    const { CKBFSData } = require('../src/index');
+    
+    // Parse the output data
+    const rawData = outputData.startsWith('0x') 
+      ? Buffer.from(outputData.slice(2), 'hex') 
+      : Buffer.from(outputData, 'hex');
+    
+    // Try with both V1 and V2 protocols
+    let ckbfsData;
+    try {
+      console.log('Trying to unpack with V2...');
+      ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V2);
+    } catch (error) {
+      console.log('Failed with V2, trying V1...');
+      ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V1);
+    }
+    
+    // Retrieve full file content
+    console.log('Retrieving file content by following backlinks...');
+    const fileContent = await getFileContentFromChain(client, outPoint, ckbfsData);
+    console.log(`Retrieved file content: ${fileContent.length} bytes`);
+    
+    // Save to file
+    const savedPath = saveFileFromChain(fileContent, ckbfsData, outputPath);
+    console.log(`File saved to: ${savedPath}`);
+    
+    return savedPath;
+  } catch (error) {
+    console.error('Error retrieving file:', error);
+    throw error;
+  }
+}
+
+/**
+ * Main function to run the example
+ */
+async function main() {
+  console.log('Running CKBFS file retrieval example...');
+  console.log('--------------------------------------');
+  
+  try {
+    await retrieveExample();
+    console.log('Example completed successfully!');
+    process.exit(0);
+  } catch (error) {
+    console.error('Example failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the example if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+} 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckbfs/api",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "SDK for CKBFS protocol on CKB",
   "license": "MIT",
   "author": "Code Monad<code@lab-11.org>",
@@ -14,7 +14,8 @@
     "test": "jest",
     "example": "ts-node examples/index.ts",
     "example:publish": "ts-node examples/publish.ts",
-    "example:append": "ts-node examples/append.ts"
+    "example:append": "ts-node examples/append.ts",
+    "example:retrieve": "ts-node examples/retrieve.ts"
   },
   "keywords": [
     "ckb",
@@ -23,17 +24,18 @@
     "sdk"
   ],
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "@types/node": "^22.7.9",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.6.3",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2",
-    "@types/jest": "^29.5.12"
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.3"
   },
   "dependencies": {
     "@ckb-ccc/core": "^0.1.0-alpha.4",
     "@ckb-lumos/base": "^0.23.0",
     "@ckb-lumos/codec": "^0.23.0",
+    "adler-32": "^1.3.1",
     "hash-wasm": "^4.11.0"
   }
 }

package/publish-tx-hash-v1.txt

@@ -0,0 +1 @@
+0x3f61e43834d55fd3f3c8cf9d8a9c643db7790050ffb00734a1fb66da8e98478f

package/src/index.ts

@@ -22,7 +22,9 @@ import {
   writeFile,
   getContentType,
   splitFileIntoChunks,
-  combineChunksToFile
+  combineChunksToFile,
+  getFileContentFromChain,
+  saveFileFromChain
 } from './utils/file';
 import {
   createCKBFSWitness,
@@ -323,6 +325,8 @@ export {
   getContentType,
   splitFileIntoChunks,
   combineChunksToFile,
+  getFileContentFromChain,
+  saveFileFromChain,
   
   // Witness utilities
   createCKBFSWitness,

package/src/utils/checksum.ts

@@ -1,4 +1,5 @@
 import { adler32 } from 'hash-wasm';
+import ADLER32 from 'adler-32';
 
 /**
  * Utility functions for Adler32 checksum generation and verification
@@ -16,24 +17,40 @@ export async function calculateChecksum(data: Uint8Array): Promise<number> {
 }
 
 /**
- * Updates an existing checksum with new data
+ * Updates an existing checksum with new data using proper rolling Adler-32 calculation
  * @param previousChecksum The existing checksum to update
  * @param newData The new data to add to the checksum
  * @returns Promise resolving to the updated checksum as a number
  */
 export async function updateChecksum(previousChecksum: number, newData: Uint8Array): Promise<number> {
-  // In a real implementation, this would require the actual Adler32 state recovery
-  // For now, we're simply concatenating the previousChecksum as a hex string with the new data
-  // and calculating a new checksum
+  // Extract a and b values from the previous checksum
+  // In Adler-32, the checksum is composed of two 16-bit integers: a and b
+  // The final checksum is (b << 16) | a
+  const a = previousChecksum & 0xFFFF;
+  const b = (previousChecksum >>> 16) & 0xFFFF;
   
-  const checksumBytes = Buffer.alloc(4);
-  checksumBytes.writeUInt32BE(previousChecksum);
+  // Use the adler-32 package to calculate a proper rolling checksum
+  // The package doesn't have a "resume" function, so we need to work with the underlying algorithm
   
-  // Concatenate the previous checksum bytes with the new data
-  const combinedData = Buffer.concat([checksumBytes, Buffer.from(newData)]);
+  // Initialize with existing a and b values
+  let adlerA = a;
+  let adlerB = b;
+  const MOD_ADLER = 65521; // Adler-32 modulo value
   
-  // Calculate the new checksum
-  return calculateChecksum(combinedData);
+  // Process each byte of the new data
+  for (let i = 0; i < newData.length; i++) {
+    adlerA = (adlerA + newData[i]) % MOD_ADLER;
+    adlerB = (adlerB + adlerA) % MOD_ADLER;
+  }
+  
+  // Combine a and b to get the final checksum
+  const updatedChecksum = (adlerB << 16) | adlerA;
+  
+  // The result should match what you'd get from the adler-32 package
+  // You can verify this in testing by calculating a full checksum
+  // of original + new data and comparing with this rolling result
+  
+  return updatedChecksum;
 }
 
 /**

package/src/utils/createPublishTransaction

@@ -0,0 +1,24 @@
+// Create CKBFS cell output data based on version
+let outputData: Uint8Array;
+
+if (version === ProtocolVersion.V1) {
+  // V1 format: Single index field (a single number, not an array)
+  // For V1, use the first index where content is placed
+  outputData = CKBFSData.pack({
+    index: contentStartIndex,
+    checksum,
+    contentType: textEncoder.encode(contentType),
+    filename: textEncoder.encode(filename),
+    backLinks: [],
+  }, version);
+} else {
+  // V2 format: Multiple indexes (array of numbers)
+  // For V2, use all the indices where content is placed
+  outputData = CKBFSData.pack({
+    indexes: witnessIndices,
+    checksum,
+    contentType: textEncoder.encode(contentType),
+    filename: textEncoder.encode(filename),
+    backLinks: [],
+  }, version);
+} 

package/src/utils/file.ts

@@ -106,4 +106,147 @@ export function splitFileIntoChunks(filePath: string, chunkSize: number): Uint8A
 export function combineChunksToFile(chunks: Uint8Array[], outputPath: string): void {
   const combinedBuffer = Buffer.concat(chunks.map(chunk => Buffer.from(chunk)));
   writeFile(outputPath, combinedBuffer);
+}
+
+/**
+ * Utility function to safely decode buffer to string
+ * @param buffer The buffer to decode
+ * @returns Decoded string or placeholder on error
+ */
+function safelyDecode(buffer: any): string {
+  if (!buffer) return '[Unknown]';
+  try {
+    if (buffer instanceof Uint8Array) {
+      return new TextDecoder().decode(buffer);
+    } else if (typeof buffer === 'string') {
+      return buffer;
+    } else {
+      return `[Buffer: ${buffer.toString()}]`;
+    }
+  } catch (e) {
+    return '[Decode Error]';
+  }
+}
+
+/**
+ * Retrieves complete file content from the blockchain by following backlinks
+ * @param client The CKB client to use for blockchain queries
+ * @param outPoint The output point of the latest CKBFS cell
+ * @param ckbfsData The data from the latest CKBFS cell
+ * @returns Promise resolving to the complete file content
+ */
+export async function getFileContentFromChain(
+  client: any,
+  outPoint: { txHash: string; index: number },
+  ckbfsData: any
+): Promise<Uint8Array> {
+  console.log(`Retrieving file: ${safelyDecode(ckbfsData.filename)}`);
+  console.log(`Content type: ${safelyDecode(ckbfsData.contentType)}`);
+  
+  // Prepare to collect all content pieces
+  const contentPieces: Uint8Array[] = [];
+  let currentData = ckbfsData;
+  let currentOutPoint = outPoint;
+  
+  // Process the current transaction first
+  const tx = await client.getTransaction(currentOutPoint.txHash);
+  if (!tx || !tx.transaction) {
+    throw new Error(`Transaction ${currentOutPoint.txHash} not found`);
+  }
+  
+  // Get content from witnesses
+  const indexes = currentData.indexes || (currentData.index !== undefined ? [currentData.index] : []);
+  if (indexes.length > 0) {
+    // Get content from each witness index
+    for (const idx of indexes) {
+      if (idx >= tx.transaction.witnesses.length) {
+        console.warn(`Witness index ${idx} out of range`);
+        continue;
+      }
+      
+      const witnessHex = tx.transaction.witnesses[idx];
+      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') {
+        const content = witness.slice(6);
+        contentPieces.unshift(content); // Add to beginning of array (we're going backwards)
+      } else {
+        console.warn(`Witness at index ${idx} is not a valid CKBFS witness`);
+      }
+    }
+  }
+  
+  // Follow backlinks recursively
+  if (currentData.backLinks && currentData.backLinks.length > 0) {
+    // Process each backlink, from most recent to oldest
+    for (let i = currentData.backLinks.length - 1; i >= 0; i--) {
+      const backlink = currentData.backLinks[i];
+      
+      // Get the transaction for this backlink
+      const backTx = await client.getTransaction(backlink.txHash);
+      if (!backTx || !backTx.transaction) {
+        console.warn(`Backlink transaction ${backlink.txHash} not found`);
+        continue;
+      }
+      
+      // Get content from backlink witnesses
+      const backIndexes = backlink.indexes || (backlink.index !== undefined ? [backlink.index] : []);
+      if (backIndexes.length > 0) {
+        // Get content from each witness index
+        for (const idx of backIndexes) {
+          if (idx >= backTx.transaction.witnesses.length) {
+            console.warn(`Backlink witness index ${idx} out of range`);
+            continue;
+          }
+          
+          const witnessHex = backTx.transaction.witnesses[idx];
+          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') {
+            const content = witness.slice(6);
+            contentPieces.unshift(content); // Add to beginning of array (we're going backwards)
+          } else {
+            console.warn(`Backlink witness at index ${idx} is not a valid CKBFS witness`);
+          }
+        }
+      }
+    }
+  }
+  
+  // Combine all content pieces
+  return Buffer.concat(contentPieces);
+}
+
+/**
+ * Saves file content retrieved from blockchain to disk
+ * @param content The file content to save
+ * @param ckbfsData The CKBFS cell data containing file metadata
+ * @param outputPath Optional path to save the file (defaults to filename in current directory)
+ * @returns The path where the file was saved
+ */
+export function saveFileFromChain(
+  content: Uint8Array,
+  ckbfsData: any,
+  outputPath?: string
+): string {
+  // Get filename from CKBFS data
+  const filename = safelyDecode(ckbfsData.filename);
+  
+  // Determine output path
+  const filePath = outputPath || filename;
+  
+  // Ensure directory exists
+  const directory = path.dirname(filePath);
+  if (!fs.existsSync(directory)) {
+    fs.mkdirSync(directory, { recursive: true });
+  }
+  
+  // Write file
+  fs.writeFileSync(filePath, content);
+  console.log(`File saved to: ${filePath}`);
+  console.log(`Size: ${content.length} bytes`);
+  
+  return filePath;
 } 

package/src/utils/molecule.ts

@@ -1,44 +1,43 @@
 import { molecule, number } from "@ckb-lumos/codec";
 import { blockchain } from "@ckb-lumos/base";
 import { ProtocolVersion } from "./constants";
+import { ccc } from "@ckb-ccc/core";
 
 /**
  * Molecule definitions for CKBFS data structures.
  */
 
-// Define the Indexes vector
+// Define the Indexes vector for V2
 export const Indexes = molecule.vector(number.Uint32);
 
-// Define the BackLink table structure for V1
+// V1: BackLink has index as Uint32, and fields are ordered differently
 export const BackLinkV1 = molecule.table(
   {
-    txHash: blockchain.Byte32,
     index: number.Uint32,
     checksum: number.Uint32,
+    txHash: blockchain.Byte32,
   },
-  ["txHash", "index", "checksum"]
+  ["index", "checksum", "txHash"]
 );
 
-// Define the BackLink table structure for V2
+// V2: BackLink has indexes as vector of Uint32
 export const BackLinkV2 = molecule.table(
   {
-    txHash: blockchain.Byte32,
     indexes: Indexes,
     checksum: number.Uint32,
+    txHash: blockchain.Byte32,
   },
-  ["txHash", "indexes", "checksum"]
+  ["indexes", "checksum", "txHash"]
 );
 
-// Define the BackLinks vector for V1
+// Define the BackLinks vector for V1 and V2
 export const BackLinksV1 = molecule.vector(BackLinkV1);
-
-// Define the BackLinks vector for V2
 export const BackLinksV2 = molecule.vector(BackLinkV2);
 
-// Define the CKBFSData table structure for V1
+// V1: CKBFSData has index as optional Uint32
 export const CKBFSDataV1 = molecule.table(
   {
-    index: Indexes,
+    index: number.Uint32,
     checksum: number.Uint32,
     contentType: blockchain.Bytes,
     filename: blockchain.Bytes,
@@ -47,7 +46,7 @@ export const CKBFSDataV1 = molecule.table(
   ["index", "checksum", "contentType", "filename", "backLinks"]
 );
 
-// Define the CKBFSData table structure for V2
+// V2: CKBFSData has indexes as vector of Uint32
 export const CKBFSDataV2 = molecule.table(
   {
     indexes: Indexes,
@@ -61,41 +60,50 @@ export const CKBFSDataV2 = molecule.table(
 
 // Type definitions for TypeScript
 export type BackLinkTypeV1 = {
-  txHash: string;
   index: number;
   checksum: number;
+  txHash: string;
 };
 
 export type BackLinkTypeV2 = {
-  txHash: string;
   indexes: number[];
   checksum: number;
+  txHash: string;
 };
 
 // Combined type that works with both versions
 export type BackLinkType = {
-  txHash: string;
   index?: number;
   indexes?: number[];
   checksum: number;
+  txHash: string;
 };
 
 // Combined CKBFSData type that works with both versions
 export type CKBFSDataType = {
-  index?: number[];
+  index?: number;
   indexes?: number[];
   checksum: number;
-  contentType: Uint8Array;
-  filename: Uint8Array;
+  contentType: string;
+  filename: string;
   backLinks: BackLinkType[];
 };
 
-// Helper function to safely get either index or indexes
+// Helper function to get indexes array from data
 function getIndexes(data: CKBFSDataType): number[] {
-  return data.indexes || data.index || [];
+  if (data.indexes) return data.indexes;
+  if (typeof data.index === 'number') return [data.index];
+  return [];
+}
+
+// Helper function to get single index from data
+function getIndex(data: CKBFSDataType): number {
+  if (typeof data.index === 'number') return data.index;
+  if (data.indexes && data.indexes.length > 0) return data.indexes[0];
+  return 0;
 }
 
-// Helper function to safely get either index or indexes from BackLinkType
+// Helper function to safely get either index or indexes from BackLinkType for V1
 function getBackLinkIndex(bl: BackLinkType): number {
   if (typeof bl.index === 'number') {
     return bl.index;
@@ -106,7 +114,7 @@ function getBackLinkIndex(bl: BackLinkType): number {
   return 0;
 }
 
-// Helper function to safely get indexes array from BackLinkType
+// Helper function to safely get indexes array from BackLinkType for V2
 function getBackLinkIndexes(bl: BackLinkType): number[] {
   if (Array.isArray(bl.indexes)) {
     return bl.indexes;
@@ -121,30 +129,44 @@ function getBackLinkIndexes(bl: BackLinkType): number[] {
 export const CKBFSData = {
   pack: (data: CKBFSDataType, version: string = ProtocolVersion.V2): Uint8Array => {
     if (version === ProtocolVersion.V1) {
-      // V1 formatting
+      // V1 formatting - uses single index
       return CKBFSDataV1.pack({
-        index: getIndexes(data),
+        index: getIndex(data),
         checksum: data.checksum,
-        contentType: data.contentType,
-        filename: data.filename,
-        backLinks: data.backLinks.map(bl => ({
-          txHash: bl.txHash,
-          index: getBackLinkIndex(bl),
-          checksum: bl.checksum,
-        })),
+        contentType: ccc.bytesFrom(data.contentType, 'utf8'),
+        filename: ccc.bytesFrom(data.filename, 'utf8'),
+        backLinks: data.backLinks.map(bl => {
+          // Ensure txHash is in proper format for molecule encoding
+          const txHash = typeof bl.txHash === 'string' 
+            ? ccc.bytesFrom(bl.txHash) 
+            : bl.txHash;
+          
+          return {
+            index: getBackLinkIndex(bl),
+            checksum: bl.checksum,
+            txHash,
+          };
+        }),
       });
     } else {
-      // V2 formatting
+      // V2 formatting - uses indexes array
       return CKBFSDataV2.pack({
         indexes: getIndexes(data),
         checksum: data.checksum,
-        contentType: data.contentType,
-        filename: data.filename,
-        backLinks: data.backLinks.map(bl => ({
-          txHash: bl.txHash,
-          indexes: getBackLinkIndexes(bl),
-          checksum: bl.checksum,
-        })),
+        contentType: ccc.bytesFrom(data.contentType, 'utf8'),
+        filename: ccc.bytesFrom(data.filename, 'utf8'),
+        backLinks: data.backLinks.map(bl => {
+          // Ensure txHash is in proper format for molecule encoding
+          const txHash = typeof bl.txHash === 'string' 
+            ? bl.txHash
+            : bl.txHash;
+          
+          return {
+            indexes: getBackLinkIndexes(bl),
+            checksum: bl.checksum,
+            txHash,
+          };
+        }),
       });
     }
   },
@@ -155,12 +177,12 @@ export const CKBFSData = {
         return {
           index: unpacked.index,
           checksum: unpacked.checksum,
-          contentType: new Uint8Array(Buffer.from(unpacked.contentType)),
-          filename: new Uint8Array(Buffer.from(unpacked.filename)),
+          contentType: ccc.bytesTo(unpacked.contentType, 'utf8'),
+          filename: ccc.bytesTo(unpacked.filename, 'utf8'),
           backLinks: unpacked.backLinks.map(bl => ({
-            txHash: bl.txHash,
             index: bl.index,
             checksum: bl.checksum,
+            txHash: bl.txHash,
           })),
         };
       } else {
@@ -169,12 +191,12 @@ export const CKBFSData = {
         return {
           indexes: unpacked.indexes,
           checksum: unpacked.checksum,
-          contentType: new Uint8Array(Buffer.from(unpacked.contentType)),
-          filename: new Uint8Array(Buffer.from(unpacked.filename)),
+          contentType: ccc.bytesTo(unpacked.contentType, 'utf8'),
+          filename: ccc.bytesTo(unpacked.filename, 'utf8'),
           backLinks: unpacked.backLinks.map(bl => ({
-            txHash: bl.txHash,
             indexes: bl.indexes,
             checksum: bl.checksum,
+            txHash: bl.txHash,
           })),
         };
       }

package/src/utils/transaction.ts

@@ -125,7 +125,9 @@ export async function createPublishTransaction(
   const combinedContent = Buffer.concat(contentChunks);
   const checksum = await calculateChecksum(combinedContent);
   
-  // Create CKBFS witnesses
+  // Create CKBFS witnesses - each chunk already includes the CKBFS header
+  // Pass 0 as version byte - this is the protocol version byte in the witness header
+  // not to be confused with the Protocol Version (V1 vs V2)
   const ckbfsWitnesses = createChunkedCKBFSWitnesses(contentChunks);
   
   // Calculate the actual witness indices where our content is placed
@@ -141,23 +143,23 @@ export async function createPublishTransaction(
   let outputData: Uint8Array;
   
   if (version === ProtocolVersion.V1) {
-    // V1 format: Single index field
+    // V1 format: Single index field (a single number, not an array)
     // For V1, use the first index where content is placed
     outputData = CKBFSData.pack({
-      index: [contentStartIndex],
+      index: contentStartIndex,
       checksum,
-      contentType: textEncoder.encode(contentType),
-      filename: textEncoder.encode(filename),
+      contentType: contentType,
+      filename: filename,
       backLinks: [],
     }, version);
   } else {
-    // V2 format: Multiple indexes
+    // V2 format: Multiple indexes (array of numbers)
     // For V2, use all the indices where content is placed
     outputData = CKBFSData.pack({
       indexes: witnessIndices,
       checksum,
-      contentType: textEncoder.encode(contentType),
-      filename: textEncoder.encode(filename),
+      contentType,
+      filename,
       backLinks: [],
     }, version);
   }
@@ -265,88 +267,98 @@ export async function createAppendTransaction(
   // Get CKBFS script config early to use version info
   const config = getCKBFSScriptConfig(network, version);
   
-  // Create CKBFS witnesses - this may vary between V1 and V2
+  // Create CKBFS witnesses - each chunk already includes the CKBFS header
+  // Pass 0 as version byte - this is the protocol version byte in the witness header
+  // not to be confused with the Protocol Version (V1 vs V2)
   const ckbfsWitnesses = createChunkedCKBFSWitnesses(contentChunks);
   
-  // Combine the new content chunks
+  // Combine the new content chunks for checksum calculation
   const combinedContent = Buffer.concat(contentChunks);
   
-  // Instead of calculating a new checksum from scratch, update the existing checksum
-  // with the new content - this is more efficient and matches the Adler32 algorithm's
-  // cumulative nature
+  // Update the existing checksum with the new content - this matches Adler32's
+  // cumulative nature as required by Rule 11 in the RFC
   const contentChecksum = await updateChecksum(data.checksum, combinedContent);
   console.log(`Updated checksum from ${data.checksum} to ${contentChecksum} for appended content`);
   
+  // Calculate the actual witness indices where our content is placed
+  // Index 0 is reserved for the secp256k1 witness for signing
+  // So our CKBFS data starts at index 1
+  const contentStartIndex = 1;
+  const witnessIndices = Array.from(
+    { length: contentChunks.length }, 
+    (_, i) => contentStartIndex + i
+  );
+  
   // Create backlink for the current state based on version
   let newBackLink: any;
   
   if (version === ProtocolVersion.V1) {
     // V1 format: Use index field (single number)
     newBackLink = {
-      txHash: outPoint.txHash,
-      index: data.index && data.index.length > 0 ? data.index[0] : 0,
+      // In V1, field order is index, checksum, txHash
+      // and index is a single number value, not an array
+      index: data.index || (data.indexes && data.indexes.length > 0 ? data.indexes[0] : 0),
       checksum: data.checksum,
+      txHash: outPoint.txHash,
     };
   } else {
     // V2 format: Use indexes field (array of numbers)
     newBackLink = {
-      txHash: outPoint.txHash,
-      indexes: data.indexes || data.index || [],
+      // In V2, field order is indexes, checksum, txHash
+      // and indexes is an array of numbers
+      indexes: data.indexes || (data.index ? [data.index] : []),
       checksum: data.checksum,
+      txHash: outPoint.txHash,
     };
   }
   
-  // Update backlinks
+  // Update backlinks - add the new one to the existing backlinks array
   const backLinks = [...(data.backLinks || []), newBackLink];
   
-  // Define indices based on version
+  // Define output data based on version
   let outputData: Uint8Array;
   
-  // Calculate the actual witness indices where our content is placed
-  // Index 0 is reserved for the secp256k1 witness for signing
-  // So our CKBFS data starts at index 1
-  const contentStartIndex = 1;
-  const witnessIndices = Array.from(
-    { length: contentChunks.length }, 
-    (_, i) => contentStartIndex + i
-  );
-  
   if (version === ProtocolVersion.V1) {
-    // In V1, use the first index where content is placed
-    // (even if we have multiple witnesses, V1 only supports a single index)
+    // In V1, index is a single number, not an array
+    // The first witness index is used (V1 can only reference one witness)
     outputData = CKBFSData.pack({
-      index: [contentStartIndex],
+      index: witnessIndices[0], // Use only the first index as a number
       checksum: contentChecksum,
       contentType: data.contentType,
       filename: data.filename,
       backLinks,
-    }, version);
+    }, ProtocolVersion.V1); // Explicitly use V1 for packing
   } else {
-    // In V2, use all the indices where content is placed
+    // In V2, indexes is an array of witness indices
     outputData = CKBFSData.pack({
       indexes: witnessIndices,
       checksum: contentChecksum,
       contentType: data.contentType,
       filename: data.filename,
       backLinks,
-    }, version);
+    }, ProtocolVersion.V2); // Explicitly use V2 for packing
   }
   
   // Pack the original data to get its size - use the appropriate version
   const originalData = CKBFSData.pack(data, version);
   const originalDataSize = originalData.length;
   
-  // Get sizes
+  // Get sizes and calculate capacity requirements
   const newDataSize = outputData.length;
-  const dataSizeDiff = newDataSize - originalDataSize;
   
-  // Calculate the additional capacity needed (in shannons)
-  // CKB requires 1 shannon per byte of data
-  const additionalCapacity = BigInt(Math.max(0, dataSizeDiff)) * 100000000n;
+  // Calculate the required capacity for the output cell
+  // This accounts for: 
+  // 1. The output data size
+  // 2. The type script's occupied size
+  // 3. The lock script's occupied size
+  // 4. A constant of 8 bytes (for header overhead)
+  const ckbfsCellSize = BigInt(outputData.length + type.occupiedSize + lock.occupiedSize + 8) * 100000000n;
+  
+  console.log(`Original capacity: ${capacity}, Calculated size: ${ckbfsCellSize}, Data size: ${outputData.length}`);
   
-  // Add the additional capacity to the original cell capacity
-  console.log(`Original capacity: ${capacity}, Additional needed: ${additionalCapacity}, Data size diff: ${dataSizeDiff}, Version: ${version}`);
-  const outputCapacity = capacity + additionalCapacity;
+  // Use the maximum value between calculated size and original capacity
+  // to ensure we have enough capacity but don't decrease capacity unnecessarily
+  const outputCapacity = ckbfsCellSize > capacity ? ckbfsCellSize : capacity;
 
   // Create initial transaction with the CKBFS cell input
   const tx = Transaction.from({
@@ -388,7 +400,8 @@ export async function createAppendTransaction(
   const address = await signer.getRecommendedAddressObj();
   
   // If we need more capacity than the original cell had, add additional inputs
-  if (additionalCapacity > 0n) {
+  if (outputCapacity > capacity) {
+    console.log(`Need additional capacity: ${outputCapacity - capacity} shannons`);
     // Add more inputs to cover the increased capacity
     await tx.completeInputsByCapacity(signer);
   }

package/src/utils/witness.ts

@@ -10,9 +10,10 @@ import { CKBFS_HEADER } from './molecule';
  * @param version Optional version byte (default is 0)
  * @returns Uint8Array containing the witness data
  */
-export function createCKBFSWitness(content: Uint8Array, version: number = 0): Uint8Array {
+export function createCKBFSWitness(content: Uint8Array): Uint8Array {
   // Create witness with CKBFS header, version byte, and content
-  const versionByte = new Uint8Array([version]);
+  // Version byte must always be 0x00 per protocol
+  const versionByte = new Uint8Array([0]);
   return Buffer.concat([CKBFS_HEADER, versionByte, content]);
 }
 
@@ -22,10 +23,10 @@ export function createCKBFSWitness(content: Uint8Array, version: number = 0): Ui
  * @param version Optional version byte (default is 0)
  * @returns Uint8Array containing the witness data
  */
-export function createTextCKBFSWitness(text: string, version: number = 0): Uint8Array {
+export function createTextCKBFSWitness(text: string): Uint8Array {
   const textEncoder = new TextEncoder();
   const contentBytes = textEncoder.encode(text);
-  return createCKBFSWitness(contentBytes, version);
+  return createCKBFSWitness(contentBytes);
 }
 
 /**
@@ -71,6 +72,6 @@ export function isCKBFSWitness(witness: Uint8Array): boolean {
  * @param version Optional version byte (default is 0)
  * @returns Array of Uint8Array witnesses
  */
-export function createChunkedCKBFSWitnesses(contentChunks: Uint8Array[], version: number = 0): Uint8Array[] {
-  return contentChunks.map(chunk => createCKBFSWitness(chunk, version));
+export function createChunkedCKBFSWitnesses(contentChunks: Uint8Array[]): Uint8Array[] {
+  return contentChunks.map(chunk => createCKBFSWitness(chunk));
 } 

package/test-download.txt

@@ -0,0 +1,2 @@
+Hello, CKBFS! This is a sample file published using 20240906.ce6724722cf6 protocol.
+This is content to append to the previously published file.