@ckbfs/api 1.0.0 → 1.0.2

package/dist/utils/file.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = readFile;
+exports.readFileAsText = readFileAsText;
+exports.readFileAsUint8Array = readFileAsUint8Array;
+exports.writeFile = writeFile;
+exports.getContentType = getContentType;
+exports.splitFileIntoChunks = splitFileIntoChunks;
+exports.combineChunksToFile = combineChunksToFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 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
+ */
+function readFile(filePath) {
+    return fs_1.default.readFileSync(filePath);
+}
+/**
+ * Reads a file as text from the file system
+ * @param filePath The path to the file to read
+ * @returns String containing the file contents
+ */
+function readFileAsText(filePath) {
+    return fs_1.default.readFileSync(filePath, 'utf-8');
+}
+/**
+ * Reads a file as Uint8Array from the file system
+ * @param filePath The path to the file to read
+ * @returns Uint8Array containing the file contents
+ */
+function readFileAsUint8Array(filePath) {
+    const buffer = fs_1.default.readFileSync(filePath);
+    return new Uint8Array(buffer);
+}
+/**
+ * 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
+ */
+function writeFile(filePath, data) {
+    // Ensure the directory exists
+    const dirPath = path_1.default.dirname(filePath);
+    if (!fs_1.default.existsSync(dirPath)) {
+        fs_1.default.mkdirSync(dirPath, { recursive: true });
+    }
+    fs_1.default.writeFileSync(filePath, data);
+}
+/**
+ * Gets the MIME content type based on file extension
+ * @param filePath The path to the file
+ * @returns The MIME content type for the file
+ */
+function getContentType(filePath) {
+    const extension = path_1.default.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.txt': 'text/plain',
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.pdf': 'application/pdf',
+        '.mp3': 'audio/mpeg',
+        '.mp4': 'video/mp4',
+        '.wav': 'audio/wav',
+        '.xml': 'application/xml',
+        '.zip': 'application/zip',
+        '.md': 'text/markdown',
+        '.markdown': 'text/markdown',
+    };
+    return mimeTypes[extension] || 'application/octet-stream';
+}
+/**
+ * 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
+ */
+function splitFileIntoChunks(filePath, chunkSize) {
+    const fileBuffer = fs_1.default.readFileSync(filePath);
+    const chunks = [];
+    for (let i = 0; i < fileBuffer.length; i += chunkSize) {
+        chunks.push(new Uint8Array(fileBuffer.slice(i, i + chunkSize)));
+    }
+    return chunks;
+}
+/**
+ * Combines chunks into a single file
+ * @param chunks Array of chunks to combine
+ * @param outputPath The path to write the combined file to
+ */
+function combineChunksToFile(chunks, outputPath) {
+    const combinedBuffer = Buffer.concat(chunks.map(chunk => Buffer.from(chunk)));
+    writeFile(outputPath, combinedBuffer);
+}

package/dist/utils/molecule.d.ts

@@ -0,0 +1,77 @@
+import { molecule, number } from "@ckb-lumos/codec";
+/**
+ * Molecule definitions for CKBFS data structures.
+ */
+export declare const Indexes: molecule.ArrayLayoutCodec<import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>>;
+export declare const BackLinkV1: molecule.ObjectLayoutCodec<{
+    txHash: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    index: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+    checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+}>;
+export declare const BackLinkV2: molecule.ObjectLayoutCodec<{
+    txHash: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    indexes: molecule.ArrayLayoutCodec<import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>>;
+    checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+}>;
+export declare const BackLinksV1: molecule.ArrayLayoutCodec<molecule.ObjectLayoutCodec<{
+    txHash: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    index: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+    checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+}>>;
+export declare const BackLinksV2: molecule.ArrayLayoutCodec<molecule.ObjectLayoutCodec<{
+    txHash: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    indexes: molecule.ArrayLayoutCodec<import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>>;
+    checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+}>>;
+export declare const CKBFSDataV1: molecule.ObjectLayoutCodec<{
+    index: molecule.ArrayLayoutCodec<import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>>;
+    checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+    contentType: import("@ckb-lumos/codec/lib/base").BytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    filename: import("@ckb-lumos/codec/lib/base").BytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    backLinks: molecule.ArrayLayoutCodec<molecule.ObjectLayoutCodec<{
+        txHash: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+        index: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+        checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+    }>>;
+}>;
+export declare const CKBFSDataV2: molecule.ObjectLayoutCodec<{
+    indexes: molecule.ArrayLayoutCodec<import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>>;
+    checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+    contentType: import("@ckb-lumos/codec/lib/base").BytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    filename: import("@ckb-lumos/codec/lib/base").BytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+    backLinks: molecule.ArrayLayoutCodec<molecule.ObjectLayoutCodec<{
+        txHash: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<string, import("@ckb-lumos/codec").BytesLike>;
+        indexes: molecule.ArrayLayoutCodec<import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>>;
+        checksum: import("@ckb-lumos/codec/lib/base").FixedBytesCodec<number, number.BIish>;
+    }>>;
+}>;
+export type BackLinkTypeV1 = {
+    txHash: string;
+    index: number;
+    checksum: number;
+};
+export type BackLinkTypeV2 = {
+    txHash: string;
+    indexes: number[];
+    checksum: number;
+};
+export type BackLinkType = {
+    txHash: string;
+    index?: number;
+    indexes?: number[];
+    checksum: number;
+};
+export type CKBFSDataType = {
+    index?: number[];
+    indexes?: number[];
+    checksum: number;
+    contentType: Uint8Array;
+    filename: Uint8Array;
+    backLinks: BackLinkType[];
+};
+export declare const CKBFSData: {
+    pack: (data: CKBFSDataType, version?: string) => Uint8Array;
+    unpack: (buf: Uint8Array, version?: string) => CKBFSDataType;
+};
+export declare const CKBFS_HEADER: Uint8Array<ArrayBuffer>;
+export declare const CKBFS_HEADER_STRING = "CKBFS";

package/dist/utils/molecule.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CKBFS_HEADER_STRING = exports.CKBFS_HEADER = exports.CKBFSData = exports.CKBFSDataV2 = exports.CKBFSDataV1 = exports.BackLinksV2 = exports.BackLinksV1 = exports.BackLinkV2 = exports.BackLinkV1 = exports.Indexes = void 0;
+const codec_1 = require("@ckb-lumos/codec");
+const base_1 = require("@ckb-lumos/base");
+const constants_1 = require("./constants");
+/**
+ * Molecule definitions for CKBFS data structures.
+ */
+// Define the Indexes vector
+exports.Indexes = codec_1.molecule.vector(codec_1.number.Uint32);
+// Define the BackLink table structure for V1
+exports.BackLinkV1 = codec_1.molecule.table({
+    txHash: base_1.blockchain.Byte32,
+    index: codec_1.number.Uint32,
+    checksum: codec_1.number.Uint32,
+}, ["txHash", "index", "checksum"]);
+// Define the BackLink table structure for V2
+exports.BackLinkV2 = codec_1.molecule.table({
+    txHash: base_1.blockchain.Byte32,
+    indexes: exports.Indexes,
+    checksum: codec_1.number.Uint32,
+}, ["txHash", "indexes", "checksum"]);
+// Define the BackLinks vector for V1
+exports.BackLinksV1 = codec_1.molecule.vector(exports.BackLinkV1);
+// Define the BackLinks vector for V2
+exports.BackLinksV2 = codec_1.molecule.vector(exports.BackLinkV2);
+// Define the CKBFSData table structure for V1
+exports.CKBFSDataV1 = codec_1.molecule.table({
+    index: exports.Indexes,
+    checksum: codec_1.number.Uint32,
+    contentType: base_1.blockchain.Bytes,
+    filename: base_1.blockchain.Bytes,
+    backLinks: exports.BackLinksV1,
+}, ["index", "checksum", "contentType", "filename", "backLinks"]);
+// Define the CKBFSData table structure for V2
+exports.CKBFSDataV2 = codec_1.molecule.table({
+    indexes: exports.Indexes,
+    checksum: codec_1.number.Uint32,
+    contentType: base_1.blockchain.Bytes,
+    filename: base_1.blockchain.Bytes,
+    backLinks: exports.BackLinksV2,
+}, ["indexes", "checksum", "contentType", "filename", "backLinks"]);
+// Helper function to safely get either index or indexes
+function getIndexes(data) {
+    return data.indexes || data.index || [];
+}
+// Helper function to safely get either index or indexes from BackLinkType
+function getBackLinkIndex(bl) {
+    if (typeof bl.index === 'number') {
+        return bl.index;
+    }
+    if (Array.isArray(bl.indexes) && bl.indexes.length > 0) {
+        return bl.indexes[0];
+    }
+    return 0;
+}
+// Helper function to safely get indexes array from BackLinkType
+function getBackLinkIndexes(bl) {
+    if (Array.isArray(bl.indexes)) {
+        return bl.indexes;
+    }
+    if (typeof bl.index === 'number') {
+        return [bl.index];
+    }
+    return [0];
+}
+// Helper function to get the right CKBFSData based on version
+exports.CKBFSData = {
+    pack: (data, version = constants_1.ProtocolVersion.V2) => {
+        if (version === constants_1.ProtocolVersion.V1) {
+            // V1 formatting
+            return exports.CKBFSDataV1.pack({
+                index: getIndexes(data),
+                checksum: data.checksum,
+                contentType: data.contentType,
+                filename: data.filename,
+                backLinks: data.backLinks.map(bl => ({
+                    txHash: bl.txHash,
+                    index: getBackLinkIndex(bl),
+                    checksum: bl.checksum,
+                })),
+            });
+        }
+        else {
+            // V2 formatting
+            return exports.CKBFSDataV2.pack({
+                indexes: getIndexes(data),
+                checksum: data.checksum,
+                contentType: data.contentType,
+                filename: data.filename,
+                backLinks: data.backLinks.map(bl => ({
+                    txHash: bl.txHash,
+                    indexes: getBackLinkIndexes(bl),
+                    checksum: bl.checksum,
+                })),
+            });
+        }
+    },
+    unpack: (buf, version = constants_1.ProtocolVersion.V2) => {
+        try {
+            if (version === constants_1.ProtocolVersion.V1) {
+                const unpacked = exports.CKBFSDataV1.unpack(buf);
+                return {
+                    index: unpacked.index,
+                    checksum: unpacked.checksum,
+                    contentType: new Uint8Array(Buffer.from(unpacked.contentType)),
+                    filename: new Uint8Array(Buffer.from(unpacked.filename)),
+                    backLinks: unpacked.backLinks.map(bl => ({
+                        txHash: bl.txHash,
+                        index: bl.index,
+                        checksum: bl.checksum,
+                    })),
+                };
+            }
+            else {
+                // V2 format
+                const unpacked = exports.CKBFSDataV2.unpack(buf);
+                return {
+                    indexes: unpacked.indexes,
+                    checksum: unpacked.checksum,
+                    contentType: new Uint8Array(Buffer.from(unpacked.contentType)),
+                    filename: new Uint8Array(Buffer.from(unpacked.filename)),
+                    backLinks: unpacked.backLinks.map(bl => ({
+                        txHash: bl.txHash,
+                        indexes: bl.indexes,
+                        checksum: bl.checksum,
+                    })),
+                };
+            }
+        }
+        catch (error) {
+            console.error('Error unpacking CKBFSData:', error);
+            throw new Error('Failed to unpack CKBFSData: ' + error);
+        }
+    }
+};
+// Constants for CKBFS protocol
+exports.CKBFS_HEADER = new Uint8Array([0x43, 0x4B, 0x42, 0x46, 0x53]); // "CKBFS" in ASCII
+exports.CKBFS_HEADER_STRING = "CKBFS";

package/dist/utils/transaction.d.ts

@@ -0,0 +1,82 @@
+import { ccc, Transaction, Script, Signer } from "@ckb-ccc/core";
+import { CKBFSDataType } from './molecule';
+import { NetworkType } from './constants';
+/**
+ * Utility functions for CKB transaction creation and handling
+ */
+/**
+ * Options for creating a CKBFS cell
+ */
+export interface CKBFSCellOptions {
+    contentType: string;
+    filename: string;
+    capacity?: bigint;
+    lock: Script;
+    network?: NetworkType;
+    version?: string;
+    useTypeID?: boolean;
+}
+/**
+ * Options for publishing a file to CKBFS
+ */
+export interface PublishOptions extends CKBFSCellOptions {
+    contentChunks: Uint8Array[];
+    feeRate?: number;
+}
+/**
+ * Options for appending content to a CKBFS file
+ */
+export interface AppendOptions {
+    ckbfsCell: {
+        outPoint: {
+            txHash: string;
+            index: number;
+        };
+        data: CKBFSDataType;
+        type: Script;
+        lock: Script;
+        capacity: bigint;
+    };
+    contentChunks: Uint8Array[];
+    feeRate?: number;
+    network?: NetworkType;
+    version?: string;
+}
+/**
+ * Creates a CKBFS cell
+ * @param options Options for creating the CKBFS cell
+ * @returns The created cell output
+ */
+export declare function createCKBFSCell(options: CKBFSCellOptions): {
+    lock: ccc.Script;
+    type: ccc.Script;
+    capacity: bigint;
+};
+/**
+ * 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 declare function createPublishTransaction(signer: Signer, options: PublishOptions): 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 createAppendTransaction(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
+ * @param options Options for publishing the file
+ * @returns Promise resolving to the signed transaction
+ */
+export declare function publishCKBFS(signer: Signer, options: PublishOptions): Promise<Transaction>;
+/**
+ * Creates a complete 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 signed transaction
+ */
+export declare function appendCKBFS(signer: Signer, options: AppendOptions): Promise<Transaction>;