@ckbfs/api 1.2.3 → 1.2.5

package/src/utils/transaction.ts

@@ -1,14 +1,15 @@
 import { ccc, Transaction, Script, Signer } from "@ckb-ccc/core";
-import { calculateChecksum, updateChecksum } from './checksum';
-import { CKBFSData, BackLinkType, CKBFSDataType } from './molecule';
-import { createChunkedCKBFSWitnesses } from './witness';
-import { 
-  getCKBFSScriptConfig, 
-  NetworkType, 
-  ProtocolVersion, 
-  DEFAULT_NETWORK, 
-  DEFAULT_VERSION 
-} from './constants';
+import { calculateChecksum, updateChecksum } from "./checksum";
+import { CKBFSData, BackLinkType, CKBFSDataType } from "./molecule";
+import { createChunkedCKBFSWitnesses } from "./witness";
+import {
+  getCKBFSScriptConfig,
+  NetworkType,
+  ProtocolVersion,
+  ProtocolVersionType,
+  DEFAULT_NETWORK,
+  DEFAULT_VERSION,
+} from "./constants";
 
 /**
  * Utility functions for CKB transaction creation and handling
@@ -23,7 +24,7 @@ export interface CKBFSCellOptions {
   capacity?: bigint;
   lock: Script;
   network?: NetworkType;
-  version?: string;
+  version?: ProtocolVersionType;
   useTypeID?: boolean;
 }
 
@@ -49,7 +50,7 @@ export interface AppendOptions {
   contentChunks: Uint8Array[];
   feeRate?: number;
   network?: NetworkType;
-  version?: string;
+  version?: ProtocolVersionType;
 }
 
 /**
@@ -57,8 +58,8 @@ export interface AppendOptions {
  * @param value The string to ensure is hex prefixed
  * @returns A hex prefixed string
  */
-function ensureHexPrefix(value: string): `0x${string}` {
-  if (value.startsWith('0x')) {
+export function ensureHexPrefix(value: string): `0x${string}` {
+  if (value.startsWith("0x")) {
     return value as `0x${string}`;
   }
   return `0x${value}` as `0x${string}`;
@@ -70,26 +71,26 @@ function ensureHexPrefix(value: string): `0x${string}` {
  * @returns The created cell output
  */
 export function createCKBFSCell(options: CKBFSCellOptions) {
-  const { 
-    contentType, 
-    filename, 
-    capacity, 
-    lock, 
-    network = DEFAULT_NETWORK, 
+  const {
+    contentType,
+    filename,
+    capacity,
+    lock,
+    network = DEFAULT_NETWORK,
     version = DEFAULT_VERSION,
-    useTypeID = false
+    useTypeID = false,
   } = options;
-  
+
   // Get CKBFS script config
   const config = getCKBFSScriptConfig(network, version, useTypeID);
-  
+
   // Create pre CKBFS type script
   const preCkbfsTypeScript = new Script(
     ensureHexPrefix(config.codeHash),
     config.hashType as any,
-    "0x0000000000000000000000000000000000000000000000000000000000000000"
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
   );
-  
+
   // Return the cell output
   return {
     lock,
@@ -105,130 +106,140 @@ export function createCKBFSCell(options: CKBFSCellOptions) {
  * @returns Promise resolving to the created transaction
  */
 export async function createPublishTransaction(
-  signer: Signer, 
-  options: PublishOptions
+  signer: Signer,
+  options: PublishOptions,
 ): Promise<Transaction> {
-  const { 
-    contentChunks, 
-    contentType, 
-    filename, 
-    lock, 
+  const {
+    contentChunks,
+    contentType,
+    filename,
+    lock,
     capacity,
     feeRate,
     network = DEFAULT_NETWORK,
     version = DEFAULT_VERSION,
-    useTypeID = false
+    useTypeID = false,
   } = options;
-  
+
   // Calculate checksum for the combined content
   const textEncoder = new TextEncoder();
   const combinedContent = Buffer.concat(contentChunks);
   const checksum = await calculateChecksum(combinedContent);
-  
+
   // 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
   // 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
+    { length: contentChunks.length },
+    (_, i) => contentStartIndex + i,
   );
-  
+
   // 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: contentType,
-      filename: filename,
-      backLinks: [],
-    }, version);
+    outputData = CKBFSData.pack(
+      {
+        index: contentStartIndex,
+        checksum,
+        contentType: contentType,
+        filename: 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,
-      filename,
-      backLinks: [],
-    }, version);
+    outputData = CKBFSData.pack(
+      {
+        indexes: witnessIndices,
+        checksum,
+        contentType,
+        filename,
+        backLinks: [],
+      },
+      version,
+    );
   }
-  
+
   // Get CKBFS script config
   const config = getCKBFSScriptConfig(network, version, useTypeID);
-  
+
   const preCkbfsTypeScript = new Script(
     ensureHexPrefix(config.codeHash),
     config.hashType as any,
-    "0x0000000000000000000000000000000000000000000000000000000000000000"
+    "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 = Transaction.from({
     outputs: [
-      createCKBFSCell({ 
-        contentType, 
-        filename, 
-        lock, 
-        network, 
+      createCKBFSCell({
+        contentType,
+        filename,
+        lock,
+        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({
     outPoint: {
       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();
-  
+
   // Complete inputs by capacity
   await preTx.completeInputsByCapacity(signer);
-  
+
   // Complete fee change to lock
   await preTx.completeFeeChangeToLock(signer, lock, feeRate || 2000);
-  
+
   // Create type ID args
   const args = ccc.hashTypeId(preTx.inputs[0], 0x0);
-  
+
   // Create CKBFS type script with type ID
   const ckbfsTypeScript = new Script(
     ensureHexPrefix(config.codeHash),
     config.hashType as any,
-    args
+    args,
   );
-  
+
   // Create final transaction with same cell deps as preTx
   const tx = Transaction.from({
     cellDeps: preTx.cellDeps,
     witnesses: [
       [], // Reset first witness for signing
-      ...preTx.witnesses.slice(1)
+      ...preTx.witnesses.slice(1),
     ],
     outputsData: preTx.outputsData,
     inputs: preTx.inputs,
@@ -238,10 +249,10 @@ export async function createPublishTransaction(
         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;
 }
 
@@ -252,52 +263,59 @@ export async function createPublishTransaction(
  * @returns Promise resolving to the created transaction
  */
 export async function createAppendTransaction(
-  signer: Signer, 
-  options: AppendOptions
+  signer: Signer,
+  options: AppendOptions,
 ): Promise<Transaction> {
-  const { 
-    ckbfsCell, 
-    contentChunks, 
+  const {
+    ckbfsCell,
+    contentChunks,
     feeRate,
     network = DEFAULT_NETWORK,
-    version = DEFAULT_VERSION 
+    version = DEFAULT_VERSION,
   } = options;
   const { outPoint, data, type, lock, capacity } = ckbfsCell;
-  
+
   // Get CKBFS script config early to use version info
   const config = getCKBFSScriptConfig(network, version);
-  
+
   // 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 for checksum calculation
   const combinedContent = Buffer.concat(contentChunks);
-  
+
   // 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`);
-  
+  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
+    { 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 = {
       // 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,
     };
@@ -311,51 +329,61 @@ export async function createAppendTransaction(
       txHash: outPoint.txHash,
     };
   }
-  
+
   // Update backlinks - add the new one to the existing backlinks array
   const backLinks = [...(data.backLinks || []), newBackLink];
-  
+
   // Define output data based on version
   let outputData: Uint8Array;
-  
+
   if (version === ProtocolVersion.V1) {
     // 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: witnessIndices[0], // Use only the first index as a number
-      checksum: contentChecksum,
-      contentType: data.contentType,
-      filename: data.filename,
-      backLinks,
-    }, ProtocolVersion.V1); // Explicitly use V1 for packing
+    outputData = CKBFSData.pack(
+      {
+        index: witnessIndices[0], // Use only the first index as a number
+        checksum: contentChecksum,
+        contentType: data.contentType,
+        filename: data.filename,
+        backLinks,
+      },
+      ProtocolVersion.V1,
+    ); // Explicitly use V1 for packing
   } else {
     // In V2, indexes is an array of witness indices
-    outputData = CKBFSData.pack({
-      indexes: witnessIndices,
-      checksum: contentChecksum,
-      contentType: data.contentType,
-      filename: data.filename,
-      backLinks,
-    }, ProtocolVersion.V2); // Explicitly use V2 for packing
+    outputData = CKBFSData.pack(
+      {
+        indexes: witnessIndices,
+        checksum: contentChecksum,
+        contentType: data.contentType,
+        filename: data.filename,
+        backLinks,
+      },
+      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 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;
-  
-  console.log(`Original capacity: ${capacity}, Calculated size: ${ckbfsCellSize}, Data size: ${outputData.length}`);
-  
+  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
   const outputCapacity = ckbfsCellSize > capacity ? ckbfsCellSize : capacity;
@@ -369,59 +397,57 @@ export async function createAppendTransaction(
           index: outPoint.index,
         },
         since: "0x0",
-      }
+      },
     ],
     outputs: [
       {
         lock,
         type,
         capacity: outputCapacity,
-      }
+      },
     ],
-    outputsData: [
-      outputData,
-    ]
+    outputsData: [outputData],
   });
 
-
   // Add the CKBFS dep group cell dependency
   tx.addCellDeps({
     outPoint: {
       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) {
-    console.log(`Need additional capacity: ${outputCapacity - capacity} shannons`);
+    console.log(
+      `Need additional capacity: ${outputCapacity - capacity} shannons`,
+    );
     // Add more inputs to cover the increased capacity
     await tx.completeInputsByCapacity(signer);
   }
 
-  const witnesses: any = []
+  const witnesses: any = [];
   // 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')
+  if (address.script.hash() === lock.hash()) {
+    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')
+  for (let i = inputsBefore; i < tx.inputs.length; i++) {
+    witnesses.push("0x");
   }
-  tx.witnesses = witnesses
+  tx.witnesses = witnesses;
 
   // Complete fee
   await tx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
-  
+
   return tx;
 }
 
@@ -432,8 +458,8 @@ export async function createAppendTransaction(
  * @returns Promise resolving to the signed transaction
  */
 export async function publishCKBFS(
-  signer: Signer, 
-  options: PublishOptions
+  signer: Signer,
+  options: PublishOptions,
 ): Promise<Transaction> {
   const tx = await createPublishTransaction(signer, options);
   return signer.signTransaction(tx);
@@ -446,9 +472,9 @@ export async function publishCKBFS(
  * @returns Promise resolving to the signed transaction
  */
 export async function appendCKBFS(
-  signer: Signer, 
-  options: AppendOptions
+  signer: Signer,
+  options: AppendOptions,
 ): Promise<Transaction> {
   const tx = await createAppendTransaction(signer, options);
   return signer.signTransaction(tx);
-} 
+}

package/traditional_direct_content_example.txt

@@ -0,0 +1 @@
+Hello CKBFS from direct content!

package/typeid_direct_content_example.txt

@@ -0,0 +1 @@
+Hello CKBFS from direct content!

package/.cursor/rules/typescript.mdc

@@ -1,49 +0,0 @@
----
-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/ABC.LOGS

@@ -1 +0,0 @@
-MINT,TO:ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqdpallzwnhe64rqnqmev7hf98yrmh4yzucgdw7qwGIVE_NAME,NEW_NAME:NERVAPE_COOKIE