@ckbfs/api 1.2.3 → 1.2.5

package/dist/utils/molecule.d.ts

@@ -1,4 +1,5 @@
 import { molecule, number } from "@ckb-lumos/codec";
+import { ProtocolVersionType } from "./constants";
 /**
  * Molecule definitions for CKBFS data structures.
  */
@@ -70,8 +71,8 @@ export type CKBFSDataType = {
     backLinks: BackLinkType[];
 };
 export declare const CKBFSData: {
-    pack: (data: CKBFSDataType, version?: string) => Uint8Array;
-    unpack: (buf: Uint8Array, version?: string) => CKBFSDataType;
+    pack: (data: CKBFSDataType, version?: ProtocolVersionType) => Uint8Array;
+    unpack: (buf: Uint8Array, version?: ProtocolVersionType) => CKBFSDataType;
 };
 export declare const CKBFS_HEADER: Uint8Array<ArrayBuffer>;
 export declare const CKBFS_HEADER_STRING = "CKBFS";

package/dist/utils/molecule.js

@@ -45,13 +45,13 @@ exports.CKBFSDataV2 = codec_1.molecule.table({
 function getIndexes(data) {
     if (data.indexes)
         return data.indexes;
-    if (typeof data.index === 'number')
+    if (typeof data.index === "number")
         return [data.index];
     return [];
 }
 // Helper function to get single index from data
 function getIndex(data) {
-    if (typeof data.index === 'number')
+    if (typeof data.index === "number")
         return data.index;
     if (data.indexes && data.indexes.length > 0)
         return data.indexes[0];
@@ -59,7 +59,7 @@ function getIndex(data) {
 }
 // Helper function to safely get either index or indexes from BackLinkType for V1
 function getBackLinkIndex(bl) {
-    if (typeof bl.index === 'number') {
+    if (typeof bl.index === "number") {
         return bl.index;
     }
     if (Array.isArray(bl.indexes) && bl.indexes.length > 0) {
@@ -72,7 +72,7 @@ function getBackLinkIndexes(bl) {
     if (Array.isArray(bl.indexes)) {
         return bl.indexes;
     }
-    if (typeof bl.index === 'number') {
+    if (typeof bl.index === "number") {
         return [bl.index];
     }
     return [0];
@@ -85,11 +85,11 @@ exports.CKBFSData = {
             return exports.CKBFSDataV1.pack({
                 index: getIndex(data),
                 checksum: data.checksum,
-                contentType: core_1.ccc.bytesFrom(data.contentType, 'utf8'),
-                filename: core_1.ccc.bytesFrom(data.filename, 'utf8'),
-                backLinks: data.backLinks.map(bl => {
+                contentType: core_1.ccc.bytesFrom(data.contentType, "utf8"),
+                filename: core_1.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'
+                    const txHash = typeof bl.txHash === "string"
                         ? core_1.ccc.bytesFrom(bl.txHash)
                         : bl.txHash;
                     return {
@@ -105,13 +105,11 @@ exports.CKBFSData = {
             return exports.CKBFSDataV2.pack({
                 indexes: getIndexes(data),
                 checksum: data.checksum,
-                contentType: core_1.ccc.bytesFrom(data.contentType, 'utf8'),
-                filename: core_1.ccc.bytesFrom(data.filename, 'utf8'),
-                backLinks: data.backLinks.map(bl => {
+                contentType: core_1.ccc.bytesFrom(data.contentType, "utf8"),
+                filename: core_1.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;
+                    const txHash = typeof bl.txHash === "string" ? bl.txHash : bl.txHash;
                     return {
                         indexes: getBackLinkIndexes(bl),
                         checksum: bl.checksum,
@@ -128,9 +126,9 @@ exports.CKBFSData = {
                 return {
                     index: unpacked.index,
                     checksum: unpacked.checksum,
-                    contentType: core_1.ccc.bytesTo(unpacked.contentType, 'utf8'),
-                    filename: core_1.ccc.bytesTo(unpacked.filename, 'utf8'),
-                    backLinks: unpacked.backLinks.map(bl => ({
+                    contentType: core_1.ccc.bytesTo(unpacked.contentType, "utf8"),
+                    filename: core_1.ccc.bytesTo(unpacked.filename, "utf8"),
+                    backLinks: unpacked.backLinks.map((bl) => ({
                         index: bl.index,
                         checksum: bl.checksum,
                         txHash: bl.txHash,
@@ -143,9 +141,9 @@ exports.CKBFSData = {
                 return {
                     indexes: unpacked.indexes,
                     checksum: unpacked.checksum,
-                    contentType: core_1.ccc.bytesTo(unpacked.contentType, 'utf8'),
-                    filename: core_1.ccc.bytesTo(unpacked.filename, 'utf8'),
-                    backLinks: unpacked.backLinks.map(bl => ({
+                    contentType: core_1.ccc.bytesTo(unpacked.contentType, "utf8"),
+                    filename: core_1.ccc.bytesTo(unpacked.filename, "utf8"),
+                    backLinks: unpacked.backLinks.map((bl) => ({
                         indexes: bl.indexes,
                         checksum: bl.checksum,
                         txHash: bl.txHash,
@@ -154,11 +152,11 @@ exports.CKBFSData = {
             }
         }
         catch (error) {
-            console.error('Error unpacking CKBFSData:', error);
-            throw new Error('Failed to unpack CKBFSData: ' + error);
+            console.error("Error unpacking CKBFSData:", error);
+            throw new Error("Failed to unpack CKBFSData: " + error);
         }
-    }
+    },
 };
 // Constants for CKBFS protocol
-exports.CKBFS_HEADER = new Uint8Array([0x43, 0x4B, 0x42, 0x46, 0x53]); // "CKBFS" in ASCII
+exports.CKBFS_HEADER = new Uint8Array([0x43, 0x4b, 0x42, 0x46, 0x53]); // "CKBFS" in ASCII
 exports.CKBFS_HEADER_STRING = "CKBFS";

package/dist/utils/transaction.d.ts

@@ -1,6 +1,6 @@
 import { ccc, Transaction, Script, Signer } from "@ckb-ccc/core";
-import { CKBFSDataType } from './molecule';
-import { NetworkType } from './constants';
+import { CKBFSDataType } from "./molecule";
+import { NetworkType, ProtocolVersionType } from "./constants";
 /**
  * Utility functions for CKB transaction creation and handling
  */
@@ -13,7 +13,7 @@ export interface CKBFSCellOptions {
     capacity?: bigint;
     lock: Script;
     network?: NetworkType;
-    version?: string;
+    version?: ProtocolVersionType;
     useTypeID?: boolean;
 }
 /**
@@ -40,8 +40,14 @@ export interface AppendOptions {
     contentChunks: Uint8Array[];
     feeRate?: number;
     network?: NetworkType;
-    version?: string;
+    version?: ProtocolVersionType;
 }
+/**
+ * Ensures a string is prefixed with '0x'
+ * @param value The string to ensure is hex prefixed
+ * @returns A hex prefixed string
+ */
+export declare function ensureHexPrefix(value: string): `0x${string}`;
 /**
  * Creates a CKBFS cell
  * @param options Options for creating the CKBFS cell

package/dist/utils/transaction.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureHexPrefix = ensureHexPrefix;
 exports.createCKBFSCell = createCKBFSCell;
 exports.createPublishTransaction = createPublishTransaction;
 exports.createAppendTransaction = createAppendTransaction;
@@ -16,7 +17,7 @@ const constants_1 = require("./constants");
  * @returns A hex prefixed string
  */
 function ensureHexPrefix(value) {
-    if (value.startsWith('0x')) {
+    if (value.startsWith("0x")) {
         return value;
     }
     return `0x${value}`;
@@ -27,7 +28,7 @@ function ensureHexPrefix(value) {
  * @returns The created cell output
  */
 function createCKBFSCell(options) {
-    const { contentType, filename, capacity, lock, network = constants_1.DEFAULT_NETWORK, version = constants_1.DEFAULT_VERSION, useTypeID = false } = options;
+    const { contentType, filename, capacity, lock, network = constants_1.DEFAULT_NETWORK, version = constants_1.DEFAULT_VERSION, useTypeID = false, } = options;
     // Get CKBFS script config
     const config = (0, constants_1.getCKBFSScriptConfig)(network, version, useTypeID);
     // Create pre CKBFS type script
@@ -46,7 +47,7 @@ function createCKBFSCell(options) {
  * @returns Promise resolving to the created transaction
  */
 async function createPublishTransaction(signer, options) {
-    const { contentChunks, contentType, filename, lock, capacity, 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);
@@ -87,7 +88,10 @@ 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;
+    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: [
@@ -98,16 +102,14 @@ async function createPublishTransaction(signer, options) {
                 network,
                 version,
                 useTypeID,
-                capacity: ckbfsCellSize || capacity
-            })
+                capacity: ckbfsCellSize || capacity,
+            }),
         ],
         witnesses: [
             [], // Empty secp witness for signing
-            ...ckbfsWitnesses.map(w => `0x${Buffer.from(w).toString('hex')}`),
+            ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
         ],
-        outputsData: [
-            outputData,
-        ]
+        outputsData: [outputData],
     });
     // Add the CKBFS dep group cell dependency
     preTx.addCellDeps({
@@ -115,7 +117,7 @@ async function createPublishTransaction(signer, options) {
             txHash: ensureHexPrefix(config.depTxHash),
             index: config.depIndex || 0,
         },
-        depType: "depGroup"
+        depType: "depGroup",
     });
     // Get the recommended address to ensure lock script cell deps are included
     const address = await signer.getRecommendedAddressObj();
@@ -132,7 +134,7 @@ async function createPublishTransaction(signer, options) {
         cellDeps: preTx.cellDeps,
         witnesses: [
             [], // Reset first witness for signing
-            ...preTx.witnesses.slice(1)
+            ...preTx.witnesses.slice(1),
         ],
         outputsData: preTx.outputsData,
         inputs: preTx.inputs,
@@ -142,8 +144,8 @@ async function createPublishTransaction(signer, options) {
                 type: ckbfsTypeScript,
                 capacity: preTx.outputs[0].capacity,
             },
-            ...preTx.outputs.slice(1) // Include rest of outputs (e.g., change)
-        ]
+            ...preTx.outputs.slice(1), // Include rest of outputs (e.g., change)
+        ],
     });
     return tx;
 }
@@ -154,7 +156,7 @@ async function createPublishTransaction(signer, options) {
  * @returns Promise resolving to the created transaction
  */
 async function createAppendTransaction(signer, options) {
-    const { ckbfsCell, contentChunks, feeRate, network = constants_1.DEFAULT_NETWORK, version = constants_1.DEFAULT_VERSION } = options;
+    const { ckbfsCell, contentChunks, feeRate, network = constants_1.DEFAULT_NETWORK, version = constants_1.DEFAULT_VERSION, } = options;
     const { outPoint, data, type, lock, capacity } = ckbfsCell;
     // Get CKBFS script config early to use version info
     const config = (0, constants_1.getCKBFSScriptConfig)(network, version);
@@ -168,10 +170,12 @@ async function createAppendTransaction(signer, options) {
     // cumulative nature as required by Rule 11 in the RFC
     const contentChecksum = await (0, checksum_1.updateChecksum)(data.checksum, combinedContent);
     console.log(`Updated checksum from ${data.checksum} to ${contentChecksum} for appended content`);
+    // Get the recommended address to ensure lock script cell deps are included
+    const address = await signer.getRecommendedAddressObj();
     // 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;
+    // CKBFS data starts at index 1 if signer's lock script is the same as ckbfs's lock script
+    // else CKBFS data starts at index 0
+    const contentStartIndex = address.script.hash() === lock.hash() ? 1 : 0;
     const witnessIndices = Array.from({ length: contentChunks.length }, (_, i) => contentStartIndex + i);
     // Create backlink for the current state based on version
     let newBackLink;
@@ -180,7 +184,8 @@ async function createAppendTransaction(signer, options) {
         newBackLink = {
             // 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),
+            index: data.index ||
+                (data.indexes && data.indexes.length > 0 ? data.indexes[0] : 0),
             checksum: data.checksum,
             txHash: outPoint.txHash,
         };
@@ -226,12 +231,13 @@ async function createAppendTransaction(signer, options) {
     // Get sizes and calculate capacity requirements
     const newDataSize = outputData.length;
     // Calculate the required capacity for the output cell
-    // This accounts for: 
+    // 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;
+    const ckbfsCellSize = BigInt(outputData.length + type.occupiedSize + lock.occupiedSize + 8) *
+        100000000n;
     console.log(`Original capacity: ${capacity}, Calculated size: ${ckbfsCellSize}, Data size: ${outputData.length}`);
     // Use the maximum value between calculated size and original capacity
     // to ensure we have enough capacity but don't decrease capacity unnecessarily
@@ -245,18 +251,16 @@ async function createAppendTransaction(signer, options) {
                     index: outPoint.index,
                 },
                 since: "0x0",
-            }
+            },
         ],
         outputs: [
             {
                 lock,
                 type,
                 capacity: outputCapacity,
-            }
+            },
         ],
-        outputsData: [
-            outputData,
-        ]
+        outputsData: [outputData],
     });
     // Add the CKBFS dep group cell dependency
     tx.addCellDeps({
@@ -264,10 +268,8 @@ async function createAppendTransaction(signer, options) {
             txHash: ensureHexPrefix(config.depTxHash),
             index: config.depIndex || 0,
         },
-        depType: "depGroup"
+        depType: "depGroup",
     });
-    // Get the recommended address to ensure lock script cell deps are included
-    const address = await signer.getRecommendedAddressObj();
     const inputsBefore = tx.inputs.length;
     // If we need more capacity than the original cell had, add additional inputs
     if (outputCapacity > capacity) {
@@ -278,14 +280,14 @@ async function createAppendTransaction(signer, options) {
     const witnesses = [];
     // add empty witness for signer if ckbfs's lock is the same as signer's lock
     if (address.script.hash() === lock.hash()) {
-        witnesses.push('0x');
+        witnesses.push("0x");
     }
     // add ckbfs witnesses
-    witnesses.push(...ckbfsWitnesses.map(w => `0x${Buffer.from(w).toString('hex')}`));
+    witnesses.push(...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`));
     // Add empty witnesses for signer's input
     // This is to ensure that the transaction is valid and can be signed
     for (let i = inputsBefore; i < tx.inputs.length; i++) {
-        witnesses.push('0x');
+        witnesses.push("0x");
     }
     tx.witnesses = witnesses;
     // Complete fee

package/examples/example.txt

@@ -0,0 +1 @@
+Hello CKBFS!

package/examples/identifier-test.ts

@@ -0,0 +1,178 @@
+import {
+  parseIdentifier,
+  IdentifierType,
+  getFileContentFromChainByIdentifier,
+  saveFileFromChainByIdentifier,
+  decodeFileFromChainByIdentifier,
+} from '../src/index';
+
+/**
+ * Simple test script to verify generic identifier functionality
+ * This script demonstrates parsing and using different identifier formats
+ */
+
+// Test identifiers
+const testIdentifiers = [
+  // Type 1: Pure TypeID hex string
+  '0xbce89252cece632ef819943bed9cd0e2576f8ce26f9f02075b621b1c9a28056a',
+
+  // Type 2: CKBFS URI with TypeID
+  'ckbfs://bce89252cece632ef819943bed9cd0e2576f8ce26f9f02075b621b1c9a28056a',
+
+  // Type 3: CKBFS URI with transaction hash and index
+  'ckbfs://431c9d668c1815d26eb4f7ac6256eb350ab351474daea8d588400146ab228780i0',
+
+  // Invalid formats for testing
+  'invalid-identifier',
+  'ckbfs://invalid',
+  '0xinvalid'
+];
+
+/**
+ * Test identifier parsing functionality
+ */
+function testIdentifierParsing() {
+  console.log('=== Testing Identifier Parsing ===');
+
+  testIdentifiers.forEach((identifier, index) => {
+    console.log(`\nTest ${index + 1}: ${identifier}`);
+
+    try {
+      const parsed = parseIdentifier(identifier);
+      console.log(`  Type: ${parsed.type}`);
+
+      if (parsed.type === IdentifierType.TypeID) {
+        console.log(`  TypeID: ${parsed.typeId}`);
+      } else if (parsed.type === IdentifierType.OutPoint) {
+        console.log(`  TxHash: ${parsed.txHash}`);
+        console.log(`  Index: ${parsed.index}`);
+      } else {
+        console.log(`  Status: Invalid identifier format`);
+      }
+
+      console.log(`  Original: ${parsed.original}`);
+    } catch (error) {
+      console.error(`  Error: ${error}`);
+    }
+  });
+}
+
+/**
+ * Test file retrieval with different identifier formats
+ * Note: This requires a real CKB client and valid identifiers
+ */
+async function testFileRetrieval() {
+  console.log('\n=== Testing File Retrieval ===');
+  console.log('Note: This test requires valid identifiers and network connection');
+
+  // This is a mock test - in real usage you would:
+  // 1. Initialize a CKB client
+  // 2. Use real identifiers from actual transactions
+  // 3. Test the retrieval functions
+
+  const mockClient = null; // Replace with real client
+  const validIdentifier = testIdentifiers[0]; // Use a real identifier
+
+  if (!mockClient) {
+    console.log('Skipping file retrieval test - no client configured');
+    return;
+  }
+
+  try {
+    console.log(`Testing retrieval with: ${validIdentifier}`);
+
+    // Test generic identifier function
+    const fileData = await getFileContentFromChainByIdentifier(
+      mockClient,
+      validIdentifier,
+      {
+        network: 'testnet',
+        version: '20241025.db973a8e8032',
+        useTypeID: false
+      }
+    );
+
+    if (fileData) {
+      console.log(`✓ Retrieved: ${fileData.filename}`);
+      console.log(`  Size: ${fileData.size} bytes`);
+      console.log(`  Content Type: ${fileData.contentType}`);
+      console.log(`  Parsed ID Type: ${fileData.parsedId.type}`);
+    } else {
+      console.log('✗ File not found');
+    }
+  } catch (error) {
+    console.error(`✗ Error: ${error}`);
+  }
+}
+
+/**
+ * Demonstrate identifier format conversion
+ */
+function demonstrateFormatConversion() {
+  console.log('\n=== Demonstrating Format Conversion ===');
+
+  const typeId = 'bce89252cece632ef819943bed9cd0e2576f8ce26f9f02075b621b1c9a28056a';
+  const txHash = '431c9d668c1815d26eb4f7ac6256eb350ab351474daea8d588400146ab228780';
+  const index = 0;
+
+  console.log('Creating different formats from the same data:');
+  console.log(`1. TypeID hex: 0x${typeId}`);
+  console.log(`2. CKBFS TypeID URI: ckbfs://${typeId}`);
+  console.log(`3. CKBFS OutPoint URI: ckbfs://${txHash}i${index}`);
+
+  // Parse each format
+  const formats = [
+    `0x${typeId}`,
+    `ckbfs://${typeId}`,
+    `ckbfs://${txHash}i${index}`
+  ];
+
+  formats.forEach((format, index) => {
+    const parsed = parseIdentifier(format);
+    console.log(`\nFormat ${index + 1} parsed as: ${parsed.type}`);
+  });
+}
+
+/**
+ * Main test function
+ */
+async function main() {
+  console.log('CKBFS Generic Identifier Test');
+  console.log('=============================');
+
+  try {
+    // Test identifier parsing
+    testIdentifierParsing();
+
+    // Demonstrate format conversion
+    demonstrateFormatConversion();
+
+    // Test file retrieval (requires real setup)
+    await testFileRetrieval();
+
+    console.log('\n=== Test Summary ===');
+    console.log('✓ Identifier parsing test completed');
+    console.log('✓ Format conversion demonstration completed');
+    console.log('ℹ File retrieval test requires real network setup');
+
+    console.log('\nTo test with real data:');
+    console.log('1. Set up a CKB client (testnet or mainnet)');
+    console.log('2. Replace mock identifiers with real ones');
+    console.log('3. Run the file retrieval tests');
+
+  } catch (error) {
+    console.error('Test failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+export {
+  testIdentifierParsing,
+  testFileRetrieval,
+  demonstrateFormatConversion
+};

package/examples/index.ts

@@ -1,43 +1,55 @@
-import { CKBFS, NetworkType, ProtocolVersion } from '../src/index';
+import { CKBFS, NetworkType, ProtocolVersion } from "../src/index";
 
 /**
  * Main CKBFS Examples
- * 
+ *
  * This file serves as the entry point for running all CKBFS SDK examples.
- * 
+ *
  * To run all examples:
  *   npm run example
- * 
+ *
  * To run specific examples:
  *   npm run example:publish
  *   npm run example:append -- --txhash=0x123456...
  */
 
-console.log('CKBFS SDK Examples');
-console.log('=================');
-console.log('');
-console.log('Available examples:');
-console.log('1. Publish File Example - npm run example:publish');
-console.log('2. Append File Example  - npm run example:append -- --txhash=0x123456...');
-console.log('');
-console.log('Run all examples with: npm run example');
-console.log('');
-console.log('Note: For the append example, you need to provide a transaction hash');
-console.log('of a previously published file using the --txhash parameter or');
-console.log('by setting the PUBLISH_TX_HASH environment variable.');
-console.log('');
+console.log("CKBFS SDK Examples");
+console.log("=================");
+console.log("");
+console.log("Available examples:");
+console.log("1. Publish File Example - npm run example:publish");
+console.log(
+  "2. Append File Example  - npm run example:append -- --txhash=0x123456...",
+);
+console.log(
+  "3. Retrieve File Example - npm run example:retrieve -- --txhash=0x123456...",
+);
+console.log("");
+console.log("Run all examples with: npm run example");
+console.log("");
+console.log(
+  "Note: For the append and retrieve examples, you need to provide a transaction hash",
+);
+console.log("of a previously published file using the --txhash parameter or");
+console.log(
+  "by setting the PUBLISH_TX_HASH/TARGET_TX_HASH environment variable.",
+);
+console.log("");
 
 // Check if we should run all examples
-const runAll = process.argv.includes('--all');
+const runAll = process.argv.includes("--all");
 
 if (runAll) {
-  console.log('Running all examples is not recommended. Please run specific examples instead.');
-  console.log('');
-  console.log('For example:');
-  console.log('  npm run example:publish');
-  console.log('  npm run example:append -- --txhash=0x123456...');
+  console.log(
+    "Running all examples is not recommended. Please run specific examples instead.",
+  );
+  console.log("");
+  console.log("For example:");
+  console.log("  npm run example:publish");
+  console.log("  npm run example:append -- --txhash=0x123456...");
+  console.log("  npm run example:retrieve -- --txhash=0x123456...");
   process.exit(1);
 }
 
 // Default behavior - just show instructions
-console.log('For more information, see the README.md file.'); 
+console.log("For more information, see the README.md file.");