npm - @ckbfs/api - Versions diffs - 1.4.0 → 1.5.1 - Mend

@ckbfs/api 1.4.0 → 1.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +1 -2
package/dist/index.d.ts +4 -2
package/dist/index.js +13 -4
package/dist/utils/transaction.d.ts +29 -0
package/dist/utils/transaction.js +368 -60
package/examples/publish.ts +2 -2
package/package.json +1 -1
package/src/index.ts +16 -3
package/src/utils/transaction.ts +435 -66

package/README.md CHANGED Viewed

@@ -14,7 +14,6 @@ CKBFS is a file system protocol built on top of the CKB blockchain that enables
 - **Protocol Versions**: Support for both V1 and V2 CKBFS protocol versions
 - **Network Support**: Compatible with CKB mainnet and testnet
 - **Chunked Storage**: Automatic file chunking for large files
-- **TypeScript**: Full type safety with comprehensive type definitions
 ## Installation
@@ -567,4 +566,4 @@ Contributions are welcome. Please ensure all tests pass and follow the existing
 ## Support
-For issues and questions, please use the GitHub issue tracker.
+For issues and questions, please use the GitHub issue tracker.

package/dist/index.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { Script, Signer, Transaction } from "@ckb-ccc/core";
 import { calculateChecksum, verifyChecksum, updateChecksum, verifyWitnessChecksum } from "./utils/checksum";
-import { createCKBFSCell, createPublishTransaction as utilCreatePublishTransaction, createAppendTransaction as utilCreateAppendTransaction, publishCKBFS as utilPublishCKBFS, appendCKBFS as utilAppendCKBFS, CKBFSCellOptions, PublishOptions, AppendOptions } from "./utils/transaction";
+import { createCKBFSCell, createPublishTransaction as utilCreatePublishTransaction, preparePublishTransaction, createAppendTransaction as utilCreateAppendTransaction, prepareAppendTransaction, createAppendTransactionDry, publishCKBFS as utilPublishCKBFS, appendCKBFS as utilAppendCKBFS, CKBFSCellOptions, PublishOptions, AppendOptions } from "./utils/transaction";
 import { readFile, readFileAsText, readFileAsUint8Array, writeFile, getContentType, splitFileIntoChunks, combineChunksToFile, getFileContentFromChain, saveFileFromChain, getFileContentFromChainByTypeId, saveFileFromChainByTypeId, decodeFileFromChainByTypeId, getFileContentFromChainByIdentifier, saveFileFromChainByIdentifier, decodeFileFromChainByIdentifier, parseIdentifier, IdentifierType, decodeWitnessContent, decodeMultipleWitnessContents, extractFileFromWitnesses, decodeFileFromWitnessData, saveFileFromWitnessData } from "./utils/file";
 import { createCKBFSWitness, createTextCKBFSWitness, extractCKBFSWitnessContent, isCKBFSWitness, createChunkedCKBFSWitnesses } from "./utils/witness";
 import { CKBFSData, BackLinkV1, BackLinkV2, CKBFSDataType, BackLinkType, CKBFS_HEADER, CKBFS_HEADER_STRING } from "./utils/molecule";
@@ -37,6 +37,7 @@ export interface CKBFSOptions {
     version?: ProtocolVersionType;
     useTypeID?: boolean;
     network?: NetworkType;
+    rpcUrl?: string;
 }
 /**
  * Main CKBFS SDK class
@@ -47,6 +48,7 @@ export declare class CKBFS {
     private network;
     private version;
     private useTypeID;
+    private rpcUrl;
     /**
      * Creates a new CKBFS SDK instance
      * @param signerOrPrivateKey The signer instance or CKB private key to use for signing transactions
@@ -130,4 +132,4 @@ export declare class CKBFS {
      */
     createAppendContentTransaction(content: string | Uint8Array, ckbfsCell: AppendOptions["ckbfsCell"], options?: AppendContentOptions): Promise<Transaction>;
 }
-export { calculateChecksum, verifyChecksum, updateChecksum, verifyWitnessChecksum, createCKBFSCell, utilCreatePublishTransaction as createPublishTransaction, utilCreateAppendTransaction as createAppendTransaction, utilPublishCKBFS as publishCKBFS, utilAppendCKBFS as appendCKBFS, readFile, readFileAsText, readFileAsUint8Array, writeFile, getContentType, splitFileIntoChunks, combineChunksToFile, getFileContentFromChain, saveFileFromChain, getFileContentFromChainByTypeId, saveFileFromChainByTypeId, decodeFileFromChainByTypeId, getFileContentFromChainByIdentifier, saveFileFromChainByIdentifier, decodeFileFromChainByIdentifier, parseIdentifier, IdentifierType, decodeWitnessContent, decodeMultipleWitnessContents, extractFileFromWitnesses, decodeFileFromWitnessData, saveFileFromWitnessData, createCKBFSWitness, createTextCKBFSWitness, extractCKBFSWitnessContent, isCKBFSWitness, createChunkedCKBFSWitnesses, CKBFSData, BackLinkV1, BackLinkV2, CKBFSDataType, BackLinkType, CKBFSCellOptions, PublishOptions, AppendOptions, CKBFS_HEADER, CKBFS_HEADER_STRING, NetworkType, ProtocolVersion, ProtocolVersionType, DEFAULT_NETWORK, DEFAULT_VERSION, CKBFS_CODE_HASH, CKBFS_TYPE_ID, ADLER32_CODE_HASH, ADLER32_TYPE_ID, DEP_GROUP_TX_HASH, DEPLOY_TX_HASH, getCKBFSScriptConfig, CKBFSScriptConfig, };
+export { calculateChecksum, verifyChecksum, updateChecksum, verifyWitnessChecksum, createCKBFSCell, utilCreatePublishTransaction as createPublishTransaction, preparePublishTransaction, utilCreateAppendTransaction as createAppendTransaction, prepareAppendTransaction, utilPublishCKBFS as publishCKBFS, utilAppendCKBFS as appendCKBFS, createAppendTransactionDry, readFile, readFileAsText, readFileAsUint8Array, writeFile, getContentType, splitFileIntoChunks, combineChunksToFile, getFileContentFromChain, saveFileFromChain, getFileContentFromChainByTypeId, saveFileFromChainByTypeId, decodeFileFromChainByTypeId, getFileContentFromChainByIdentifier, saveFileFromChainByIdentifier, decodeFileFromChainByIdentifier, parseIdentifier, IdentifierType, decodeWitnessContent, decodeMultipleWitnessContents, extractFileFromWitnesses, decodeFileFromWitnessData, saveFileFromWitnessData, createCKBFSWitness, createTextCKBFSWitness, extractCKBFSWitnessContent, isCKBFSWitness, createChunkedCKBFSWitnesses, CKBFSData, BackLinkV1, BackLinkV2, CKBFSDataType, BackLinkType, CKBFSCellOptions, PublishOptions, AppendOptions, CKBFS_HEADER, CKBFS_HEADER_STRING, NetworkType, ProtocolVersion, ProtocolVersionType, DEFAULT_NETWORK, DEFAULT_VERSION, CKBFS_CODE_HASH, CKBFS_TYPE_ID, ADLER32_CODE_HASH, ADLER32_TYPE_ID, DEP_GROUP_TX_HASH, DEPLOY_TX_HASH, getCKBFSScriptConfig, CKBFSScriptConfig, };

package/dist/index.js CHANGED Viewed

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADLER32_TYPE_ID = exports.ADLER32_CODE_HASH = exports.CKBFS_TYPE_ID = exports.CKBFS_CODE_HASH = exports.DEFAULT_VERSION = exports.DEFAULT_NETWORK = exports.ProtocolVersion = exports.NetworkType = exports.CKBFS_HEADER_STRING = exports.CKBFS_HEADER = exports.BackLinkV2 = exports.BackLinkV1 = exports.CKBFSData = exports.createChunkedCKBFSWitnesses = exports.isCKBFSWitness = exports.extractCKBFSWitnessContent = exports.createTextCKBFSWitness = exports.createCKBFSWitness = exports.saveFileFromWitnessData = exports.decodeFileFromWitnessData = exports.extractFileFromWitnesses = exports.decodeMultipleWitnessContents = exports.decodeWitnessContent = exports.IdentifierType = exports.parseIdentifier = exports.decodeFileFromChainByIdentifier = exports.saveFileFromChainByIdentifier = exports.getFileContentFromChainByIdentifier = exports.decodeFileFromChainByTypeId = exports.saveFileFromChainByTypeId = exports.getFileContentFromChainByTypeId = exports.saveFileFromChain = exports.getFileContentFromChain = exports.combineChunksToFile = exports.splitFileIntoChunks = exports.getContentType = exports.writeFile = exports.readFileAsUint8Array = exports.readFileAsText = exports.readFile = exports.appendCKBFS = exports.publishCKBFS = exports.createAppendTransaction = exports.createPublishTransaction = exports.createCKBFSCell = exports.verifyWitnessChecksum = exports.updateChecksum = exports.verifyChecksum = exports.calculateChecksum = exports.CKBFS = void 0;
-exports.getCKBFSScriptConfig = exports.DEPLOY_TX_HASH = exports.DEP_GROUP_TX_HASH = void 0;
+exports.CKBFS_CODE_HASH = exports.DEFAULT_VERSION = exports.DEFAULT_NETWORK = exports.ProtocolVersion = exports.NetworkType = exports.CKBFS_HEADER_STRING = exports.CKBFS_HEADER = exports.BackLinkV2 = exports.BackLinkV1 = exports.CKBFSData = exports.createChunkedCKBFSWitnesses = exports.isCKBFSWitness = exports.extractCKBFSWitnessContent = exports.createTextCKBFSWitness = exports.createCKBFSWitness = exports.saveFileFromWitnessData = exports.decodeFileFromWitnessData = exports.extractFileFromWitnesses = exports.decodeMultipleWitnessContents = exports.decodeWitnessContent = exports.IdentifierType = exports.parseIdentifier = exports.decodeFileFromChainByIdentifier = exports.saveFileFromChainByIdentifier = exports.getFileContentFromChainByIdentifier = exports.decodeFileFromChainByTypeId = exports.saveFileFromChainByTypeId = exports.getFileContentFromChainByTypeId = exports.saveFileFromChain = exports.getFileContentFromChain = exports.combineChunksToFile = exports.splitFileIntoChunks = exports.getContentType = exports.writeFile = exports.readFileAsUint8Array = exports.readFileAsText = exports.readFile = exports.createAppendTransactionDry = exports.appendCKBFS = exports.publishCKBFS = exports.prepareAppendTransaction = exports.createAppendTransaction = exports.preparePublishTransaction = exports.createPublishTransaction = exports.createCKBFSCell = exports.verifyWitnessChecksum = exports.updateChecksum = exports.verifyChecksum = exports.calculateChecksum = exports.CKBFS = void 0;
+exports.getCKBFSScriptConfig = exports.DEPLOY_TX_HASH = exports.DEP_GROUP_TX_HASH = exports.ADLER32_TYPE_ID = exports.ADLER32_CODE_HASH = exports.CKBFS_TYPE_ID = void 0;
 const core_1 = require("@ckb-ccc/core");
 const checksum_1 = require("./utils/checksum");
 Object.defineProperty(exports, "calculateChecksum", { enumerable: true, get: function () { return checksum_1.calculateChecksum; } });
@@ -11,7 +11,10 @@ Object.defineProperty(exports, "verifyWitnessChecksum", { enumerable: true, get:
 const transaction_1 = require("./utils/transaction");
 Object.defineProperty(exports, "createCKBFSCell", { enumerable: true, get: function () { return transaction_1.createCKBFSCell; } });
 Object.defineProperty(exports, "createPublishTransaction", { enumerable: true, get: function () { return transaction_1.createPublishTransaction; } });
+Object.defineProperty(exports, "preparePublishTransaction", { enumerable: true, get: function () { return transaction_1.preparePublishTransaction; } });
 Object.defineProperty(exports, "createAppendTransaction", { enumerable: true, get: function () { return transaction_1.createAppendTransaction; } });
+Object.defineProperty(exports, "prepareAppendTransaction", { enumerable: true, get: function () { return transaction_1.prepareAppendTransaction; } });
+Object.defineProperty(exports, "createAppendTransactionDry", { enumerable: true, get: function () { return transaction_1.createAppendTransactionDry; } });
 Object.defineProperty(exports, "publishCKBFS", { enumerable: true, get: function () { return transaction_1.publishCKBFS; } });
 Object.defineProperty(exports, "appendCKBFS", { enumerable: true, get: function () { return transaction_1.appendCKBFS; } });
 const file_1 = require("./utils/file");
@@ -85,13 +88,18 @@ class CKBFS {
             const opts = options ||
                 (typeof networkOrOptions === "object" ? networkOrOptions : {});
             const client = network === "mainnet"
-                ? new core_1.ClientPublicMainnet()
-                : new core_1.ClientPublicTestnet();
+                ? new core_1.ClientPublicMainnet({
+                    url: opts.rpcUrl,
+                })
+                : new core_1.ClientPublicTestnet({
+                    url: opts.rpcUrl,
+                });
             this.signer = new core_1.SignerCkbPrivateKey(client, privateKey);
             this.network = network;
             this.chunkSize = opts.chunkSize || 30 * 1024;
             this.version = opts.version || constants_1.DEFAULT_VERSION;
             this.useTypeID = opts.useTypeID || false;
+            this.rpcUrl = opts.rpcUrl || client.url;
         }
         else {
             // Initialize with signer
@@ -101,6 +109,7 @@ class CKBFS {
             this.chunkSize = opts.chunkSize || 30 * 1024;
             this.version = opts.version || constants_1.DEFAULT_VERSION;
             this.useTypeID = opts.useTypeID || false;
+            this.rpcUrl = opts.rpcUrl || this.signer.client.url;
         }
     }
     /**

package/dist/utils/transaction.d.ts CHANGED Viewed

@@ -22,6 +22,7 @@ export interface CKBFSCellOptions {
 export interface PublishOptions extends CKBFSCellOptions {
     contentChunks: Uint8Array[];
     feeRate?: number;
+    from?: Transaction;
 }
 /**
  * Options for appending content to a CKBFS file
@@ -41,6 +42,7 @@ export interface AppendOptions {
     feeRate?: number;
     network?: NetworkType;
     version?: ProtocolVersionType;
+    from?: Transaction;
 }
 /**
  * Ensures a string is prefixed with '0x'
@@ -58,6 +60,17 @@ export declare function createCKBFSCell(options: CKBFSCellOptions): {
     type: ccc.Script;
     capacity: bigint;
 };
+/**
+ * Prepares a transaction for publishing a file to CKBFS without fee and change handling
+ * You will need to manually set the typeID if you did not provide inputs, or just check is return value emptyTypeID is true
+ * @param options Options for publishing the file
+ * @returns Promise resolving to the prepared transaction and the output index of CKBFS Cell
+ */
+export declare function preparePublishTransaction(options: PublishOptions): Promise<{
+    tx: Transaction;
+    outputIndex: number;
+    emptyTypeID: boolean;
+}>;
 /**
  * Creates a transaction for publishing a file to CKBFS
  * @param signer The signer to use for the transaction
@@ -65,6 +78,15 @@ export declare function createCKBFSCell(options: CKBFSCellOptions): {
  * @returns Promise resolving to the created transaction
  */
 export declare function createPublishTransaction(signer: Signer, options: PublishOptions): Promise<Transaction>;
+/**
+ * Prepares a transaction for appending content to a CKBFS 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 prepareAppendTransaction(options: AppendOptions): Promise<{
+    tx: Transaction;
+    outputIndex: number;
+}>;
 /**
  * Creates a transaction for appending content to a CKBFS file
  * @param signer The signer to use for the transaction
@@ -72,6 +94,13 @@ export declare function createPublishTransaction(signer: Signer, options: Publis
  * @returns Promise resolving to the created transaction
  */
 export declare function createAppendTransaction(signer: Signer, options: AppendOptions): Promise<Transaction>;
+/**
+ * Creates a transaction for appending content to a CKBFS file
+ * @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 createAppendTransactionDry(signer: Signer, options: AppendOptions): Promise<Transaction>;
 /**
  * Creates a complete transaction for publishing a file to CKBFS
  * @param signer The signer to use for the transaction

package/dist/utils/transaction.js CHANGED Viewed

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureHexPrefix = ensureHexPrefix;
 exports.createCKBFSCell = createCKBFSCell;
+exports.preparePublishTransaction = preparePublishTransaction;
 exports.createPublishTransaction = createPublishTransaction;
+exports.prepareAppendTransaction = prepareAppendTransaction;
 exports.createAppendTransaction = createAppendTransaction;
+exports.createAppendTransactionDry = createAppendTransactionDry;
 exports.publishCKBFS = publishCKBFS;
 exports.appendCKBFS = appendCKBFS;
 const core_1 = require("@ckb-ccc/core");
@@ -41,15 +44,14 @@ function createCKBFSCell(options) {
     };
 }
 /**
- * Creates a transaction for publishing a file to CKBFS
- * @param signer The signer to use for the transaction
+ * Prepares a transaction for publishing a file to CKBFS without fee and change handling
+ * You will need to manually set the typeID if you did not provide inputs, or just check is return value emptyTypeID is true
  * @param options Options for publishing the file
- * @returns Promise resolving to the created transaction
+ * @returns Promise resolving to the prepared transaction and the output index of CKBFS Cell
  */
-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;
+async function preparePublishTransaction(options) {
+    const { from, contentChunks, contentType, filename, lock, capacity, 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);
     const checksum = await (0, checksum_1.calculateChecksum)(combinedContent);
     // Create CKBFS witnesses - each chunk already includes the CKBFS header
@@ -57,9 +59,7 @@ async function createPublishTransaction(signer, options) {
     // not to be confused with the Protocol Version (V1 vs V2)
     const ckbfsWitnesses = (0, witness_1.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 contentStartIndex = from?.witnesses.length || 1;
     const witnessIndices = Array.from({ length: contentChunks.length }, (_, i) => contentStartIndex + i);
     // Create CKBFS cell output data based on version
     let outputData;
@@ -93,24 +93,72 @@ async function createPublishTransaction(signer, options) {
         lock.occupiedSize +
         8) * 100000000n;
     // Create pre transaction without cell deps initially
-    const preTx = core_1.Transaction.from({
-        outputs: [
-            createCKBFSCell({
-                contentType,
-                filename,
-                lock,
-                network,
-                version,
-                useTypeID,
-                capacity: ckbfsCellSize || capacity,
-            }),
-        ],
-        witnesses: [
-            [], // Empty secp witness for signing
-            ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
-        ],
-        outputsData: [outputData],
-    });
+    let preTx;
+    if (from) {
+        // If from is not empty, inject/merge the fields
+        preTx = core_1.Transaction.from({
+            ...from,
+            outputs: from.outputs.length === 0
+                ? [
+                    createCKBFSCell({
+                        contentType,
+                        filename,
+                        lock,
+                        network,
+                        version,
+                        useTypeID,
+                        capacity: ckbfsCellSize || capacity,
+                    }),
+                ]
+                : [
+                    ...from.outputs,
+                    createCKBFSCell({
+                        contentType,
+                        filename,
+                        lock,
+                        network,
+                        version,
+                        useTypeID,
+                        capacity: ckbfsCellSize || capacity,
+                    }),
+                ],
+            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")}`),
+                ],
+            outputsData: from.outputsData.length === 0
+                ? [outputData]
+                : [
+                    ...from.outputsData,
+                    outputData,
+                ],
+        });
+    }
+    else {
+        preTx = core_1.Transaction.from({
+            outputs: [
+                createCKBFSCell({
+                    contentType,
+                    filename,
+                    lock,
+                    network,
+                    version,
+                    useTypeID,
+                    capacity: ckbfsCellSize || capacity,
+                }),
+            ],
+            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: {
@@ -119,35 +167,261 @@ async function createPublishTransaction(signer, options) {
         },
         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 = core_1.ccc.hashTypeId(preTx.inputs[0], 0x0);
+    const outputIndex = from ? from.outputs.length : 0;
+    const args = preTx.inputs.length > 0 ? core_1.ccc.hashTypeId(preTx.inputs[0], outputIndex) : "0x0000000000000000000000000000000000000000000000000000000000000000";
     // Create CKBFS type script with type ID
     const ckbfsTypeScript = new core_1.Script(ensureHexPrefix(config.codeHash), config.hashType, args);
     // Create final transaction with same cell deps as preTx
     const tx = core_1.Transaction.from({
         cellDeps: preTx.cellDeps,
-        witnesses: [
-            [], // Reset first witness for signing
-            ...preTx.witnesses.slice(1),
-        ],
+        witnesses: preTx.witnesses,
         outputsData: preTx.outputsData,
         inputs: preTx.inputs,
-        outputs: [
-            {
-                lock,
-                type: ckbfsTypeScript,
-                capacity: preTx.outputs[0].capacity,
-            },
-            ...preTx.outputs.slice(1), // Include rest of outputs (e.g., change)
-        ],
+        outputs: outputIndex === 0
+            ? [
+                {
+                    lock,
+                    type: ckbfsTypeScript,
+                    capacity: preTx.outputs[outputIndex].capacity,
+                },
+            ]
+            : [
+                ...preTx.outputs.slice(0, outputIndex), // Include rest of outputs (e.g., change)
+                {
+                    lock,
+                    type: ckbfsTypeScript,
+                    capacity: preTx.outputs[outputIndex].capacity,
+                },
+            ],
     });
-    return tx;
+    return { tx, outputIndex, emptyTypeID: args === "0x0000000000000000000000000000000000000000000000000000000000000000" };
+}
+/**
+ * Creates a transaction for publishing a file to CKBFS
+ * @param signer The signer to use for the transaction
+ * @param options Options for publishing the file
+ * @returns Promise resolving to the created transaction
+ */
+async function createPublishTransaction(signer, options) {
+    const { feeRate, lock, } = options;
+    // Use preparePublishTransaction to create the base transaction
+    const { tx: preTx, outputIndex, emptyTypeID } = await preparePublishTransaction(options);
+    // Complete inputs by capacity
+    await preTx.completeInputsByCapacity(signer);
+    // Complete fee change to lock
+    await preTx.completeFeeChangeToLock(signer, lock, feeRate || 2000);
+    // If emptyTypeID is true, we need to create the proper type ID args
+    if (emptyTypeID) {
+        // Get CKBFS script config
+        const config = (0, constants_1.getCKBFSScriptConfig)(options.network || constants_1.DEFAULT_NETWORK, options.version || constants_1.DEFAULT_VERSION, options.useTypeID || false);
+        // Create type ID args
+        const args = core_1.ccc.hashTypeId(preTx.inputs[0], outputIndex);
+        // Create CKBFS type script with type ID
+        const ckbfsTypeScript = new core_1.Script(ensureHexPrefix(config.codeHash), config.hashType, args);
+        // Create final transaction with updated type script
+        const tx = core_1.Transaction.from({
+            cellDeps: preTx.cellDeps,
+            witnesses: preTx.witnesses,
+            outputsData: preTx.outputsData,
+            inputs: preTx.inputs,
+            outputs: preTx.outputs.map((output, index) => index === outputIndex
+                ? {
+                    lock,
+                    type: ckbfsTypeScript,
+                    capacity: output.capacity,
+                }
+                : output),
+        });
+        return tx;
+    }
+    else {
+        // If typeID was already set properly, just reset the first witness for signing
+        const tx = core_1.Transaction.from({
+            cellDeps: preTx.cellDeps,
+            witnesses: preTx.witnesses,
+            outputsData: preTx.outputsData,
+            inputs: preTx.inputs,
+            outputs: preTx.outputs,
+        });
+        return tx;
+    }
+}
+/**
+ * Prepares a transaction for appending content to a CKBFS 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 prepareAppendTransaction(options) {
+    const { from, ckbfsCell, contentChunks, 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);
+    // 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 = (0, witness_1.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 (0, checksum_1.updateChecksum)(data.checksum, combinedContent);
+    // Calculate the actual witness indices where our content is placed
+    const contentStartIndex = from?.witnesses.length || 1;
+    const witnessIndices = Array.from({ length: contentChunks.length }, (_, i) => contentStartIndex + i);
+    // Create backlink for the current state based on version
+    let newBackLink;
+    if (version === constants_1.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),
+            checksum: data.checksum,
+            txHash: outPoint.txHash,
+        };
+    }
+    else {
+        // V2 format: Use indexes field (array of numbers)
+        newBackLink = {
+            // In V2, field order is indexes, checksum, txHash
+            // and indexes is an array of numbers
+            indexes: data.indexes || (data.index ? [data.index] : []),
+            checksum: data.checksum,
+            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;
+    if (version === constants_1.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 = molecule_1.CKBFSData.pack({
+            index: witnessIndices[0], // Use only the first index as a number
+            checksum: contentChecksum,
+            contentType: data.contentType,
+            filename: data.filename,
+            backLinks,
+        }, constants_1.ProtocolVersion.V1); // Explicitly use V1 for packing
+    }
+    else {
+        // In V2, indexes is an array of witness indices
+        outputData = molecule_1.CKBFSData.pack({
+            indexes: witnessIndices,
+            checksum: contentChecksum,
+            contentType: data.contentType,
+            filename: data.filename,
+            backLinks,
+        }, constants_1.ProtocolVersion.V2); // Explicitly use V2 for packing
+    }
+    // Calculate the required capacity for the output cell
+    // 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;
+    // 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;
+    // 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: {
+                            txHash: outPoint.txHash,
+                            index: outPoint.index,
+                        },
+                        since: "0x0",
+                    },
+                ]
+                : [
+                    ...from.inputs,
+                    {
+                        previousOutput: {
+                            txHash: outPoint.txHash,
+                            index: outPoint.index,
+                        },
+                        since: "0x0",
+                    },
+                ],
+            outputs: from.outputs.length === 0
+                ? [
+                    {
+                        lock,
+                        type,
+                        capacity: outputCapacity,
+                    },
+                ]
+                : [
+                    ...from.outputs,
+                    {
+                        lock,
+                        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: {
+                        txHash: outPoint.txHash,
+                        index: outPoint.index,
+                    },
+                    since: "0x0",
+                },
+            ],
+            outputs: [
+                {
+                    lock,
+                    type,
+                    capacity: outputCapacity,
+                },
+            ],
+            outputsData: [outputData],
+            witnesses: [
+                [], // Empty secp witness for signing
+                ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+            ],
+        });
+    }
+    // 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 file
@@ -156,7 +430,44 @@ 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, feeRate, } = options;
+    const { lock } = ckbfsCell;
+    // Use prepareAppendTransaction to create the base transaction
+    const { tx: preTx, outputIndex } = await prepareAppendTransaction(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 file
+ * @param signer The signer to use for the transaction
+ * @param options Options for appending content
+ * @returns Promise resolving to the created transaction
+ */
+async function createAppendTransactionDry(signer, options) {
+    const { ckbfsCell, contentChunks, 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);
@@ -225,11 +536,6 @@ async function createAppendTransaction(signer, options) {
             backLinks,
         }, constants_1.ProtocolVersion.V2); // Explicitly use V2 for packing
     }
-    // Pack the original data to get its size - use the appropriate version
-    const originalData = molecule_1.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:
     // 1. The output data size
@@ -271,12 +577,14 @@ async function createAppendTransaction(signer, options) {
         depType: "depGroup",
     });
     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`);
-        // Add more inputs to cover the increased capacity
-        await tx.completeInputsByCapacity(signer);
-    }
+    // // If we need more capacity than the original cell had, add additional inputs
+    // if (outputCapacity > capacity) {
+    //   console.log(
+    //     `Need additional capacity: ${outputCapacity - capacity} shannons`,
+    //   );
+    //   // Add more inputs to cover the increased capacity
+    //   await tx.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()) {
@@ -291,7 +599,7 @@ async function createAppendTransaction(signer, options) {
     }
     tx.witnesses = witnesses;
     // Complete fee
-    await tx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
+    //await tx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
     return tx;
 }
 /**

package/examples/publish.ts CHANGED Viewed

@@ -6,11 +6,11 @@ const privateKey = process.env.CKB_PRIVATE_KEY || 'your-private-key-here';
 // Initialize the SDK with network and version options
 const ckbfs = new CKBFS(
   privateKey,
-  NetworkType.Mainnet, // Use testnet
+  NetworkType.Testnet, // Use testnet
   {
     version: ProtocolVersion.V2, // Use the latest version (V2)
     chunkSize: 30 * 1024, // 30KB chunks
-    useTypeID: false // Use code hash instead of type ID
+    useTypeID: false, // Use code hash instead of type ID
   }
 );

package/package.json CHANGED Viewed

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

package/src/index.ts CHANGED Viewed

@@ -15,7 +15,10 @@ import {
 import {
   createCKBFSCell,
   createPublishTransaction as utilCreatePublishTransaction,
+  preparePublishTransaction,
   createAppendTransaction as utilCreateAppendTransaction,
+  prepareAppendTransaction,
+  createAppendTransactionDry,
   publishCKBFS as utilPublishCKBFS,
   appendCKBFS as utilAppendCKBFS,
   CKBFSCellOptions,
@@ -122,6 +125,7 @@ export interface CKBFSOptions {
   version?: ProtocolVersionType;
   useTypeID?: boolean;
   network?: NetworkType;
+  rpcUrl?: string;
 }
 /**
@@ -133,6 +137,7 @@ export class CKBFS {
   private network: NetworkType;
   private version: ProtocolVersionType;
   private useTypeID: boolean;
+  private rpcUrl: string;
   /**
    * Creates a new CKBFS SDK instance
@@ -159,13 +164,18 @@ export class CKBFS {
       const client =
         network === "mainnet"
-          ? new ClientPublicMainnet()
-          : new ClientPublicTestnet();
+          ? new ClientPublicMainnet({
+            url: opts.rpcUrl,
+          })
+          : new ClientPublicTestnet({
+            url: opts.rpcUrl,
+          });
       this.signer = new SignerCkbPrivateKey(client, privateKey);
       this.network = network;
       this.chunkSize = opts.chunkSize || 30 * 1024;
       this.version = opts.version || DEFAULT_VERSION;
       this.useTypeID = opts.useTypeID || false;
+      this.rpcUrl = opts.rpcUrl || client.url;
     } else {
       // Initialize with signer
       this.signer = signerOrPrivateKey;
@@ -175,6 +185,7 @@ export class CKBFS {
       this.chunkSize = opts.chunkSize || 30 * 1024;
       this.version = opts.version || DEFAULT_VERSION;
       this.useTypeID = opts.useTypeID || false;
+      this.rpcUrl = opts.rpcUrl || this.signer.client.url;
     }
   }
@@ -519,10 +530,12 @@ export {
   // Transaction utilities (Exporting original names from transaction.ts)
   createCKBFSCell,
   utilCreatePublishTransaction as createPublishTransaction,
+  preparePublishTransaction,
   utilCreateAppendTransaction as createAppendTransaction,
+  prepareAppendTransaction,
   utilPublishCKBFS as publishCKBFS,
   utilAppendCKBFS as appendCKBFS,
+  createAppendTransactionDry,
   // File utilities
   readFile,
   readFileAsText,

package/src/utils/transaction.ts CHANGED Viewed

@@ -34,6 +34,7 @@ export interface CKBFSCellOptions {
 export interface PublishOptions extends CKBFSCellOptions {
   contentChunks: Uint8Array[];
   feeRate?: number;
+  from?: Transaction;
 }
 /**
@@ -51,6 +52,7 @@ export interface AppendOptions {
   feeRate?: number;
   network?: NetworkType;
   version?: ProtocolVersionType;
+  from?: Transaction;
 }
 /**
@@ -100,29 +102,27 @@ export function createCKBFSCell(options: CKBFSCellOptions) {
 }
 /**
- * Creates a transaction for publishing a file to CKBFS
- * @param signer The signer to use for the transaction
+ * Prepares a transaction for publishing a file to CKBFS without fee and change handling
+ * You will need to manually set the typeID if you did not provide inputs, or just check is return value emptyTypeID is true
  * @param options Options for publishing the file
- * @returns Promise resolving to the created transaction
+ * @returns Promise resolving to the prepared transaction and the output index of CKBFS Cell
  */
-export async function createPublishTransaction(
-  signer: Signer,
+export async function preparePublishTransaction(
   options: PublishOptions,
-): Promise<Transaction> {
+): Promise<{tx: Transaction, outputIndex: number, emptyTypeID: boolean}> { // if emptyTypeID is true, you shall manually set the typeID after
   const {
+    from,
     contentChunks,
     contentType,
     filename,
     lock,
     capacity,
-    feeRate,
     network = DEFAULT_NETWORK,
     version = DEFAULT_VERSION,
     useTypeID = false,
   } = options;
   // Calculate checksum for the combined content
-  const textEncoder = new TextEncoder();
   const combinedContent = Buffer.concat(contentChunks);
   const checksum = await calculateChecksum(combinedContent);
@@ -132,9 +132,8 @@ export async function createPublishTransaction(
   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 contentStartIndex = from?.witnesses.length || 1;
   const witnessIndices = Array.from(
     { length: contentChunks.length },
     (_, i) => contentStartIndex + i,
@@ -187,24 +186,71 @@ export async function createPublishTransaction(
         8,
     ) * 100000000n;
   // Create pre transaction without cell deps initially
-  const preTx = Transaction.from({
-    outputs: [
-      createCKBFSCell({
-        contentType,
-        filename,
-        lock,
-        network,
-        version,
-        useTypeID,
-        capacity: ckbfsCellSize || capacity,
-      }),
-    ],
-    witnesses: [
-      [], // Empty secp witness for signing
-      ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
-    ],
-    outputsData: [outputData],
-  });
+  let preTx: Transaction;
+  if(from) {
+    // If from is not empty, inject/merge the fields
+    preTx = Transaction.from({
+      ...from,
+      outputs: from.outputs.length === 0
+        ? [
+            createCKBFSCell({
+              contentType,
+              filename,
+              lock,
+              network,
+              version,
+              useTypeID,
+              capacity: ckbfsCellSize || capacity,
+            }),
+          ]
+        : [
+            ...from.outputs,
+            createCKBFSCell({
+              contentType,
+              filename,
+              lock,
+              network,
+              version,
+              useTypeID,
+              capacity: ckbfsCellSize || capacity,
+            }),
+          ],
+      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")}`),
+          ],
+      outputsData: from.outputsData.length === 0
+        ? [outputData]
+        : [
+            ...from.outputsData,
+            outputData,
+          ],
+    });
+  } else {
+      preTx = Transaction.from({
+        outputs: [
+          createCKBFSCell({
+            contentType,
+            filename,
+            lock,
+            network,
+            version,
+            useTypeID,
+            capacity: ckbfsCellSize || capacity,
+          }),
+        ],
+        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({
@@ -215,17 +261,9 @@ export async function createPublishTransaction(
     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);
+  const outputIndex = from ? from.outputs.length : 0;
+  const args = preTx.inputs.length > 0 ? ccc.hashTypeId(preTx.inputs[0], outputIndex) : "0x0000000000000000000000000000000000000000000000000000000000000000";
   // Create CKBFS type script with type ID
   const ckbfsTypeScript = new Script(
@@ -237,23 +275,308 @@ export async function createPublishTransaction(
   // 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),
-    ],
+    witnesses: preTx.witnesses,
     outputsData: preTx.outputsData,
     inputs: preTx.inputs,
-    outputs: [
+    outputs: outputIndex === 0
+      ? [
+          {
+            lock,
+            type: ckbfsTypeScript,
+            capacity: preTx.outputs[outputIndex].capacity,
+          },
+        ]
+      : [
+          ...preTx.outputs.slice(0, outputIndex), // Include rest of outputs (e.g., change)
+          {
+            lock,
+            type: ckbfsTypeScript,
+            capacity: preTx.outputs[outputIndex].capacity,
+          },
+        ],
+  });
+  return {tx, outputIndex, emptyTypeID: args === "0x0000000000000000000000000000000000000000000000000000000000000000"};
+}
+/**
+ * Creates a transaction for publishing a file to CKBFS
+ * @param signer The signer to use for the transaction
+ * @param options Options for publishing the file
+ * @returns Promise resolving to the created transaction
+ */
+export async function createPublishTransaction(
+  signer: Signer,
+  options: PublishOptions,
+): Promise<Transaction> {
+  const {
+    feeRate,
+    lock,
+  } = options;
+  // Use preparePublishTransaction to create the base transaction
+  const { tx: preTx, outputIndex, emptyTypeID } = await preparePublishTransaction(options);
+  // Complete inputs by capacity
+  await preTx.completeInputsByCapacity(signer);
+  // Complete fee change to lock
+  await preTx.completeFeeChangeToLock(signer, lock, feeRate || 2000);
+  // If emptyTypeID is true, we need to create the proper type ID args
+  if (emptyTypeID) {
+    // Get CKBFS script config
+    const config = getCKBFSScriptConfig(options.network || DEFAULT_NETWORK, options.version || DEFAULT_VERSION, options.useTypeID || false);
+    // Create type ID args
+    const args = ccc.hashTypeId(preTx.inputs[0], outputIndex);
+    // Create CKBFS type script with type ID
+    const ckbfsTypeScript = new Script(
+      ensureHexPrefix(config.codeHash),
+      config.hashType as any,
+      args,
+    );
+    // Create final transaction with updated type script
+    const tx = Transaction.from({
+      cellDeps: preTx.cellDeps,
+      witnesses: preTx.witnesses,
+      outputsData: preTx.outputsData,
+      inputs: preTx.inputs,
+      outputs: preTx.outputs.map((output, index) =>
+        index === outputIndex
+          ? {
+              lock,
+              type: ckbfsTypeScript,
+              capacity: output.capacity,
+            }
+          : output
+      ),
+    });
+    return tx;
+  } else {
+    // If typeID was already set properly, just reset the first witness for signing
+    const tx = Transaction.from({
+      cellDeps: preTx.cellDeps,
+      witnesses: preTx.witnesses,
+      outputsData: preTx.outputsData,
+      inputs: preTx.inputs,
+      outputs: preTx.outputs,
+    });
+    return tx;
+  }
+}
+/**
+ * Prepares a transaction for appending content to a CKBFS 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 prepareAppendTransaction(
+  options: AppendOptions,
+): Promise<{tx: Transaction, outputIndex: number}> {
+  const {
+    from,
+    ckbfsCell,
+    contentChunks,
+    network = DEFAULT_NETWORK,
+    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);
+  // Calculate the actual witness indices where our content is placed
+  const contentStartIndex = from?.witnesses.length || 1;
+  const witnessIndices = Array.from(
+    { 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),
+      checksum: data.checksum,
+      txHash: outPoint.txHash,
+    };
+  } else {
+    // V2 format: Use indexes field (array of numbers)
+    newBackLink = {
+      // In V2, field order is indexes, checksum, txHash
+      // and indexes is an array of numbers
+      indexes: data.indexes || (data.index ? [data.index] : []),
+      checksum: data.checksum,
+      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(
       {
-        lock,
-        type: ckbfsTypeScript,
-        capacity: preTx.outputs[0].capacity,
+        index: witnessIndices[0], // Use only the first index as a number
+        checksum: contentChecksum,
+        contentType: data.contentType,
+        filename: data.filename,
+        backLinks,
       },
-      ...preTx.outputs.slice(1), // Include rest of outputs (e.g., change)
-    ],
+      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
+  }
+  // Calculate the required capacity for the output cell
+  // 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;
+  // 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;
+  // 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: {
+                txHash: outPoint.txHash,
+                index: outPoint.index,
+              },
+              since: "0x0",
+            },
+          ]
+        : [
+            ...from.inputs,
+            {
+              previousOutput: {
+                txHash: outPoint.txHash,
+                index: outPoint.index,
+              },
+              since: "0x0",
+            },
+          ],
+      outputs: from.outputs.length === 0
+        ? [
+            {
+              lock,
+              type,
+              capacity: outputCapacity,
+            },
+          ]
+        : [
+            ...from.outputs,
+            {
+              lock,
+              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: {
+            txHash: outPoint.txHash,
+            index: outPoint.index,
+          },
+          since: "0x0",
+        },
+      ],
+      outputs: [
+        {
+          lock,
+          type,
+          capacity: outputCapacity,
+        },
+      ],
+      outputsData: [outputData],
+      witnesses: [
+        [], // Empty secp witness for signing
+        ...ckbfsWitnesses.map((w) => `0x${Buffer.from(w).toString("hex")}`),
+      ],
+    });
+  }
+  // Add the CKBFS dep group cell dependency
+  preTx.addCellDeps({
+    outPoint: {
+      txHash: ensureHexPrefix(config.depTxHash),
+      index: config.depIndex || 0,
+    },
+    depType: "depGroup",
   });
-  return tx;
+  const outputIndex = from ? from.outputs.length : 0;
+  return {tx: preTx, outputIndex};
 }
 /**
@@ -268,8 +591,60 @@ export async function createAppendTransaction(
 ): Promise<Transaction> {
   const {
     ckbfsCell,
-    contentChunks,
     feeRate,
+  } = options;
+  const { lock } = ckbfsCell;
+  // Use prepareAppendTransaction to create the base transaction
+  const { tx: preTx, outputIndex } = await prepareAppendTransaction(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 file
+ * @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 createAppendTransactionDry(
+  signer: Signer,
+  options: AppendOptions,
+): Promise<Transaction> {
+  const {
+    ckbfsCell,
+    contentChunks,
     network = DEFAULT_NETWORK,
     version = DEFAULT_VERSION,
   } = options;
@@ -363,12 +738,6 @@ export async function createAppendTransaction(
     ); // 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:
@@ -419,14 +788,14 @@ export async function createAppendTransaction(
   });
   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`,
-    );
-    // Add more inputs to cover the increased capacity
-    await tx.completeInputsByCapacity(signer);
-  }
+  // // If we need more capacity than the original cell had, add additional inputs
+  // if (outputCapacity > capacity) {
+  //   console.log(
+  //     `Need additional capacity: ${outputCapacity - capacity} shannons`,
+  //   );
+  //   // Add more inputs to cover the increased capacity
+  //   await tx.completeInputsByCapacity(signer);
+  // }
   const witnesses: any = [];
   // add empty witness for signer if ckbfs's lock is the same as signer's lock
@@ -446,7 +815,7 @@ export async function createAppendTransaction(
   tx.witnesses = witnesses;
   // Complete fee
-  await tx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
+  //await tx.completeFeeChangeToLock(signer, address.script, feeRate || 2000);
   return tx;
 }