@ckbfs/api 1.5.0 → 2.0.0

package/examples/chunked-publish.ts

@@ -0,0 +1,307 @@
+import { CKBFS, NetworkType, ProtocolVersion, PublishContentOptions } from '../src/index';
+import { ClientPublicTestnet, Transaction, ccc } from "@ckb-ccc/core";
+import { readFileSync, statSync } from 'fs';
+import { join } from 'path';
+
+// Replace with your actual private key
+const privateKey = process.env.CKB_PRIVATE_KEY || 'your-private-key-here';
+
+// Configuration for chunked publishing
+const CHUNK_SIZE_LIMIT = 490 * 1024; // 490KB configurable limit
+const TRANSACTION_CHUNK_SIZE = 31 * 1024; // 31KB per transaction (SDK internal chunking)
+
+// Initialize the SDK with network and version options
+const ckbfs = new CKBFS(
+  privateKey,
+  NetworkType.Testnet, // Use testnet
+  {
+    version: ProtocolVersion.V2, // Use the latest version (V2)
+    chunkSize: TRANSACTION_CHUNK_SIZE,
+    useTypeID: false, // Use code hash instead of type ID
+  }
+);
+
+// Initialize CKB client for transaction confirmation
+const client = new ClientPublicTestnet();
+
+/**
+ * Wait for transaction confirmation by polling
+ * @param txHash The transaction hash to wait for
+ * @param maxRetries Maximum number of retries (default: 60)
+ * @param retryInterval Interval between retries in milliseconds (default: 5000)
+ */
+async function waitForTransactionConfirmation(
+  txHash: string, 
+  maxRetries: number = 60,
+  retryInterval: number = 5000
+): Promise<boolean> {
+  console.log(`Waiting for transaction confirmation: ${txHash}`);
+  
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const txWithStatus = await client.getTransaction(txHash);
+      if (txWithStatus && txWithStatus.status === 'committed') {
+        console.log(`✅ Transaction confirmed after ${i + 1} attempts`);
+        return true;
+      }
+      
+      console.log(`⏳ Attempt ${i + 1}/${maxRetries} - Transaction status: ${txWithStatus?.status || 'unknown'}`);
+      
+      if (i < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, retryInterval));
+      }
+    } catch (error) {
+      console.log(`❌ Error checking transaction status (attempt ${i + 1}/${maxRetries}):`, error);
+      if (i < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, retryInterval));
+      }
+    }
+  }
+  
+  console.log(`❌ Transaction not confirmed after ${maxRetries} attempts`);
+  return false;
+}
+
+/**
+ * Get file information from a transaction (needed for append operations)
+ * @param txHash The transaction hash
+ */
+async function getCellInfoFromTransaction(txHash: string) {
+  try {
+    const txWithStatus = await client.getTransaction(txHash);
+    if (!txWithStatus || !txWithStatus.transaction) {
+      throw new Error(`Transaction ${txHash} not found`);
+    }
+    
+    const tx = Transaction.from(txWithStatus.transaction);
+    const output = tx.outputs[0]; // First output should be CKBFS cell
+    
+    if (!output || !output.type) {
+      throw new Error('No CKBFS cell found in the transaction');
+    }
+    
+    // Parse output data using CKBFS utilities
+    const outputData = tx.outputsData[0];
+    const rawData = outputData.startsWith('0x') 
+      ? ccc.bytesFrom(outputData.slice(2), 'hex')
+      : Buffer.from(outputData, 'hex');
+    
+    // Import CKBFSData utility for proper parsing
+    const { CKBFSData } = await import('../src/utils/molecule');
+    
+    // Try to unpack CKBFS data with both protocol versions
+    let ckbfsData: any;
+    try {
+      ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V2);
+    } catch (error) {
+      try {
+        ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V1);
+      } catch (v1Error) {
+        throw new Error(`Failed to unpack CKBFS data: V2(${error}), V1(${v1Error})`);
+      }
+    }
+    
+    return {
+      outPoint: {
+        txHash,
+        index: 0
+      },
+      type: output.type,
+      lock: output.lock,
+      capacity: output.capacity,
+      data: ckbfsData // Now properly parsed CKBFSDataType
+    };
+  } catch (error) {
+    console.error('Error retrieving cell info:', error);
+    throw error;
+  }
+}
+
+/**
+ * Publish a large file using chunked approach
+ * @param filePath Path to the file to publish
+ * @param options Publishing options
+ */
+async function publishLargeFile(
+  filePath: string, 
+  options: {
+    contentType?: string;
+    filename?: string;
+    maxChunkSize?: number;
+  } = {}
+): Promise<string> {
+  try {
+    // Check if file exists and get its size
+    const fileStats = statSync(filePath);
+    const fileSize = fileStats.size;
+    const maxChunkSize = options.maxChunkSize || CHUNK_SIZE_LIMIT;
+    
+    console.log(`📁 File: ${filePath}`);
+    console.log(`📏 Size: ${fileSize} bytes (${(fileSize / 1024 / 1024).toFixed(2)} MB)`);
+    console.log(`🔧 Chunk size limit: ${maxChunkSize} bytes (${(maxChunkSize / 1024 / 1024).toFixed(2)} MB)`);
+    
+    // Get address info
+    const address = await ckbfs.getAddress();
+    console.log(`💼 Using address: ${address.toString()}`);
+    
+    // Determine content type and filename
+    const filename = options.filename || filePath.split(/[\\\/]/).pop() || 'unknown';
+    const contentType = options.contentType || 'application/octet-stream';
+    
+    if (fileSize <= maxChunkSize) {
+      console.log('📤 File size is within limit - publishing directly...');
+      
+      const txHash = await ckbfs.publishFile(filePath, {
+        contentType,
+        filename
+      });
+      
+      console.log(`✅ File published successfully in single transaction!`);
+      console.log(`📋 Transaction Hash: ${txHash}`);
+      console.log(`🔗 View at: https://pudge.explorer.nervos.org/transaction/${txHash}`);
+      
+      return txHash;
+    } else {
+      console.log('📦 File is too large - using chunked publishing...');
+      console.log(`🔢 Will split into ${Math.ceil(fileSize / maxChunkSize)} chunks`);
+      
+      // Read file content
+      const fileContent = readFileSync(filePath);
+      
+      // Calculate number of chunks needed
+      const numChunks = Math.ceil(fileSize / maxChunkSize);
+      let lastTxHash = '';
+      let ckbfsCell: any = null;
+      
+      for (let chunkIndex = 0; chunkIndex < numChunks; chunkIndex++) {
+        const start = chunkIndex * maxChunkSize;
+        const end = Math.min(start + maxChunkSize, fileSize);
+        const chunkContent = fileContent.slice(start, end);
+        
+        console.log(`\n🔄 Processing chunk ${chunkIndex + 1}/${numChunks}`);
+        console.log(`📏 Chunk size: ${chunkContent.length} bytes`);
+        
+        if (chunkIndex === 0) {
+          // First chunk - publish as new file
+          console.log('📤 Publishing first chunk...');
+          
+          lastTxHash = await ckbfs.publishContent(chunkContent, {
+            contentType,
+            filename
+          });
+          
+          console.log(`✅ First chunk published: ${lastTxHash}`);
+          
+        } else {
+          // Subsequent chunks - append to existing file
+          console.log('➕ Appending chunk...');
+          
+          // Wait for previous transaction to be confirmed before appending
+          const isConfirmed = await waitForTransactionConfirmation(lastTxHash);
+          if (!isConfirmed) {
+            throw new Error(`Previous transaction ${lastTxHash} was not confirmed`);
+          }
+          
+          // Get cell info from the last transaction
+          ckbfsCell = await getCellInfoFromTransaction(lastTxHash);
+          
+          lastTxHash = await ckbfs.appendContent(chunkContent, ckbfsCell);
+          
+          console.log(`✅ Chunk ${chunkIndex + 1} appended: ${lastTxHash}`);
+        }
+        
+        console.log(`🔗 View chunk ${chunkIndex + 1} at: https://pudge.explorer.nervos.org/transaction/${lastTxHash}`);
+      }
+      
+      // Wait for final transaction confirmation
+      console.log('\n⏳ Waiting for final transaction confirmation...');
+      const finalConfirmed = await waitForTransactionConfirmation(lastTxHash);
+      if (!finalConfirmed) {
+        console.log('⚠️  Warning: Final transaction was not confirmed within timeout');
+      }
+      
+      console.log(`\n🎉 Large file published successfully using ${numChunks} chunks!`);
+      console.log(`📋 Final Transaction Hash: ${lastTxHash}`);
+      console.log(`🔗 View final result at: https://pudge.explorer.nervos.org/transaction/${lastTxHash}`);
+      
+      return lastTxHash;
+    }
+  } catch (error) {
+    console.error('❌ Error publishing large file:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example demonstrating chunked file publishing
+ */
+async function chunkedPublishExample() {
+  try {
+    // Example 1: Small file (should publish directly)
+    console.log('\n=== Example 1: Small File (Direct Publishing) ===');
+    const smallFilePath = './small-example.txt';
+    
+    // Create a small test file
+    const fs = require('fs');
+    if (!fs.existsSync(smallFilePath)) {
+      fs.writeFileSync(smallFilePath, 'This is a small test file that should be published directly.');
+      console.log(`Created test file: ${smallFilePath}`);
+    }
+    
+    console.log('\n=== Example 2: Large File (Chunked Publishing) ===');
+    
+    // For demonstration purposes, create a larger file or use an existing one
+    const largeFilePath = '/mnt/old/nvme_data/ヨルシカ - 春泥棒（OFFICIAL VIDEO） [Sw1Flgub9s8].mp4';
+    
+    // Create a large test file (6MB) if it doesn't exist
+    if (!fs.existsSync(largeFilePath)) {
+      console.log('Creating large test file (6MB) for demonstration...');
+      const largeContent = Buffer.alloc(6 * 1024 * 1024, 0x41); // 6MB of 'A' characters
+      fs.writeFileSync(largeFilePath, largeContent);
+      console.log(`Created large test file: ${largeFilePath}`);
+    }
+    
+    await publishLargeFile(largeFilePath, {
+      contentType: 'video/mp4',
+      filename: 'ヨルシカ - 春泥棒（OFFICIAL VIDEO).mp4',
+      maxChunkSize: CHUNK_SIZE_LIMIT // 4MB chunks
+    });
+    
+  } catch (error) {
+    console.error('Example failed:', error);
+    throw error;
+  }
+}
+
+/**
+ * Main function to run the chunked publishing example
+ */
+async function main() {
+  console.log('🚀 Running CKBFS Chunked Publishing Example...');
+  console.log('===============================================');
+  console.log(`📋 Protocol Version: ${ProtocolVersion.V2}`);
+  console.log(`📏 Chunk Size Limit: ${(CHUNK_SIZE_LIMIT / 1024 / 1024).toFixed(2)} MB`);
+  console.log(`🔧 Transaction Chunk Size: ${(TRANSACTION_CHUNK_SIZE / 1024).toFixed(2)} KB`);
+  
+  try {
+    await chunkedPublishExample();
+    console.log('\n🎉 All examples completed successfully!');
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Examples failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the example if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+export {
+  publishLargeFile,
+  waitForTransactionConfirmation,
+  getCellInfoFromTransaction,
+  CHUNK_SIZE_LIMIT,
+  TRANSACTION_CHUNK_SIZE
+};

package/examples/publish-v3.ts

@@ -0,0 +1,152 @@
+import { CKBFS, NetworkType, ProtocolVersion, PublishContentOptions } from '../src/index';
+
+// Replace with your actual private key
+const privateKey = process.env.CKB_PRIVATE_KEY || 'your-private-key-here';
+
+// Initialize the SDK for CKBFS v3
+const ckbfs = new CKBFS(
+  privateKey,
+  NetworkType.Testnet, // Use testnet
+  {
+    version: ProtocolVersion.V3, // Use v3
+    chunkSize: 30 * 1024, // 30KB chunks
+    useTypeID: false, // Use code hash instead of type ID
+  }
+);
+
+/**
+ * Example of publishing a file to CKBFS v3
+ */
+async function publishFileV3Example() {
+  try {
+    // Get address info
+    const address = await ckbfs.getAddress();
+    console.log(`Using address: ${address.toString()}`);
+    
+    // Get CKBFS script config
+    const config = ckbfs.getCKBFSConfig();
+    console.log('Using CKBFS v3 config:', config);
+    
+    // Publish a text file to CKBFS v3
+    const filePath = './examples/example.txt';
+    
+    // You can provide additional options
+    const options = {
+      contentType: 'text/plain',
+      filename: 'v3-example.txt',
+      // Specify capacity if needed (default is 200 CKB)
+      // capacity: 250n * 100000000n
+    };
+    
+    console.log(`Publishing file to CKBFS v3: ${filePath}`);
+    const txHash = await ckbfs.publishFileV3(filePath, options);
+    
+    console.log(`File published successfully to CKBFS v3!`);
+    console.log(`Transaction Hash: ${txHash}`);
+    console.log(`View at: https://pudge.explorer.nervos.org/transaction/${txHash}`);
+    
+    return txHash;
+  } catch (error) {
+    console.error('Error publishing file to v3:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example of publishing content directly (string) to CKBFS v3
+ */
+async function publishContentV3Example() {
+  try {
+    // Get address info
+    const address = await ckbfs.getAddress();
+    console.log(`Using address for v3 content publish: ${address.toString()}`);
+    
+    // Define content and options (contentType and filename are required)
+    const content = "Hello CKBFS v3 from direct content! This uses witness-based storage with no backlinks in cell data.";
+    const options: PublishContentOptions = {
+      contentType: 'text/plain',
+      filename: 'v3_direct_content_example.txt',
+      // You can optionally specify feeRate, network, useTypeID
+      // feeRate: 3000 
+    };
+    
+    console.log(`Publishing direct content to CKBFS v3: "${content}"`);
+    const txHash = await ckbfs.publishContentV3(content, options);
+    
+    console.log(`Direct content published successfully to CKBFS v3!`);
+    console.log(`Transaction Hash: ${txHash}`);
+    console.log(`View at: https://pudge.explorer.nervos.org/transaction/${txHash}`);
+    
+    return txHash;
+  } catch (error) {
+    console.error('Error publishing direct content to v3:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example of publishing content using the simplified V3 API
+ */
+async function publishContentV3WithSimplifiedAPI() {
+  try {
+    // Get address info
+    const address = await ckbfs.getAddress();
+    console.log(`Using address for v3 content publish: ${address.toString()}`);
+    
+    // Define content for publishing
+    const content = "Hello CKBFS v3! This example shows the simplified publishing API.";
+    
+    // Send the transaction using the public interface
+    console.log('\n=== SENDING TRANSACTION ===');
+    const txHash = await ckbfs.publishContent(content, {
+      contentType: 'text/plain',
+      filename: 'v3_tx_example.txt',
+    });
+    
+    console.log(`Transaction sent successfully!`);
+    console.log(`Transaction Hash: ${txHash}`);
+    console.log(`View at: https://pudge.explorer.nervos.org/transaction/${txHash}`);
+    
+    return txHash;
+  } catch (error) {
+    console.error('Error in detailed v3 publish example:', error);
+    throw error;
+  }
+}
+
+/**
+ * Main function to run the v3 publish example
+ */
+async function main() {
+  console.log('Running CKBFS v3 publishing example...');
+  console.log('=====================================');
+  console.log(`Using CKBFS protocol version: ${ProtocolVersion.V3}`);
+  console.log('Key v3 features:');
+  console.log('- Witnesses-based storage (lower costs)');
+  console.log('- No backlinks in cell data');
+  console.log('- Structured witnesses with chaining');
+  console.log('=====================================');
+  
+  try {
+    // Run the simplified V3 API example
+    await publishContentV3WithSimplifiedAPI();
+    console.log('=====================================');
+    
+    // Uncomment to also test the regular publish method:
+    // await publishContentV3Example();
+    // console.log('=====================================');
+    
+    // Uncomment to also test file publishing:
+    // await publishFileV3Example();
+    console.log('CKBFS v3 example completed successfully!');
+    process.exit(0);
+  } catch (error) {
+    console.error('CKBFS v3 example failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the example if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/publish.ts

@@ -28,12 +28,12 @@ async function publishExample() {
     console.log('Using CKBFS config:', config);
     
     // Publish a text file to CKBFS
-    const filePath = './code.png';
+    const filePath = './examples/example.txt';
     
     // You can provide additional options
     const options = {
-      contentType: 'image/png',
-      filename: 'code.png',
+      contentType: 'plain/text',
+      filename: 'example.txt',
       // Specify capacity if needed (default is 200 CKB)
       // capacity: 250n * 100000000n
     };
@@ -95,7 +95,7 @@ async function main() {
   try {
     await publishExample();
     console.log('----------------------------------');
-    await publishContentExample();
+    //await publishContentExample();
     console.log('Example completed successfully!');
     process.exit(0);
   } catch (error) {

package/examples/retrieve-v3.ts

@@ -0,0 +1,222 @@
+import { 
+  getFileContentFromChainByIdentifierV3, 
+  saveFileFromChainByIdentifierV3,
+  ProtocolVersion,
+} from '../src/index';
+import { ClientPublicTestnet } from '@ckb-ccc/core';
+
+// Initialize the CKB client
+const client = new ClientPublicTestnet(); // Use testnet
+
+/**
+ * Example of retrieving a file from CKBFS v3 using TypeID
+ */
+async function retrieveFileByTypeIdV3Example() {
+  try {
+    // Example TypeID (replace with actual TypeID from a v3 published file)
+    const typeId = "0xc387111856be837b1f358d49a9d7e4461dc18244c2b7b59f9012617b1c09d7be";
+    
+    console.log(`Retrieving CKBFS v3 file by TypeID: ${typeId}`);
+    
+    const fileData = await getFileContentFromChainByIdentifierV3(
+      client,
+      typeId,
+      {
+        network: "testnet",
+        version: ProtocolVersion.V3,
+        useTypeID: false
+      }
+    );
+
+    if (!fileData) {
+      console.log('File not found or failed to retrieve');
+      return;
+    }
+
+    console.log('CKBFS v3 file retrieved successfully!');
+    console.log(`Filename: ${fileData.filename}`);
+    console.log(`Content type: ${fileData.contentType}`);
+    console.log(`Size: ${fileData.size} bytes`);
+    console.log(`Checksum: ${fileData.checksum}`);
+    
+    // Enhanced content preview to better understand the file content
+    const contentText = fileData.content.toString();
+    console.log(`Full content length: ${contentText.length} characters`);
+    
+    if (contentText.length <= 200) {
+      console.log(`Full content: "${contentText}"`);
+    } else {
+      console.log(`Content preview (first 100 chars): "${contentText.slice(0, 100)}"`);
+      console.log(`Content preview (last 100 chars): "${contentText.slice(-100)}"`);
+    }
+    
+    // Check if content looks like it might be truncated or only showing appends
+    const lines = contentText.split('\n');
+    console.log(`Content has ${lines.length} lines`);
+    if (lines.length > 3) {
+      console.log(`First line: "${lines[0]}"`);
+      console.log(`Last line: "${lines[lines.length - 1]}"`);
+    }
+    
+    return fileData;
+  } catch (error) {
+    console.error('Error retrieving file by TypeID from v3:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example of retrieving and saving a file from CKBFS v3
+ */
+async function retrieveAndSaveFileV3Example() {
+  try {
+    // Example TypeID (replace with actual TypeID from a v3 published file)
+    const typeId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+    
+    console.log(`Retrieving and saving CKBFS v3 file by TypeID: ${typeId}`);
+    
+    const savedPath = await saveFileFromChainByIdentifierV3(
+      client,
+      typeId,
+      './retrieved_v3_file.txt', // Optional output path
+      {
+        network: "testnet",
+        version: ProtocolVersion.V3,
+        useTypeID: false
+      }
+    );
+
+    if (!savedPath) {
+      console.log('File not found or failed to save');
+      return;
+    }
+
+    console.log(`CKBFS v3 file saved successfully to: ${savedPath}`);
+    
+    return savedPath;
+  } catch (error) {
+    console.error('Error retrieving and saving file from v3:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example of retrieving a file using CKBFS URI format
+ */
+async function retrieveFileByURIV3Example() {
+  try {
+    // Example CKBFS URI (replace with actual URI)
+    const ckbfsUri = "ckbfs://c387111856be837b1f358d49a9d7e4461dc18244c2b7b59f9012617b1c09d7be";
+    
+    console.log(`Retrieving CKBFS v3 file by URI: ${ckbfsUri}`);
+    
+    const fileData = await getFileContentFromChainByIdentifierV3(
+      client,
+      ckbfsUri,
+      {
+        network: "testnet",
+        version: ProtocolVersion.V3,
+        useTypeID: false
+      }
+    );
+
+    if (!fileData) {
+      console.log('File not found or failed to retrieve');
+      return;
+    }
+
+    console.log('CKBFS v3 file retrieved successfully using URI!');
+    console.log(`Filename: ${fileData.filename}`);
+    console.log(`Content type: ${fileData.contentType}`);
+    console.log(`Size: ${fileData.size} bytes`);
+    console.log(`Checksum: ${fileData.checksum}`);
+    console.log(`Content: ${fileData.content}`);
+    
+    return fileData;
+  } catch (error) {
+    console.error('Error retrieving file by URI from v3:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example of retrieving a file using OutPoint format
+ */
+async function retrieveFileByOutPointV3Example() {
+  try {
+    // Example OutPoint URI (replace with actual transaction hash and index)
+    const outPointUri = "ckbfs://1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefi0";
+    
+    console.log(`Retrieving CKBFS v3 file by OutPoint: ${outPointUri}`);
+    
+    const fileData = await getFileContentFromChainByIdentifierV3(
+      client,
+      outPointUri,
+      {
+        network: "testnet",
+        version: ProtocolVersion.V3,
+        useTypeID: false
+      }
+    );
+
+    if (!fileData) {
+      console.log('File not found or failed to retrieve');
+      return;
+    }
+
+    console.log('CKBFS v3 file retrieved successfully using OutPoint!');
+    console.log(`Filename: ${fileData.filename}`);
+    console.log(`Content type: ${fileData.contentType}`);
+    console.log(`Size: ${fileData.size} bytes`);
+    console.log(`Checksum: ${fileData.checksum}`);
+    
+    return fileData;
+  } catch (error) {
+    console.error('Error retrieving file by OutPoint from v3:', error);
+    throw error;
+  }
+}
+
+/**
+ * Main function to run the v3 retrieval examples
+ */
+async function main() {
+  console.log('Running CKBFS v3 file retrieval examples...');
+  console.log('============================================');
+  console.log(`Using CKBFS protocol version: ${ProtocolVersion.V3}`);
+  console.log('Key v3 retrieval features:');
+  console.log('- Follows witness-based backlink chain');
+  console.log('- Reconstructs file from witness content');
+  console.log('- Supports TypeID, URI, and OutPoint formats');
+  console.log('============================================');
+  
+  try {
+    console.log('Note: These examples require existing CKBFS v3 files.');
+    console.log('Please run publish-v3.ts first to create v3 files,');
+    console.log('then update the identifiers in this example.');
+    console.log('');
+    console.log('Supported identifier formats:');
+    console.log('- TypeID: 0x1234...abcdef');
+    console.log('- CKBFS URI: ckbfs://1234...abcdef');
+    console.log('- OutPoint URI: ckbfs://1234...abcdefi0');
+    console.log('');
+    
+    // Uncomment to test different retrieval methods:
+    await retrieveFileByTypeIdV3Example();
+    // await retrieveAndSaveFileV3Example();
+    await retrieveFileByURIV3Example();
+    // await retrieveFileByOutPointV3Example();
+    
+    console.log('Retrieval example structure completed successfully!');
+    console.log('Update the identifiers and uncomment methods to test.');
+    process.exit(0);
+  } catch (error) {
+    console.error('CKBFS v3 retrieval examples failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the example if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}