@ckbfs/api 2.0.1 → 2.0.3

package/dist/utils/transactions/v3.d.ts

@@ -87,6 +87,15 @@ export declare function preparePublishV3Transaction(options: PublishV3Options):
  * @returns Promise resolving to the created transaction
  */
 export declare function createPublishV3Transaction(signer: Signer, options: PublishV3Options): Promise<Transaction>;
+/**
+ * Prepares a transaction for appending content to a CKBFS v3 file without fee and change handling
+ * @param options Options for appending content
+ * @returns Promise resolving to the prepared transaction and the output index of CKBFS Cell
+ */
+export declare function prepareAppendV3Transaction(options: AppendV3Options): Promise<{
+    tx: Transaction;
+    outputIndex: number;
+}>;
 /**
  * Creates a transaction for appending content to a CKBFS v3 file
  * @param signer The signer to use for the transaction
@@ -94,6 +103,13 @@ export declare function createPublishV3Transaction(signer: Signer, options: Publ
  * @returns Promise resolving to the created transaction
  */
 export declare function createAppendV3Transaction(signer: Signer, options: AppendV3Options): Promise<Transaction>;
+/**
+ * Creates a transaction for appending content to a CKBFS v3 file (dry run without fee completion)
+ * @param signer The signer to use for the transaction
+ * @param options Options for appending content
+ * @returns Promise resolving to the created transaction
+ */
+export declare function createAppendV3TransactionDry(signer: Signer, options: AppendV3Options): Promise<Transaction>;
 /**
  * Creates a transaction for transferring ownership of a CKBFS v3 file
  * @param signer The signer to use for the transaction

package/dist/utils/transactions/v3.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCKBFSV3Cell = createCKBFSV3Cell;
 exports.preparePublishV3Transaction = preparePublishV3Transaction;
 exports.createPublishV3Transaction = createPublishV3Transaction;
+exports.prepareAppendV3Transaction = prepareAppendV3Transaction;
 exports.createAppendV3Transaction = createAppendV3Transaction;
+exports.createAppendV3TransactionDry = createAppendV3TransactionDry;
 exports.createTransferV3Transaction = createTransferV3Transaction;
 exports.publishCKBFSV3 = publishCKBFSV3;
 exports.appendCKBFSV3 = appendCKBFSV3;
@@ -209,6 +211,125 @@ async function createPublishV3Transaction(signer, options) {
     }
     return preTx;
 }
+/**
+ * Prepares a transaction for appending content to a CKBFS v3 file without fee and change handling
+ * @param options Options for appending content
+ * @returns Promise resolving to the prepared transaction and the output index of CKBFS Cell
+ */
+async function prepareAppendV3Transaction(options) {
+    const { from, ckbfsCell, contentChunks, network = constants_1.DEFAULT_NETWORK, previousTxHash, previousWitnessIndex, previousChecksum, } = options;
+    // Calculate new checksum by updating from previous checksum
+    const combinedContent = Buffer.concat(contentChunks);
+    const newChecksum = await (0, checksum_1.updateChecksum)(previousChecksum, combinedContent);
+    // Calculate the actual witness indices where our content is placed
+    const contentStartIndex = from?.witnesses.length || 1;
+    // Create CKBFS v3 witnesses with backlink info
+    const ckbfsWitnesses = (0, witness_1.createChunkedCKBFSV3Witnesses)(contentChunks, {
+        previousTxHash,
+        previousWitnessIndex,
+        previousChecksum,
+        startIndex: contentStartIndex,
+    });
+    // Create updated CKBFS v3 cell output data
+    const outputData = molecule_1.CKBFSData.pack({
+        index: contentStartIndex,
+        checksum: newChecksum,
+        contentType: ckbfsCell.data.contentType,
+        filename: ckbfsCell.data.filename,
+    }, constants_1.ProtocolVersion.V3);
+    // Get CKBFS script config
+    const config = (0, constants_1.getCKBFSScriptConfig)(network, constants_1.ProtocolVersion.V3, false);
+    // Calculate the required capacity for the output cell
+    const ckbfsCellSize = BigInt(outputData.length + ckbfsCell.type.occupiedSize + ckbfsCell.lock.occupiedSize + 8) *
+        100000000n;
+    // Use the maximum value between calculated size and original capacity
+    const outputCapacity = ckbfsCellSize > ckbfsCell.capacity ? ckbfsCellSize : ckbfsCell.capacity;
+    // Create initial transaction with the CKBFS cell input
+    let preTx;
+    if (from) {
+        // If from is not empty, inject/merge the fields
+        preTx = core_1.Transaction.from({
+            ...from,
+            inputs: from.inputs.length === 0
+                ? [
+                    {
+                        previousOutput: ckbfsCell.outPoint,
+                        since: "0x0",
+                    },
+                ]
+                : [
+                    ...from.inputs,
+                    {
+                        previousOutput: ckbfsCell.outPoint,
+                        since: "0x0",
+                    },
+                ],
+            outputs: from.outputs.length === 0
+                ? [
+                    {
+                        lock: ckbfsCell.lock,
+                        type: ckbfsCell.type,
+                        capacity: outputCapacity,
+                    },
+                ]
+                : [
+                    ...from.outputs,
+                    {
+                        lock: ckbfsCell.lock,
+                        type: ckbfsCell.type,
+                        capacity: outputCapacity,
+                    },
+                ],
+            outputsData: from.outputsData.length === 0
+                ? [outputData]
+                : [
+                    ...from.outputsData,
+                    outputData,
+                ],
+            witnesses: from.witnesses.length === 0
+                ? [
+                    [], // Empty secp witness for signing if not provided
+                    ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+                ]
+                : [
+                    ...from.witnesses,
+                    ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+                ],
+        });
+    }
+    else {
+        preTx = core_1.Transaction.from({
+            inputs: [
+                {
+                    previousOutput: ckbfsCell.outPoint,
+                    since: "0x0",
+                },
+            ],
+            outputs: [
+                {
+                    lock: ckbfsCell.lock,
+                    type: ckbfsCell.type,
+                    capacity: outputCapacity,
+                },
+            ],
+            witnesses: [
+                [], // Empty secp witness for signing
+                ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+            ],
+            outputsData: [outputData],
+        });
+    }
+    // Add the CKBFS dep group cell dependency
+    preTx.addCellDeps({
+        outPoint: {
+            txHash: (0, shared_1.ensureHexPrefix)(config.depTxHash),
+            index: config.depIndex || 0,
+        },
+        depType: "depGroup",
+    });
+    const outputIndex = from ? from.outputs.length : 0;
+    return { tx: preTx, outputIndex };
+}
 /**
  * Creates a transaction for appending content to a CKBFS v3 file
  * @param signer The signer to use for the transaction
@@ -216,18 +337,61 @@ async function createPublishV3Transaction(signer, options) {
  * @returns Promise resolving to the created transaction
  */
 async function createAppendV3Transaction(signer, options) {
-    const { ckbfsCell, contentChunks, feeRate, network = constants_1.DEFAULT_NETWORK, previousTxHash, previousWitnessIndex, previousChecksum, } = options;
+    const { ckbfsCell, feeRate, } = options;
+    const { lock } = ckbfsCell;
+    // Use prepareAppendV3Transaction to create the base transaction
+    const { tx: preTx, outputIndex } = await prepareAppendV3Transaction(options);
+    // Get the recommended address to ensure lock script cell deps are included
+    const address = await signer.getRecommendedAddressObj();
+    const inputsBefore = preTx.inputs.length;
+    // If we need more capacity than the original cell had, add additional inputs
+    if (preTx.outputs[outputIndex].capacity > ckbfsCell.capacity) {
+        console.log(`Need additional capacity: ${preTx.outputs[outputIndex].capacity - ckbfsCell.capacity} shannons`);
+        // Add more inputs to cover the increased capacity
+        await preTx.completeInputsByCapacity(signer);
+    }
+    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");
+    }
+    // add ckbfs witnesses (skip the first witness which is for signing)
+    witnesses.push(...preTx.witnesses.slice(1));
+    // Add empty witnesses for additional signer inputs
+    // This is to ensure that the transaction is valid and can be signed
+    for (let i = inputsBefore; i < preTx.inputs.length; i++) {
+        witnesses.push("0x");
+    }
+    preTx.witnesses = witnesses;
+    // Complete fee
+    await preTx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
+    return preTx;
+}
+/**
+ * Creates a transaction for appending content to a CKBFS v3 file (dry run without fee completion)
+ * @param signer The signer to use for the transaction
+ * @param options Options for appending content
+ * @returns Promise resolving to the created transaction
+ */
+async function createAppendV3TransactionDry(signer, options) {
+    const { ckbfsCell, contentChunks, network = constants_1.DEFAULT_NETWORK, previousTxHash, previousWitnessIndex, previousChecksum, } = options;
+    const { lock } = ckbfsCell;
     // Calculate new checksum by updating from previous checksum
     const combinedContent = Buffer.concat(contentChunks);
     const newChecksum = await (0, checksum_1.updateChecksum)(previousChecksum, combinedContent);
+    // 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
+    // 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;
     // Create CKBFS v3 witnesses with backlink info
     const ckbfsWitnesses = (0, witness_1.createChunkedCKBFSV3Witnesses)(contentChunks, {
         previousTxHash,
         previousWitnessIndex,
         previousChecksum,
+        startIndex: contentStartIndex,
     });
-    // V3 format uses single index (first witness containing content)
-    const contentStartIndex = 1; // First witness is for signer, content starts at index 1
     // Create updated CKBFS v3 cell output data
     const outputData = molecule_1.CKBFSData.pack({
         index: contentStartIndex,
@@ -240,9 +404,10 @@ async function createAppendV3Transaction(signer, options) {
     // Calculate the required capacity for the output cell
     const ckbfsCellSize = BigInt(outputData.length + ckbfsCell.type.occupiedSize + ckbfsCell.lock.occupiedSize + 8) *
         100000000n;
+    console.log(`Original capacity: ${ckbfsCell.capacity}, Calculated size: ${ckbfsCellSize}, Data size: ${outputData.length}`);
     // Use the maximum value between calculated size and original capacity
     const outputCapacity = ckbfsCellSize > ckbfsCell.capacity ? ckbfsCellSize : ckbfsCell.capacity;
-    // Create transaction
+    // Create initial transaction with the CKBFS cell input
     const tx = core_1.Transaction.from({
         inputs: [
             {
@@ -257,10 +422,6 @@ async function createAppendV3Transaction(signer, options) {
                 capacity: outputCapacity,
             },
         ],
-        witnesses: [
-            [], // Empty secp witness for signing
-            ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
-        ],
         outputsData: [outputData],
     });
     // Add the CKBFS dep group cell dependency
@@ -271,10 +432,20 @@ async function createAppendV3Transaction(signer, options) {
         },
         depType: "depGroup",
     });
-    // Complete inputs by capacity for fees
-    await tx.completeInputsByCapacity(signer);
-    // Complete fee change to lock
-    await tx.completeFeeChangeToLock(signer, ckbfsCell.lock, feeRate || 2000);
+    const inputsBefore = tx.inputs.length;
+    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");
+    }
+    // add ckbfs witnesses
+    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");
+    }
+    tx.witnesses = witnesses;
     return tx;
 }
 /**

package/examples/retrieve-v3.ts

@@ -2,6 +2,10 @@ import {
   getFileContentFromChainByIdentifierV3, 
   saveFileFromChainByIdentifierV3,
   ProtocolVersion,
+  CKBFSData,
+  getCKBFSScriptConfig,
+  NetworkType,
+  resolveCKBFSCell,
 } from '../src/index';
 import { ClientPublicTestnet } from '@ckb-ccc/core';
 
@@ -14,7 +18,7 @@ const client = new ClientPublicTestnet(); // Use testnet
 async function retrieveFileByTypeIdV3Example() {
   try {
     // Example TypeID (replace with actual TypeID from a v3 published file)
-    const typeId = "0xc387111856be837b1f358d49a9d7e4461dc18244c2b7b59f9012617b1c09d7be";
+    const typeId = "0x32d5f0b09f85a64143e91847b6167d8e952ea3026db92068cada45f4478dd814";
     
     console.log(`Retrieving CKBFS v3 file by TypeID: ${typeId}`);
     
@@ -106,7 +110,7 @@ async function retrieveAndSaveFileV3Example() {
 async function retrieveFileByURIV3Example() {
   try {
     // Example CKBFS URI (replace with actual URI)
-    const ckbfsUri = "ckbfs://c387111856be837b1f358d49a9d7e4461dc18244c2b7b59f9012617b1c09d7be";
+    const ckbfsUri = "ckbfs://d52d8536d3498bd68fa1e235f7e090c2d047154e22fcea5cfa54ccb58c236eb3";
     
     console.log(`Retrieving CKBFS v3 file by URI: ${ckbfsUri}`);
     
@@ -145,7 +149,7 @@ async function retrieveFileByURIV3Example() {
 async function retrieveFileByOutPointV3Example() {
   try {
     // Example OutPoint URI (replace with actual transaction hash and index)
-    const outPointUri = "ckbfs://1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefi0";
+    const outPointUri = "ckbfs://1cc22be7489f64bda7cbc3a9227a94640394dc99f98181b1c3b1243d24897972i0";
     
     console.log(`Retrieving CKBFS v3 file by OutPoint: ${outPointUri}`);
     
@@ -169,6 +173,7 @@ async function retrieveFileByOutPointV3Example() {
     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) {
@@ -202,10 +207,10 @@ async function main() {
     console.log('');
     
     // Uncomment to test different retrieval methods:
-    await retrieveFileByTypeIdV3Example();
+    //await retrieveFileByTypeIdV3Example();
     // await retrieveAndSaveFileV3Example();
     await retrieveFileByURIV3Example();
-    // await retrieveFileByOutPointV3Example();
+    //await retrieveFileByOutPointV3Example();
     
     console.log('Retrieval example structure completed successfully!');
     console.log('Update the identifiers and uncomment methods to test.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckbfs/api",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "SDK for CKBFS protocol on CKB",
   "license": "MIT",
   "author": "Code Monad<code@lab-11.org>",

package/src/index.ts

@@ -34,7 +34,10 @@ import {
   appendCKBFSV3,
   transferCKBFSV3,
   createPublishV3Transaction,
+  prepareAppendV3Transaction,
+  preparePublishV3Transaction,
   createAppendV3Transaction,
+  createAppendV3TransactionDry,
   createTransferV3Transaction,
 } from "./utils/transaction";
 import {
@@ -64,6 +67,7 @@ import {
   getFileContentFromChainV3,
   getFileContentFromChainByIdentifierV3,
   saveFileFromChainByIdentifierV3,
+  resolveCKBFSCell
 } from "./utils/file";
 import {
   createCKBFSWitness,
@@ -1046,6 +1050,7 @@ export {
   createChunkedCKBFSV3Witnesses,
   extractCKBFSV3WitnessContent,
   isCKBFSV3Witness,
+  resolveCKBFSCell,
   CKBFSV3WitnessOptions,
 
   // Molecule definitions

package/src/utils/file.ts

@@ -510,7 +510,7 @@ export function parseIdentifier(identifier: string): ParsedIdentifier {
  * @param options Optional configuration for network, version, and useTypeID
  * @returns Promise resolving to the found cell and transaction info, or null if not found
  */
-async function resolveCKBFSCell(
+export async function resolveCKBFSCell(
   client: any,
   identifier: string,
   options: {

package/src/utils/transactions/v3.ts

@@ -341,6 +341,150 @@ export async function createPublishV3Transaction(
   return preTx;
 }
 
+/**
+ * Prepares a transaction for appending content to a CKBFS v3 file without fee and change handling
+ * @param options Options for appending content
+ * @returns Promise resolving to the prepared transaction and the output index of CKBFS Cell
+ */
+export async function prepareAppendV3Transaction(
+  options: AppendV3Options,
+): Promise<{tx: Transaction, outputIndex: number}> {
+  const {
+    from,
+    ckbfsCell,
+    contentChunks,
+    network = DEFAULT_NETWORK,
+    previousTxHash,
+    previousWitnessIndex,
+    previousChecksum,
+  } = options;
+
+  // Calculate new checksum by updating from previous checksum
+  const combinedContent = Buffer.concat(contentChunks);
+  const newChecksum = await updateChecksum(previousChecksum, combinedContent);
+
+  // Calculate the actual witness indices where our content is placed
+  const contentStartIndex = from?.witnesses.length || 1;
+
+  // Create CKBFS v3 witnesses with backlink info
+  const ckbfsWitnesses = createChunkedCKBFSV3Witnesses(contentChunks, {
+    previousTxHash,
+    previousWitnessIndex,
+    previousChecksum,
+    startIndex: contentStartIndex,
+  });
+  
+  // Create updated CKBFS v3 cell output data
+  const outputData = CKBFSData.pack(
+    {
+      index: contentStartIndex,
+      checksum: newChecksum,
+      contentType: ckbfsCell.data.contentType,
+      filename: ckbfsCell.data.filename,
+    },
+    ProtocolVersion.V3,
+  );
+
+  // Get CKBFS script config
+  const config = getCKBFSScriptConfig(network, ProtocolVersion.V3, false);
+
+  // Calculate the required capacity for the output cell
+  const ckbfsCellSize =
+    BigInt(outputData.length + ckbfsCell.type.occupiedSize + ckbfsCell.lock.occupiedSize + 8) *
+    100000000n;
+
+  // Use the maximum value between calculated size and original capacity
+  const outputCapacity = ckbfsCellSize > ckbfsCell.capacity ? ckbfsCellSize : ckbfsCell.capacity;
+
+  // Create initial transaction with the CKBFS cell input
+  let preTx: Transaction;
+  if (from) {
+    // If from is not empty, inject/merge the fields
+    preTx = Transaction.from({
+      ...from,
+      inputs: from.inputs.length === 0
+        ? [
+            {
+              previousOutput: ckbfsCell.outPoint,
+              since: "0x0",
+            },
+          ]
+        : [
+            ...from.inputs,
+            {
+              previousOutput: ckbfsCell.outPoint,
+              since: "0x0",
+            },
+          ],
+      outputs: from.outputs.length === 0
+        ? [
+            {
+              lock: ckbfsCell.lock,
+              type: ckbfsCell.type,
+              capacity: outputCapacity,
+            },
+          ]
+        : [
+            ...from.outputs,
+            {
+              lock: ckbfsCell.lock,
+              type: ckbfsCell.type,
+              capacity: outputCapacity,
+            },
+          ],
+      outputsData: from.outputsData.length === 0
+        ? [outputData]
+        : [
+            ...from.outputsData,
+            outputData,
+          ],
+      witnesses: from.witnesses.length === 0
+        ? [
+            [], // Empty secp witness for signing if not provided
+            ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+          ]
+        : [
+            ...from.witnesses,
+            ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+          ],
+    });
+  } else {
+    preTx = Transaction.from({
+      inputs: [
+        {
+          previousOutput: ckbfsCell.outPoint,
+          since: "0x0",
+        },
+      ],
+      outputs: [
+        {
+          lock: ckbfsCell.lock,
+          type: ckbfsCell.type,
+          capacity: outputCapacity,
+        },
+      ],
+      witnesses: [
+        [], // Empty secp witness for signing
+        ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+      ],
+      outputsData: [outputData],
+    });
+  }
+
+  // Add the CKBFS dep group cell dependency
+  preTx.addCellDeps({
+    outPoint: {
+      txHash: ensureHexPrefix(config.depTxHash),
+      index: config.depIndex || 0,
+    },
+    depType: "depGroup",
+  });
+
+  const outputIndex = from ? from.outputs.length : 0;
+
+  return {tx: preTx, outputIndex};
+}
+
 /**
  * Creates a transaction for appending content to a CKBFS v3 file
  * @param signer The signer to use for the transaction
@@ -353,27 +497,86 @@ export async function createAppendV3Transaction(
 ): Promise<Transaction> {
   const {
     ckbfsCell,
-    contentChunks,
     feeRate,
+  } = options;
+  const { lock } = ckbfsCell;
+
+  // Use prepareAppendV3Transaction to create the base transaction
+  const { tx: preTx, outputIndex } = await prepareAppendV3Transaction(options);
+
+  // Get the recommended address to ensure lock script cell deps are included
+  const address = await signer.getRecommendedAddressObj();
+
+  const inputsBefore = preTx.inputs.length;
+  // If we need more capacity than the original cell had, add additional inputs
+  if (preTx.outputs[outputIndex].capacity > ckbfsCell.capacity) {
+    console.log(
+      `Need additional capacity: ${preTx.outputs[outputIndex].capacity - ckbfsCell.capacity} shannons`,
+    );
+    // Add more inputs to cover the increased capacity
+    await preTx.completeInputsByCapacity(signer);
+  }
+
+  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");
+  }
+  // add ckbfs witnesses (skip the first witness which is for signing)
+  witnesses.push(...preTx.witnesses.slice(1));
+
+  // Add empty witnesses for additional signer inputs
+  // This is to ensure that the transaction is valid and can be signed
+  for (let i = inputsBefore; i < preTx.inputs.length; i++) {
+    witnesses.push("0x");
+  }
+  preTx.witnesses = witnesses;
+
+  // Complete fee
+  await preTx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
+
+  return preTx;
+}
+
+/**
+ * Creates a transaction for appending content to a CKBFS v3 file (dry run without fee completion)
+ * @param signer The signer to use for the transaction
+ * @param options Options for appending content
+ * @returns Promise resolving to the created transaction
+ */
+export async function createAppendV3TransactionDry(
+  signer: Signer,
+  options: AppendV3Options,
+): Promise<Transaction> {
+  const {
+    ckbfsCell,
+    contentChunks,
     network = DEFAULT_NETWORK,
     previousTxHash,
     previousWitnessIndex,
     previousChecksum,
   } = options;
+  const { lock } = ckbfsCell;
 
   // Calculate new checksum by updating from previous checksum
   const combinedContent = Buffer.concat(contentChunks);
   const newChecksum = await updateChecksum(previousChecksum, combinedContent);
 
+  // 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
+  // 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;
+
   // Create CKBFS v3 witnesses with backlink info
   const ckbfsWitnesses = createChunkedCKBFSV3Witnesses(contentChunks, {
     previousTxHash,
     previousWitnessIndex,
     previousChecksum,
+    startIndex: contentStartIndex,
   });
-
-  // V3 format uses single index (first witness containing content)
-  const contentStartIndex = 1; // First witness is for signer, content starts at index 1
   
   // Create updated CKBFS v3 cell output data
   const outputData = CKBFSData.pack(
@@ -394,10 +597,14 @@ export async function createAppendV3Transaction(
     BigInt(outputData.length + ckbfsCell.type.occupiedSize + ckbfsCell.lock.occupiedSize + 8) *
     100000000n;
 
+  console.log(
+    `Original capacity: ${ckbfsCell.capacity}, Calculated size: ${ckbfsCellSize}, Data size: ${outputData.length}`,
+  );
+
   // Use the maximum value between calculated size and original capacity
   const outputCapacity = ckbfsCellSize > ckbfsCell.capacity ? ckbfsCellSize : ckbfsCell.capacity;
 
-  // Create transaction
+  // Create initial transaction with the CKBFS cell input
   const tx = Transaction.from({
     inputs: [
       {
@@ -412,10 +619,6 @@ export async function createAppendV3Transaction(
         capacity: outputCapacity,
       },
     ],
-    witnesses: [
-      [], // Empty secp witness for signing
-      ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
-    ],
     outputsData: [outputData],
   });
 
@@ -428,11 +631,24 @@ export async function createAppendV3Transaction(
     depType: "depGroup",
   });
 
-  // Complete inputs by capacity for fees
-  await tx.completeInputsByCapacity(signer);
+  const inputsBefore = tx.inputs.length;
 
-  // Complete fee change to lock
-  await tx.completeFeeChangeToLock(signer, ckbfsCell.lock, feeRate || 2000);
+  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");
+  }
+  // add ckbfs witnesses
+  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");
+  }
+  tx.witnesses = witnesses;
 
   return tx;
 }