@ckbfs/api 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+import { Script, Signer, Transaction } from "@ckb-ccc/core";
+import { calculateChecksum, verifyChecksum, updateChecksum, verifyWitnessChecksum } from './utils/checksum';
+import { createCKBFSCell, createPublishTransaction, createAppendTransaction, publishCKBFS, appendCKBFS, CKBFSCellOptions, PublishOptions, AppendOptions } from './utils/transaction';
+import { readFile, readFileAsText, readFileAsUint8Array, writeFile, getContentType, splitFileIntoChunks, combineChunksToFile } 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';
+import { NetworkType, ProtocolVersion, 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 } from './utils/constants';
+/**
+ * Custom options for file publishing and appending
+ */
+export interface FileOptions {
+    contentType?: string;
+    filename?: string;
+    capacity?: bigint;
+    feeRate?: number;
+    network?: NetworkType;
+    version?: string;
+    useTypeID?: boolean;
+}
+/**
+ * Configuration options for the CKBFS SDK
+ */
+export interface CKBFSOptions {
+    chunkSize?: number;
+    version?: string;
+    useTypeID?: boolean;
+    network?: NetworkType;
+}
+/**
+ * Main CKBFS SDK class
+ */
+export declare class CKBFS {
+    private signer;
+    private chunkSize;
+    private network;
+    private version;
+    private useTypeID;
+    /**
+     * Creates a new CKBFS SDK instance
+     * @param signerOrPrivateKey The signer instance or CKB private key to use for signing transactions
+     * @param networkOrOptions The network type or configuration options
+     * @param options Additional configuration options when using privateKey
+     */
+    constructor(signerOrPrivateKey: Signer | string, networkOrOptions?: NetworkType | CKBFSOptions, options?: CKBFSOptions);
+    /**
+     * Gets the recommended address object for the signer
+     * @returns Promise resolving to the address object
+     */
+    getAddress(): Promise<import("@ckb-ccc/core").Address>;
+    /**
+     * Gets the lock script for the signer
+     * @returns Promise resolving to the lock script
+     */
+    getLock(): Promise<Script>;
+    /**
+     * Gets the CKBFS script configuration for the current settings
+     * @returns The CKBFS script configuration
+     */
+    getCKBFSConfig(): CKBFSScriptConfig;
+    /**
+     * Publishes a file to CKBFS
+     * @param filePath The path to the file to publish
+     * @param options Options for publishing the file
+     * @returns Promise resolving to the transaction hash
+     */
+    publishFile(filePath: string, options?: FileOptions): Promise<string>;
+    /**
+     * Appends content to an existing CKBFS file
+     * @param filePath The path to the file containing the content to append
+     * @param ckbfsCell The CKBFS cell to append to
+     * @param options Additional options for the append operation
+     * @returns Promise resolving to the transaction hash
+     */
+    appendFile(filePath: string, ckbfsCell: AppendOptions['ckbfsCell'], options?: Omit<FileOptions, 'contentType' | 'filename'>): Promise<string>;
+    /**
+     * Creates a new transaction for publishing a file but doesn't sign or send it
+     * @param filePath The path to the file to publish
+     * @param options Options for publishing the file
+     * @returns Promise resolving to the unsigned transaction
+     */
+    createPublishTransaction(filePath: string, options?: FileOptions): Promise<Transaction>;
+    /**
+     * Creates a new transaction for appending content but doesn't sign or send it
+     * @param filePath The path to the file containing the content to append
+     * @param ckbfsCell The CKBFS cell to append to
+     * @param options Additional options for the append operation
+     * @returns Promise resolving to the unsigned transaction
+     */
+    createAppendTransaction(filePath: string, ckbfsCell: AppendOptions['ckbfsCell'], options?: Omit<FileOptions, 'contentType' | 'filename'>): Promise<Transaction>;
+}
+export { calculateChecksum, verifyChecksum, updateChecksum, verifyWitnessChecksum, createCKBFSCell, createPublishTransaction, createAppendTransaction, publishCKBFS, appendCKBFS, readFile, readFileAsText, readFileAsUint8Array, writeFile, getContentType, splitFileIntoChunks, combineChunksToFile, createCKBFSWitness, createTextCKBFSWitness, extractCKBFSWitnessContent, isCKBFSWitness, createChunkedCKBFSWitnesses, CKBFSData, BackLinkV1, BackLinkV2, CKBFSDataType, BackLinkType, CKBFSCellOptions, PublishOptions, AppendOptions, CKBFS_HEADER, CKBFS_HEADER_STRING, NetworkType, ProtocolVersion, 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

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCKBFSScriptConfig = exports.DEPLOY_TX_HASH = exports.DEP_GROUP_TX_HASH = 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.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;
+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; } });
+Object.defineProperty(exports, "verifyChecksum", { enumerable: true, get: function () { return checksum_1.verifyChecksum; } });
+Object.defineProperty(exports, "updateChecksum", { enumerable: true, get: function () { return checksum_1.updateChecksum; } });
+Object.defineProperty(exports, "verifyWitnessChecksum", { enumerable: true, get: function () { return checksum_1.verifyWitnessChecksum; } });
+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, "createAppendTransaction", { enumerable: true, get: function () { return transaction_1.createAppendTransaction; } });
+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");
+Object.defineProperty(exports, "readFile", { enumerable: true, get: function () { return file_1.readFile; } });
+Object.defineProperty(exports, "readFileAsText", { enumerable: true, get: function () { return file_1.readFileAsText; } });
+Object.defineProperty(exports, "readFileAsUint8Array", { enumerable: true, get: function () { return file_1.readFileAsUint8Array; } });
+Object.defineProperty(exports, "writeFile", { enumerable: true, get: function () { return file_1.writeFile; } });
+Object.defineProperty(exports, "getContentType", { enumerable: true, get: function () { return file_1.getContentType; } });
+Object.defineProperty(exports, "splitFileIntoChunks", { enumerable: true, get: function () { return file_1.splitFileIntoChunks; } });
+Object.defineProperty(exports, "combineChunksToFile", { enumerable: true, get: function () { return file_1.combineChunksToFile; } });
+const witness_1 = require("./utils/witness");
+Object.defineProperty(exports, "createCKBFSWitness", { enumerable: true, get: function () { return witness_1.createCKBFSWitness; } });
+Object.defineProperty(exports, "createTextCKBFSWitness", { enumerable: true, get: function () { return witness_1.createTextCKBFSWitness; } });
+Object.defineProperty(exports, "extractCKBFSWitnessContent", { enumerable: true, get: function () { return witness_1.extractCKBFSWitnessContent; } });
+Object.defineProperty(exports, "isCKBFSWitness", { enumerable: true, get: function () { return witness_1.isCKBFSWitness; } });
+Object.defineProperty(exports, "createChunkedCKBFSWitnesses", { enumerable: true, get: function () { return witness_1.createChunkedCKBFSWitnesses; } });
+const molecule_1 = require("./utils/molecule");
+Object.defineProperty(exports, "CKBFSData", { enumerable: true, get: function () { return molecule_1.CKBFSData; } });
+Object.defineProperty(exports, "BackLinkV1", { enumerable: true, get: function () { return molecule_1.BackLinkV1; } });
+Object.defineProperty(exports, "BackLinkV2", { enumerable: true, get: function () { return molecule_1.BackLinkV2; } });
+Object.defineProperty(exports, "CKBFS_HEADER", { enumerable: true, get: function () { return molecule_1.CKBFS_HEADER; } });
+Object.defineProperty(exports, "CKBFS_HEADER_STRING", { enumerable: true, get: function () { return molecule_1.CKBFS_HEADER_STRING; } });
+const constants_1 = require("./utils/constants");
+Object.defineProperty(exports, "NetworkType", { enumerable: true, get: function () { return constants_1.NetworkType; } });
+Object.defineProperty(exports, "ProtocolVersion", { enumerable: true, get: function () { return constants_1.ProtocolVersion; } });
+Object.defineProperty(exports, "DEFAULT_NETWORK", { enumerable: true, get: function () { return constants_1.DEFAULT_NETWORK; } });
+Object.defineProperty(exports, "DEFAULT_VERSION", { enumerable: true, get: function () { return constants_1.DEFAULT_VERSION; } });
+Object.defineProperty(exports, "CKBFS_CODE_HASH", { enumerable: true, get: function () { return constants_1.CKBFS_CODE_HASH; } });
+Object.defineProperty(exports, "CKBFS_TYPE_ID", { enumerable: true, get: function () { return constants_1.CKBFS_TYPE_ID; } });
+Object.defineProperty(exports, "ADLER32_CODE_HASH", { enumerable: true, get: function () { return constants_1.ADLER32_CODE_HASH; } });
+Object.defineProperty(exports, "ADLER32_TYPE_ID", { enumerable: true, get: function () { return constants_1.ADLER32_TYPE_ID; } });
+Object.defineProperty(exports, "DEP_GROUP_TX_HASH", { enumerable: true, get: function () { return constants_1.DEP_GROUP_TX_HASH; } });
+Object.defineProperty(exports, "DEPLOY_TX_HASH", { enumerable: true, get: function () { return constants_1.DEPLOY_TX_HASH; } });
+Object.defineProperty(exports, "getCKBFSScriptConfig", { enumerable: true, get: function () { return constants_1.getCKBFSScriptConfig; } });
+/**
+ * Main CKBFS SDK class
+ */
+class CKBFS {
+    /**
+     * Creates a new CKBFS SDK instance
+     * @param signerOrPrivateKey The signer instance or CKB private key to use for signing transactions
+     * @param networkOrOptions The network type or configuration options
+     * @param options Additional configuration options when using privateKey
+     */
+    constructor(signerOrPrivateKey, networkOrOptions = constants_1.DEFAULT_NETWORK, options) {
+        // Determine if first parameter is a Signer or privateKey
+        if (typeof signerOrPrivateKey === 'string') {
+            // Initialize with private key
+            const privateKey = signerOrPrivateKey;
+            const network = typeof networkOrOptions === 'string' ? networkOrOptions : constants_1.DEFAULT_NETWORK;
+            const opts = options || (typeof networkOrOptions === 'object' ? networkOrOptions : {});
+            const client = new core_1.ClientPublicTestnet();
+            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;
+        }
+        else {
+            // Initialize with signer
+            this.signer = signerOrPrivateKey;
+            const opts = typeof networkOrOptions === 'object' ? networkOrOptions : {};
+            this.network = opts.network || constants_1.DEFAULT_NETWORK;
+            this.chunkSize = opts.chunkSize || 30 * 1024;
+            this.version = opts.version || constants_1.DEFAULT_VERSION;
+            this.useTypeID = opts.useTypeID || false;
+        }
+    }
+    /**
+     * Gets the recommended address object for the signer
+     * @returns Promise resolving to the address object
+     */
+    async getAddress() {
+        return this.signer.getRecommendedAddressObj();
+    }
+    /**
+     * Gets the lock script for the signer
+     * @returns Promise resolving to the lock script
+     */
+    async getLock() {
+        const address = await this.getAddress();
+        return address.script;
+    }
+    /**
+     * Gets the CKBFS script configuration for the current settings
+     * @returns The CKBFS script configuration
+     */
+    getCKBFSConfig() {
+        return (0, constants_1.getCKBFSScriptConfig)(this.network, this.version, this.useTypeID);
+    }
+    /**
+     * Publishes a file to CKBFS
+     * @param filePath The path to the file to publish
+     * @param options Options for publishing the file
+     * @returns Promise resolving to the transaction hash
+     */
+    async publishFile(filePath, options = {}) {
+        // Read the file and split into chunks
+        const fileContent = (0, file_1.readFileAsUint8Array)(filePath);
+        const contentChunks = [];
+        for (let i = 0; i < fileContent.length; i += this.chunkSize) {
+            contentChunks.push(fileContent.slice(i, i + this.chunkSize));
+        }
+        // Get the lock script
+        const lock = await this.getLock();
+        // Determine content type if not provided
+        const contentType = options.contentType || (0, file_1.getContentType)(filePath);
+        // Use the filename from the path if not provided
+        const pathParts = filePath.split(/[\\\/]/);
+        const filename = options.filename || pathParts[pathParts.length - 1];
+        // Create and sign the transaction
+        const tx = await (0, transaction_1.publishCKBFS)(this.signer, {
+            contentChunks,
+            contentType,
+            filename,
+            lock,
+            capacity: options.capacity,
+            feeRate: options.feeRate,
+            network: options.network || this.network,
+            version: options.version || this.version,
+            useTypeID: options.useTypeID !== undefined ? options.useTypeID : this.useTypeID
+        });
+        console.log('tx', tx.stringify());
+        // Send the transaction
+        const txHash = await this.signer.sendTransaction(tx);
+        return txHash;
+    }
+    /**
+     * Appends content to an existing CKBFS file
+     * @param filePath The path to the file containing the content to append
+     * @param ckbfsCell The CKBFS cell to append to
+     * @param options Additional options for the append operation
+     * @returns Promise resolving to the transaction hash
+     */
+    async appendFile(filePath, ckbfsCell, options = {}) {
+        // Read the file and split into chunks
+        const fileContent = (0, file_1.readFileAsUint8Array)(filePath);
+        const contentChunks = [];
+        for (let i = 0; i < fileContent.length; i += this.chunkSize) {
+            contentChunks.push(fileContent.slice(i, i + this.chunkSize));
+        }
+        // Create and sign the transaction
+        const tx = await (0, transaction_1.appendCKBFS)(this.signer, {
+            ckbfsCell,
+            contentChunks,
+            feeRate: options.feeRate,
+            network: options.network || this.network,
+            version: options.version || this.version
+        });
+        // Send the transaction
+        const txHash = await this.signer.sendTransaction(tx);
+        return txHash;
+    }
+    /**
+     * Creates a new transaction for publishing a file but doesn't sign or send it
+     * @param filePath The path to the file to publish
+     * @param options Options for publishing the file
+     * @returns Promise resolving to the unsigned transaction
+     */
+    async createPublishTransaction(filePath, options = {}) {
+        // Read the file and split into chunks
+        const fileContent = (0, file_1.readFileAsUint8Array)(filePath);
+        const contentChunks = [];
+        for (let i = 0; i < fileContent.length; i += this.chunkSize) {
+            contentChunks.push(fileContent.slice(i, i + this.chunkSize));
+        }
+        // Get the lock script
+        const lock = await this.getLock();
+        // Determine content type if not provided
+        const contentType = options.contentType || (0, file_1.getContentType)(filePath);
+        // Use the filename from the path if not provided
+        const pathParts = filePath.split(/[\\\/]/);
+        const filename = options.filename || pathParts[pathParts.length - 1];
+        // Create the transaction
+        return (0, transaction_1.createPublishTransaction)(this.signer, {
+            contentChunks,
+            contentType,
+            filename,
+            lock,
+            capacity: options.capacity,
+            feeRate: options.feeRate,
+            network: options.network || this.network,
+            version: options.version || this.version,
+            useTypeID: options.useTypeID !== undefined ? options.useTypeID : this.useTypeID
+        });
+    }
+    /**
+     * Creates a new transaction for appending content but doesn't sign or send it
+     * @param filePath The path to the file containing the content to append
+     * @param ckbfsCell The CKBFS cell to append to
+     * @param options Additional options for the append operation
+     * @returns Promise resolving to the unsigned transaction
+     */
+    async createAppendTransaction(filePath, ckbfsCell, options = {}) {
+        // Read the file and split into chunks
+        const fileContent = (0, file_1.readFileAsUint8Array)(filePath);
+        const contentChunks = [];
+        for (let i = 0; i < fileContent.length; i += this.chunkSize) {
+            contentChunks.push(fileContent.slice(i, i + this.chunkSize));
+        }
+        // Create the transaction
+        return (0, transaction_1.createAppendTransaction)(this.signer, {
+            ckbfsCell,
+            contentChunks,
+            feeRate: options.feeRate,
+            network: options.network || this.network,
+            version: options.version || this.version
+        });
+    }
+}
+exports.CKBFS = CKBFS;

package/dist/utils/checksum.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Utility functions for Adler32 checksum generation and verification
+ */
+/**
+ * Calculates Adler32 checksum for the provided data
+ * @param data The data to calculate checksum for
+ * @returns Promise resolving to the calculated checksum as a number
+ */
+export declare function calculateChecksum(data: Uint8Array): Promise<number>;
+/**
+ * Updates an existing checksum with new data
+ * @param previousChecksum The existing checksum to update
+ * @param newData The new data to add to the checksum
+ * @returns Promise resolving to the updated checksum as a number
+ */
+export declare function updateChecksum(previousChecksum: number, newData: Uint8Array): Promise<number>;
+/**
+ * Verifies if a given checksum matches the expected checksum for the data
+ * @param data The data to verify
+ * @param expectedChecksum The expected checksum
+ * @returns Promise resolving to a boolean indicating whether the checksum is valid
+ */
+export declare function verifyChecksum(data: Uint8Array, expectedChecksum: number): Promise<boolean>;
+/**
+ * Verifies the checksum of a CKBFS witness
+ * @param witness The witness bytes
+ * @param expectedChecksum The expected checksum
+ * @param backlinks Optional backlinks to use for checksum verification
+ * @returns Promise resolving to a boolean indicating whether the checksum is valid
+ */
+export declare function verifyWitnessChecksum(witness: Uint8Array, expectedChecksum: number, backlinks?: {
+    checksum: number;
+}[]): Promise<boolean>;

package/dist/utils/checksum.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateChecksum = calculateChecksum;
+exports.updateChecksum = updateChecksum;
+exports.verifyChecksum = verifyChecksum;
+exports.verifyWitnessChecksum = verifyWitnessChecksum;
+const hash_wasm_1 = require("hash-wasm");
+/**
+ * Utility functions for Adler32 checksum generation and verification
+ */
+/**
+ * Calculates Adler32 checksum for the provided data
+ * @param data The data to calculate checksum for
+ * @returns Promise resolving to the calculated checksum as a number
+ */
+async function calculateChecksum(data) {
+    const checksumString = await (0, hash_wasm_1.adler32)(data);
+    const checksumBuffer = Buffer.from(checksumString, 'hex');
+    return checksumBuffer.readUInt32BE();
+}
+/**
+ * Updates an existing checksum with new data
+ * @param previousChecksum The existing checksum to update
+ * @param newData The new data to add to the checksum
+ * @returns Promise resolving to the updated checksum as a number
+ */
+async function updateChecksum(previousChecksum, newData) {
+    // In a real implementation, this would require the actual Adler32 state recovery
+    // For now, we're simply concatenating the previousChecksum as a hex string with the new data
+    // and calculating a new checksum
+    const checksumBytes = Buffer.alloc(4);
+    checksumBytes.writeUInt32BE(previousChecksum);
+    // Concatenate the previous checksum bytes with the new data
+    const combinedData = Buffer.concat([checksumBytes, Buffer.from(newData)]);
+    // Calculate the new checksum
+    return calculateChecksum(combinedData);
+}
+/**
+ * Verifies if a given checksum matches the expected checksum for the data
+ * @param data The data to verify
+ * @param expectedChecksum The expected checksum
+ * @returns Promise resolving to a boolean indicating whether the checksum is valid
+ */
+async function verifyChecksum(data, expectedChecksum) {
+    const calculatedChecksum = await calculateChecksum(data);
+    return calculatedChecksum === expectedChecksum;
+}
+/**
+ * Verifies the checksum of a CKBFS witness
+ * @param witness The witness bytes
+ * @param expectedChecksum The expected checksum
+ * @param backlinks Optional backlinks to use for checksum verification
+ * @returns Promise resolving to a boolean indicating whether the checksum is valid
+ */
+async function verifyWitnessChecksum(witness, expectedChecksum, backlinks = []) {
+    // Extract the content bytes from the witness (skip the CKBFS header and version)
+    const contentBytes = witness.slice(6);
+    // If backlinks are provided, use the last backlink's checksum
+    if (backlinks.length > 0) {
+        const lastBacklink = backlinks[backlinks.length - 1];
+        const updatedChecksum = await updateChecksum(lastBacklink.checksum, contentBytes);
+        return updatedChecksum === expectedChecksum;
+    }
+    // Otherwise, calculate checksum from scratch
+    return verifyChecksum(contentBytes, expectedChecksum);
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CKBFS protocol deployment constants
+ */
+export declare enum NetworkType {
+    Mainnet = "mainnet",
+    Testnet = "testnet"
+}
+export declare const ProtocolVersion: {
+    readonly V1: "20240906.ce6724722cf6";
+    readonly V2: "20241025.db973a8e8032";
+};
+export type ProtocolVersionType = typeof ProtocolVersion[keyof typeof ProtocolVersion];
+export declare const CKBFS_CODE_HASH: Record<NetworkType, Record<string, string>>;
+export declare const CKBFS_TYPE_ID: Record<NetworkType, Record<string, string>>;
+export declare const ADLER32_CODE_HASH: Record<NetworkType, Record<string, string>>;
+export declare const ADLER32_TYPE_ID: Record<NetworkType, Record<string, string>>;
+export declare const DEP_GROUP_TX_HASH: Record<NetworkType, Record<string, string>>;
+export declare const DEPLOY_TX_HASH: Record<NetworkType, Record<string, {
+    ckbfs: string;
+    adler32: string;
+}>>;
+export declare const DEFAULT_VERSION: "20241025.db973a8e8032";
+export declare const DEFAULT_NETWORK = NetworkType.Testnet;
+export interface CKBFSScriptConfig {
+    codeHash: string;
+    hashType: 'data1' | 'type';
+    depTxHash: string;
+    depIndex?: number;
+}
+/**
+ * Get CKBFS script configuration for a specific network and version
+ * @param network Network type (mainnet or testnet)
+ * @param version Protocol version (default: latest version)
+ * @param useTypeID Whether to use type ID instead of code hash (default: false)
+ * @returns CKBFS script configuration
+ */
+export declare function getCKBFSScriptConfig(network?: NetworkType, version?: string, useTypeID?: boolean): CKBFSScriptConfig;

package/dist/utils/constants.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * CKBFS protocol deployment constants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NETWORK = exports.DEFAULT_VERSION = exports.DEPLOY_TX_HASH = exports.DEP_GROUP_TX_HASH = exports.ADLER32_TYPE_ID = exports.ADLER32_CODE_HASH = exports.CKBFS_TYPE_ID = exports.CKBFS_CODE_HASH = exports.ProtocolVersion = exports.NetworkType = void 0;
+exports.getCKBFSScriptConfig = getCKBFSScriptConfig;
+var NetworkType;
+(function (NetworkType) {
+    NetworkType["Mainnet"] = "mainnet";
+    NetworkType["Testnet"] = "testnet";
+})(NetworkType || (exports.NetworkType = NetworkType = {}));
+// Use string literals for version values to avoid TypeScript indexing issues
+exports.ProtocolVersion = {
+    V1: '20240906.ce6724722cf6', // Original version, compact and simple, suitable for small files
+    V2: '20241025.db973a8e8032' // New version, more features and can do complex operations
+};
+// CKBFS Type Script Constants
+exports.CKBFS_CODE_HASH = {
+    [NetworkType.Mainnet]: {
+        [exports.ProtocolVersion.V2]: '0x31e6376287d223b8c0410d562fb422f04d1d617b2947596a14c3d2efb7218d3a'
+    },
+    [NetworkType.Testnet]: {
+        [exports.ProtocolVersion.V1]: '0xe8905ad29a02cf8befa9c258f4f941773839a618d75a64afc22059de9413f712',
+        [exports.ProtocolVersion.V2]: '0x31e6376287d223b8c0410d562fb422f04d1d617b2947596a14c3d2efb7218d3a'
+    }
+};
+exports.CKBFS_TYPE_ID = {
+    [NetworkType.Mainnet]: {
+        [exports.ProtocolVersion.V2]: '0xfd2058c9a0c0183354cf637e25d2707ffa9bb6fa2ba9b29f4ebc6be3e54ad7eb'
+    },
+    [NetworkType.Testnet]: {
+        [exports.ProtocolVersion.V1]: '0x88ef4d436af35684a27edda0d44dd8771318330285f90f02d13606e095aea86f',
+        [exports.ProtocolVersion.V2]: '0x7c6dcab8268201f064dc8676b5eafa60ca2569e5c6209dcbab0eb64a9cb3aaa3'
+    }
+};
+// Adler32 Hasher Constants
+exports.ADLER32_CODE_HASH = {
+    [NetworkType.Mainnet]: {
+        [exports.ProtocolVersion.V2]: '0x2138683f76944437c0c643664120d620bdb5858dd6c9d1d156805e279c2c536f'
+    },
+    [NetworkType.Testnet]: {
+        [exports.ProtocolVersion.V1]: '0x8af42cd329cf1bcffb4c73b48252e99cb32346fdbc1cdaa5ae1d000232d47e84',
+        [exports.ProtocolVersion.V2]: '0x2138683f76944437c0c643664120d620bdb5858dd6c9d1d156805e279c2c536f'
+    }
+};
+exports.ADLER32_TYPE_ID = {
+    [NetworkType.Mainnet]: {
+        [exports.ProtocolVersion.V2]: '0x641c01d590833a3f5471bd441651d9f2a8a200141949cdfeef2d68d8094c5876'
+    },
+    [NetworkType.Testnet]: {
+        [exports.ProtocolVersion.V1]: '0xccf29a0d8e860044a3d2f6a6e709f6572f77e4fe245fadd212fc342337048d60',
+        [exports.ProtocolVersion.V2]: '0x5f73f128be76e397f5a3b56c94ca16883a8ee91b498bc0ee80473818318c05ac'
+    }
+};
+// Dep Group Transaction Constants
+exports.DEP_GROUP_TX_HASH = {
+    [NetworkType.Mainnet]: {
+        [exports.ProtocolVersion.V2]: '0xfab07962ed7178ed88d450774e2a6ecd50bae856bdb9b692980be8c5147d1bfa'
+    },
+    [NetworkType.Testnet]: {
+        [exports.ProtocolVersion.V1]: '0xc8fd44aba36f0c4b37536b6c7ea3b88df65fa97e02f77cd33b9bf20bf241a09b',
+        [exports.ProtocolVersion.V2]: '0x469af0d961dcaaedd872968a9388b546717a6ccfa47b3165b3f9c981e9d66aaa'
+    }
+};
+// Deploy Transaction Constants
+exports.DEPLOY_TX_HASH = {
+    [NetworkType.Mainnet]: {
+        [exports.ProtocolVersion.V2]: {
+            ckbfs: '0xc9b6698f44c3b80e7e1c48823b2714e432b93f0206ffaf9df885d23267ed2ebc',
+            adler32: '0xc9b6698f44c3b80e7e1c48823b2714e432b93f0206ffaf9df885d23267ed2ebc'
+        }
+    },
+    [NetworkType.Testnet]: {
+        [exports.ProtocolVersion.V1]: {
+            ckbfs: '0xde8eb09151fbcdcba398423159ce348cc89a38a736de3fd0960b18b084465382',
+            adler32: '0x042f264d7397a181437b51ff9981cf536f252ab5740b61ce52ce31ada04ed54b'
+        },
+        [exports.ProtocolVersion.V2]: {
+            ckbfs: '0x2c8c9ad3134743368b5a79977648f96c5bd0aba187021a72fb624301064d3616',
+            adler32: '0x2c8c9ad3134743368b5a79977648f96c5bd0aba187021a72fb624301064d3616'
+        }
+    }
+};
+// Default values - V2 is now the default
+exports.DEFAULT_VERSION = exports.ProtocolVersion.V2;
+exports.DEFAULT_NETWORK = NetworkType.Testnet;
+/**
+ * Get CKBFS script configuration for a specific network and version
+ * @param network Network type (mainnet or testnet)
+ * @param version Protocol version (default: latest version)
+ * @param useTypeID Whether to use type ID instead of code hash (default: false)
+ * @returns CKBFS script configuration
+ */
+function getCKBFSScriptConfig(network = exports.DEFAULT_NETWORK, version = exports.DEFAULT_VERSION, useTypeID = false) {
+    return {
+        codeHash: useTypeID
+            ? exports.CKBFS_TYPE_ID[network][version]
+            : exports.CKBFS_CODE_HASH[network][version],
+        hashType: useTypeID ? 'type' : 'data1',
+        depTxHash: exports.DEP_GROUP_TX_HASH[network][version],
+        depIndex: 0
+    };
+}

package/dist/utils/file.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Utility functions for file operations
+ */
+/**
+ * Reads a file from the file system
+ * @param filePath The path to the file to read
+ * @returns Buffer containing the file contents
+ */
+export declare function readFile(filePath: string): Buffer;
+/**
+ * Reads a file as text from the file system
+ * @param filePath The path to the file to read
+ * @returns String containing the file contents
+ */
+export declare function readFileAsText(filePath: string): string;
+/**
+ * Reads a file as Uint8Array from the file system
+ * @param filePath The path to the file to read
+ * @returns Uint8Array containing the file contents
+ */
+export declare function readFileAsUint8Array(filePath: string): Uint8Array;
+/**
+ * Writes data to a file in the file system
+ * @param filePath The path to write the file to
+ * @param data The data to write to the file
+ */
+export declare function writeFile(filePath: string, data: Buffer | string): void;
+/**
+ * Gets the MIME content type based on file extension
+ * @param filePath The path to the file
+ * @returns The MIME content type for the file
+ */
+export declare function getContentType(filePath: string): string;
+/**
+ * Splits a file into chunks of a specific size
+ * @param filePath The path to the file to split
+ * @param chunkSize The maximum size of each chunk in bytes
+ * @returns Array of Uint8Array chunks
+ */
+export declare function splitFileIntoChunks(filePath: string, chunkSize: number): Uint8Array[];
+/**
+ * Combines chunks into a single file
+ * @param chunks Array of chunks to combine
+ * @param outputPath The path to write the combined file to
+ */
+export declare function combineChunksToFile(chunks: Uint8Array[], outputPath: string): void;