@ckbfs/api 2.0.1 → 2.0.2

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckbfs/api",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "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 {

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;
 }