@ckbfs/api 1.0.0

package/src/utils/constants.ts

@@ -0,0 +1,123 @@
+/**
+ * CKBFS protocol deployment constants
+ */
+
+export enum NetworkType {
+  Mainnet = 'mainnet',
+  Testnet = 'testnet'
+}
+
+// Use string literals for version values to avoid TypeScript indexing issues
+export const 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
+} as const;
+
+export type ProtocolVersionType = typeof ProtocolVersion[keyof typeof ProtocolVersion];
+
+// CKBFS Type Script Constants
+export const CKBFS_CODE_HASH: Record<NetworkType, Record<string, string>> = {
+  [NetworkType.Mainnet]: {
+    [ProtocolVersion.V2]: '0x31e6376287d223b8c0410d562fb422f04d1d617b2947596a14c3d2efb7218d3a'
+  },
+  [NetworkType.Testnet]: {
+    [ProtocolVersion.V1]: '0xe8905ad29a02cf8befa9c258f4f941773839a618d75a64afc22059de9413f712',
+    [ProtocolVersion.V2]: '0x31e6376287d223b8c0410d562fb422f04d1d617b2947596a14c3d2efb7218d3a'
+  }
+};
+
+export const CKBFS_TYPE_ID: Record<NetworkType, Record<string, string>> = {
+  [NetworkType.Mainnet]: {
+    [ProtocolVersion.V2]: '0xfd2058c9a0c0183354cf637e25d2707ffa9bb6fa2ba9b29f4ebc6be3e54ad7eb'
+  },
+  [NetworkType.Testnet]: {
+    [ProtocolVersion.V1]: '0x88ef4d436af35684a27edda0d44dd8771318330285f90f02d13606e095aea86f',
+    [ProtocolVersion.V2]: '0x7c6dcab8268201f064dc8676b5eafa60ca2569e5c6209dcbab0eb64a9cb3aaa3'
+  }
+};
+
+// Adler32 Hasher Constants
+export const ADLER32_CODE_HASH: Record<NetworkType, Record<string, string>> = {
+  [NetworkType.Mainnet]: {
+    [ProtocolVersion.V2]: '0x2138683f76944437c0c643664120d620bdb5858dd6c9d1d156805e279c2c536f'
+  },
+  [NetworkType.Testnet]: {
+    [ProtocolVersion.V1]: '0x8af42cd329cf1bcffb4c73b48252e99cb32346fdbc1cdaa5ae1d000232d47e84',
+    [ProtocolVersion.V2]: '0x2138683f76944437c0c643664120d620bdb5858dd6c9d1d156805e279c2c536f'
+  }
+};
+
+export const ADLER32_TYPE_ID: Record<NetworkType, Record<string, string>> = {
+  [NetworkType.Mainnet]: {
+    [ProtocolVersion.V2]: '0x641c01d590833a3f5471bd441651d9f2a8a200141949cdfeef2d68d8094c5876'
+  },
+  [NetworkType.Testnet]: {
+    [ProtocolVersion.V1]: '0xccf29a0d8e860044a3d2f6a6e709f6572f77e4fe245fadd212fc342337048d60',
+    [ProtocolVersion.V2]: '0x5f73f128be76e397f5a3b56c94ca16883a8ee91b498bc0ee80473818318c05ac'
+  }
+};
+
+// Dep Group Transaction Constants
+export const DEP_GROUP_TX_HASH: Record<NetworkType, Record<string, string>> = {
+  [NetworkType.Mainnet]: {
+    [ProtocolVersion.V2]: '0xfab07962ed7178ed88d450774e2a6ecd50bae856bdb9b692980be8c5147d1bfa'
+  },
+  [NetworkType.Testnet]: {
+    [ProtocolVersion.V1]: '0xc8fd44aba36f0c4b37536b6c7ea3b88df65fa97e02f77cd33b9bf20bf241a09b',
+    [ProtocolVersion.V2]: '0x469af0d961dcaaedd872968a9388b546717a6ccfa47b3165b3f9c981e9d66aaa'
+  }
+};
+
+// Deploy Transaction Constants
+export const DEPLOY_TX_HASH: Record<NetworkType, Record<string, { ckbfs: string; adler32: string }>> = {
+  [NetworkType.Mainnet]: {
+    [ProtocolVersion.V2]: {
+      ckbfs: '0xc9b6698f44c3b80e7e1c48823b2714e432b93f0206ffaf9df885d23267ed2ebc',
+      adler32: '0xc9b6698f44c3b80e7e1c48823b2714e432b93f0206ffaf9df885d23267ed2ebc'
+    }
+  },
+  [NetworkType.Testnet]: {
+    [ProtocolVersion.V1]: {
+      ckbfs: '0xde8eb09151fbcdcba398423159ce348cc89a38a736de3fd0960b18b084465382',
+      adler32: '0x042f264d7397a181437b51ff9981cf536f252ab5740b61ce52ce31ada04ed54b'
+    },
+    [ProtocolVersion.V2]: {
+      ckbfs: '0x2c8c9ad3134743368b5a79977648f96c5bd0aba187021a72fb624301064d3616',
+      adler32: '0x2c8c9ad3134743368b5a79977648f96c5bd0aba187021a72fb624301064d3616'
+    }
+  }
+};
+
+// Default values - V2 is now the default
+export const DEFAULT_VERSION = ProtocolVersion.V2;
+export const DEFAULT_NETWORK = NetworkType.Testnet;
+
+// Helper function to get CKBFS script configuration
+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 function getCKBFSScriptConfig(
+  network: NetworkType = DEFAULT_NETWORK,
+  version: string = DEFAULT_VERSION,
+  useTypeID: boolean = false
+): CKBFSScriptConfig {
+  return {
+    codeHash: useTypeID 
+      ? CKBFS_TYPE_ID[network][version] 
+      : CKBFS_CODE_HASH[network][version],
+    hashType: useTypeID ? 'type' : 'data1',
+    depTxHash: DEP_GROUP_TX_HASH[network][version],
+    depIndex: 0
+  };
+} 

package/src/utils/file.ts

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from '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
+ */
+export function readFile(filePath: string): Buffer {
+  return fs.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
+ */
+export function readFileAsText(filePath: string): string {
+  return fs.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
+ */
+export function readFileAsUint8Array(filePath: string): Uint8Array {
+  const buffer = fs.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
+ */
+export function writeFile(filePath: string, data: Buffer | string): void {
+  // Ensure the directory exists
+  const dirPath = path.dirname(filePath);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  
+  fs.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
+ */
+export function getContentType(filePath: string): string {
+  const extension = path.extname(filePath).toLowerCase();
+  
+  const mimeTypes: { [key: string]: string } = {
+    '.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
+ */
+export function splitFileIntoChunks(filePath: string, chunkSize: number): Uint8Array[] {
+  const fileBuffer = fs.readFileSync(filePath);
+  const chunks: Uint8Array[] = [];
+  
+  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
+ */
+export function combineChunksToFile(chunks: Uint8Array[], outputPath: string): void {
+  const combinedBuffer = Buffer.concat(chunks.map(chunk => Buffer.from(chunk)));
+  writeFile(outputPath, combinedBuffer);
+} 

package/src/utils/molecule.ts

@@ -0,0 +1,190 @@
+import { molecule, number } from "@ckb-lumos/codec";
+import { blockchain } from "@ckb-lumos/base";
+import { ProtocolVersion } from "./constants";
+
+/**
+ * Molecule definitions for CKBFS data structures.
+ */
+
+// Define the Indexes vector
+export const Indexes = molecule.vector(number.Uint32);
+
+// Define the BackLink table structure for V1
+export const BackLinkV1 = molecule.table(
+  {
+    txHash: blockchain.Byte32,
+    index: number.Uint32,
+    checksum: number.Uint32,
+  },
+  ["txHash", "index", "checksum"]
+);
+
+// Define the BackLink table structure for V2
+export const BackLinkV2 = molecule.table(
+  {
+    txHash: blockchain.Byte32,
+    indexes: Indexes,
+    checksum: number.Uint32,
+  },
+  ["txHash", "indexes", "checksum"]
+);
+
+// Define the BackLinks vector for V1
+export const BackLinksV1 = molecule.vector(BackLinkV1);
+
+// Define the BackLinks vector for V2
+export const BackLinksV2 = molecule.vector(BackLinkV2);
+
+// Define the CKBFSData table structure for V1
+export const CKBFSDataV1 = molecule.table(
+  {
+    index: Indexes,
+    checksum: number.Uint32,
+    contentType: blockchain.Bytes,
+    filename: blockchain.Bytes,
+    backLinks: BackLinksV1,
+  },
+  ["index", "checksum", "contentType", "filename", "backLinks"]
+);
+
+// Define the CKBFSData table structure for V2
+export const CKBFSDataV2 = molecule.table(
+  {
+    indexes: Indexes,
+    checksum: number.Uint32,
+    contentType: blockchain.Bytes,
+    filename: blockchain.Bytes,
+    backLinks: BackLinksV2,
+  },
+  ["indexes", "checksum", "contentType", "filename", "backLinks"]
+);
+
+// Type definitions for TypeScript
+export type BackLinkTypeV1 = {
+  txHash: string;
+  index: number;
+  checksum: number;
+};
+
+export type BackLinkTypeV2 = {
+  txHash: string;
+  indexes: number[];
+  checksum: number;
+};
+
+// Combined type that works with both versions
+export type BackLinkType = {
+  txHash: string;
+  index?: number;
+  indexes?: number[];
+  checksum: number;
+};
+
+// Combined CKBFSData type that works with both versions
+export type CKBFSDataType = {
+  index?: number[];
+  indexes?: number[];
+  checksum: number;
+  contentType: Uint8Array;
+  filename: Uint8Array;
+  backLinks: BackLinkType[];
+};
+
+// Helper function to safely get either index or indexes
+function getIndexes(data: CKBFSDataType): number[] {
+  return data.indexes || data.index || [];
+}
+
+// Helper function to safely get either index or indexes from BackLinkType
+function getBackLinkIndex(bl: BackLinkType): number {
+  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: BackLinkType): number[] {
+  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
+export const CKBFSData = {
+  pack: (data: CKBFSDataType, version: string = ProtocolVersion.V2): Uint8Array => {
+    if (version === ProtocolVersion.V1) {
+      // V1 formatting
+      return 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 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: Uint8Array, version: string = ProtocolVersion.V2): CKBFSDataType => {
+    try {
+      if (version === ProtocolVersion.V1) {
+        const unpacked = 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 = 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
+export const CKBFS_HEADER = new Uint8Array([0x43, 0x4B, 0x42, 0x46, 0x53]); // "CKBFS" in ASCII
+export const CKBFS_HEADER_STRING = "CKBFS";