@brightchain/brightchain-lib 0.1.0

package/src/lib/enumerations/blockSize.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Block sizes in the Owner Free Filesystem (OFF) are carefully chosen powers of 2
+ * that balance several key factors:
+ * 1. Storage efficiency
+ * 2. Memory usage
+ * 3. XOR operation performance
+ * 4. Network transfer efficiency
+ *
+ * Block Size Selection:
+ * - Smaller blocks (512B - 4KB): Better for small files, less padding waste
+ * - Medium blocks (1MB): Good balance for typical files
+ * - Large blocks (64MB - 256MB): Better for large files, more efficient storage
+ */
+import StringNames from './stringNames';
+/**
+ * Block size exponents (2^x) for calculating block sizes.
+ * These are chosen to provide a good range of sizes while maintaining
+ * power-of-2 alignment for efficient operations.
+ */
+export declare const blockSizeExponents: readonly [9, 10, 12, 20, 26, 28];
+/**
+ * Actual block sizes in bytes, calculated from the exponents.
+ * Each size is optimized for different use cases and storage patterns.
+ */
+export declare const blockSizeLengths: readonly [number, number, number, number, number, number];
+/**
+ * Block size enumeration defining standard block sizes in OFF.
+ * Each size is optimized for specific use cases and provides different
+ * trade-offs between storage efficiency and performance.
+ */
+export declare enum BlockSize {
+    /**
+     * Invalid or unknown block size.
+     * Used for error conditions and initialization.
+     */
+    Unknown = 0,
+    /**
+     * Message size (512B)
+     * Optimal for:
+     * 1. Small messages
+     * 2. Configuration data
+     * 3. Metadata storage
+     */
+    Message,
+    /**
+     * Tiny size (1KB)
+     * Optimal for:
+     * 1. Small files
+     * 2. Configuration files
+     * 3. Quick operations
+     */
+    Tiny,
+    /**
+     * Small size (4KB)
+     * Optimal for:
+     * 1. Small to medium files
+     * 2. System page size alignment
+     * 3. Efficient disk I/O
+     */
+    Small,
+    /**
+     * Medium size (1MB)
+     * Optimal for:
+     * 1. Medium-sized files
+     * 2. Balanced performance
+     * 3. Common file sizes
+     */
+    Medium,
+    /**
+     * Large size (64MB)
+     * Optimal for:
+     * 1. Large files
+     * 2. Streaming operations
+     * 3. High throughput
+     */
+    Large,
+    /**
+     * Huge size (256MB)
+     * Optimal for:
+     * 1. Very large files
+     * 2. Maximum throughput
+     * 3. Minimal overhead
+     */
+    Huge
+}
+/**
+ * List of valid block sizes for validation and iteration.
+ * Excludes Unknown size as it's not valid for actual use.
+ */
+export declare const validBlockSizes: readonly BlockSize[];
+/**
+ * Human-readable names for block sizes.
+ * Used for display and logging purposes.
+ */
+export declare const blockSizeStringNames: Record<BlockSize, StringNames>;
+/**
+ * Map of block sizes to their metadata.
+ * Provides quick access to size information and names.
+ */
+export declare const BlockSizeInfo: {
+    [key in BlockSize]: {
+        blockSize: BlockSize;
+        length: number;
+        name: string;
+    };
+};
+/**
+ * Validate if a length matches a valid block size.
+ * @param length - The length to validate
+ * @param allowNonStandard - Whether to allow non-standard block sizes (for testing)
+ * @returns True if the length is a valid block size
+ */
+export declare function validateBlockSize(length: number, allowNonStandard?: boolean): boolean;
+/**
+ * Convert a byte length to its BlockSize enum value.
+ * @param length - The length in bytes
+ * @param allowNonStandard - Whether to allow non-standard block sizes (for testing)
+ * @returns The corresponding BlockSize enum value
+ * @throws InvalidBlockSizeLengthError if the length doesn't match a valid block size
+ */
+export declare function lengthToBlockSize(length: number, allowNonStandard?: boolean): BlockSize;
+/**
+ * Convert a byte length to the closest BlockSize enum value.
+ * @param length - The length in bytes
+ * @returns The closest BlockSize enum value
+ */
+export declare function lengthToClosestBlockSize(length: number): BlockSize;
+/**
+ * Convert a BlockSize enum value to its string representation.
+ * @param blockSize - The BlockSize enum value
+ * @returns The human-readable name of the block size
+ * @throws Error if the block size is invalid
+ */
+export declare function blockSizeToSizeString(blockSize: BlockSize): string;
+//# sourceMappingURL=blockSize.d.ts.map

package/src/lib/enumerations/blockSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockSize.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/blockSize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,WAAW,MAAM,eAAe,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,kCAAmC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,gBAAgB,2DAOnB,CAAC;AAEX;;;;GAIG;AACH,oBAAY,SAAS;IACnB;;;OAGG;IACH,OAAO,IAAI;IAEX;;;;;;OAMG;IACH,OAA6B;IAE7B;;;;;;OAMG;IACH,IAA0B;IAE1B;;;;;;OAMG;IACH,KAA2B;IAE3B;;;;;;OAMG;IACH,MAA4B;IAE5B;;;;;;OAMG;IACH,KAA2B;IAE3B;;;;;;OAMG;IACH,IAA0B;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,SAAS,EAOtC,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAQtD,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE;KACzB,GAAG,IAAI,SAAS,GAAG;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAqClE,CAAC;AAEX;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,gBAAgB,UAAQ,GACvB,OAAO,CAYT;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,gBAAgB,UAAO,GACtB,SAAS,CAqBX;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAoBlE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAElE"}

package/src/lib/enumerations/blockSize.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Block sizes in the Owner Free Filesystem (OFF) are carefully chosen powers of 2
+ * that balance several key factors:
+ * 1. Storage efficiency
+ * 2. Memory usage
+ * 3. XOR operation performance
+ * 4. Network transfer efficiency
+ *
+ * Block Size Selection:
+ * - Smaller blocks (512B - 4KB): Better for small files, less padding waste
+ * - Medium blocks (1MB): Good balance for typical files
+ * - Large blocks (64MB - 256MB): Better for large files, more efficient storage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockSizeInfo = exports.blockSizeStringNames = exports.validBlockSizes = exports.BlockSize = exports.blockSizeLengths = exports.blockSizeExponents = void 0;
+exports.validateBlockSize = validateBlockSize;
+exports.lengthToBlockSize = lengthToBlockSize;
+exports.lengthToClosestBlockSize = lengthToClosestBlockSize;
+exports.blockSizeToSizeString = blockSizeToSizeString;
+const invalidBlockSizeLength_1 = require("../errors/invalidBlockSizeLength");
+const i18n_1 = require("../i18n");
+const stringNames_1 = require("./stringNames");
+/**
+ * Block size exponents (2^x) for calculating block sizes.
+ * These are chosen to provide a good range of sizes while maintaining
+ * power-of-2 alignment for efficient operations.
+ */
+exports.blockSizeExponents = [9, 10, 12, 20, 26, 28];
+/**
+ * Actual block sizes in bytes, calculated from the exponents.
+ * Each size is optimized for different use cases and storage patterns.
+ */
+exports.blockSizeLengths = [
+    2 ** exports.blockSizeExponents[0],
+    2 ** exports.blockSizeExponents[1],
+    2 ** exports.blockSizeExponents[2],
+    2 ** exports.blockSizeExponents[3],
+    2 ** exports.blockSizeExponents[4],
+    2 ** exports.blockSizeExponents[5],
+];
+/**
+ * Block size enumeration defining standard block sizes in OFF.
+ * Each size is optimized for specific use cases and provides different
+ * trade-offs between storage efficiency and performance.
+ */
+var BlockSize;
+(function (BlockSize) {
+    /**
+     * Invalid or unknown block size.
+     * Used for error conditions and initialization.
+     */
+    BlockSize[BlockSize["Unknown"] = 0] = "Unknown";
+    /**
+     * Message size (512B)
+     * Optimal for:
+     * 1. Small messages
+     * 2. Configuration data
+     * 3. Metadata storage
+     */
+    BlockSize[BlockSize["Message"] = exports.blockSizeLengths[0]] = "Message";
+    /**
+     * Tiny size (1KB)
+     * Optimal for:
+     * 1. Small files
+     * 2. Configuration files
+     * 3. Quick operations
+     */
+    BlockSize[BlockSize["Tiny"] = exports.blockSizeLengths[1]] = "Tiny";
+    /**
+     * Small size (4KB)
+     * Optimal for:
+     * 1. Small to medium files
+     * 2. System page size alignment
+     * 3. Efficient disk I/O
+     */
+    BlockSize[BlockSize["Small"] = exports.blockSizeLengths[2]] = "Small";
+    /**
+     * Medium size (1MB)
+     * Optimal for:
+     * 1. Medium-sized files
+     * 2. Balanced performance
+     * 3. Common file sizes
+     */
+    BlockSize[BlockSize["Medium"] = exports.blockSizeLengths[3]] = "Medium";
+    /**
+     * Large size (64MB)
+     * Optimal for:
+     * 1. Large files
+     * 2. Streaming operations
+     * 3. High throughput
+     */
+    BlockSize[BlockSize["Large"] = exports.blockSizeLengths[4]] = "Large";
+    /**
+     * Huge size (256MB)
+     * Optimal for:
+     * 1. Very large files
+     * 2. Maximum throughput
+     * 3. Minimal overhead
+     */
+    BlockSize[BlockSize["Huge"] = exports.blockSizeLengths[5]] = "Huge";
+})(BlockSize || (exports.BlockSize = BlockSize = {}));
+/**
+ * List of valid block sizes for validation and iteration.
+ * Excludes Unknown size as it's not valid for actual use.
+ */
+exports.validBlockSizes = [
+    BlockSize.Message,
+    BlockSize.Tiny,
+    BlockSize.Small,
+    BlockSize.Medium,
+    BlockSize.Large,
+    BlockSize.Huge,
+];
+/**
+ * Human-readable names for block sizes.
+ * Used for display and logging purposes.
+ */
+exports.blockSizeStringNames = {
+    [BlockSize.Unknown]: stringNames_1.default.BlockSize_Unknown,
+    [BlockSize.Message]: stringNames_1.default.BlockSize_Message,
+    [BlockSize.Tiny]: stringNames_1.default.BlockSize_Tiny,
+    [BlockSize.Small]: stringNames_1.default.BlockSize_Small,
+    [BlockSize.Medium]: stringNames_1.default.BlockSize_Medium,
+    [BlockSize.Large]: stringNames_1.default.BlockSize_Large,
+    [BlockSize.Huge]: stringNames_1.default.BlockSize_Huge,
+};
+/**
+ * Map of block sizes to their metadata.
+ * Provides quick access to size information and names.
+ */
+exports.BlockSizeInfo = {
+    [BlockSize.Unknown]: {
+        blockSize: BlockSize.Unknown,
+        length: BlockSize.Unknown,
+        name: stringNames_1.default.BlockSize_Unknown,
+    },
+    [BlockSize.Message]: {
+        blockSize: BlockSize.Message,
+        length: BlockSize.Message,
+        name: stringNames_1.default.BlockSize_Message,
+    },
+    [BlockSize.Tiny]: {
+        blockSize: BlockSize.Tiny,
+        length: BlockSize.Tiny,
+        name: stringNames_1.default.BlockSize_Tiny,
+    },
+    [BlockSize.Small]: {
+        blockSize: BlockSize.Small,
+        length: BlockSize.Small,
+        name: stringNames_1.default.BlockSize_Small,
+    },
+    [BlockSize.Medium]: {
+        blockSize: BlockSize.Medium,
+        length: BlockSize.Medium,
+        name: stringNames_1.default.BlockSize_Medium,
+    },
+    [BlockSize.Large]: {
+        blockSize: BlockSize.Large,
+        length: BlockSize.Large,
+        name: stringNames_1.default.BlockSize_Large,
+    },
+    [BlockSize.Huge]: {
+        blockSize: BlockSize.Huge,
+        length: BlockSize.Huge,
+        name: stringNames_1.default.BlockSize_Huge,
+    },
+};
+/**
+ * Validate if a length matches a valid block size.
+ * @param length - The length to validate
+ * @param allowNonStandard - Whether to allow non-standard block sizes (for testing)
+ * @returns True if the length is a valid block size
+ */
+function validateBlockSize(length, allowNonStandard = false) {
+    // For standard validation, check if the length is in the predefined list
+    if (exports.blockSizeLengths.includes(length)) {
+        return true;
+    }
+    // For testing purposes, allow non-standard block sizes
+    if (allowNonStandard && length > 0) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Convert a byte length to its BlockSize enum value.
+ * @param length - The length in bytes
+ * @param allowNonStandard - Whether to allow non-standard block sizes (for testing)
+ * @returns The corresponding BlockSize enum value
+ * @throws InvalidBlockSizeLengthError if the length doesn't match a valid block size
+ */
+function lengthToBlockSize(length, allowNonStandard = true) {
+    // Check if the length is a valid block size
+    if (!validateBlockSize(length, allowNonStandard)) {
+        throw new invalidBlockSizeLength_1.InvalidBlockSizeLengthError(length);
+    }
+    // For standard block sizes, return the exact match
+    const values = Object.values(exports.BlockSizeInfo);
+    for (let i = 0; i < values.length; i++) {
+        if (values[i].length === length) {
+            return values[i].blockSize;
+        }
+    }
+    // For non-standard block sizes (in tests), return the closest block size
+    if (allowNonStandard) {
+        return lengthToClosestBlockSize(length);
+    }
+    // This should never happen since we've already validated the block size
+    throw new invalidBlockSizeLength_1.InvalidBlockSizeLengthError(length);
+}
+/**
+ * Convert a byte length to the closest BlockSize enum value.
+ * @param length - The length in bytes
+ * @returns The closest BlockSize enum value
+ */
+function lengthToClosestBlockSize(length) {
+    if (length < 0) {
+        throw new invalidBlockSizeLength_1.InvalidBlockSizeLengthError(length);
+    }
+    // For values larger than the largest block size, return the largest block size
+    if (length > BlockSize.Huge) {
+        return BlockSize.Huge;
+    }
+    const values = Object.values(exports.BlockSizeInfo);
+    // skip unknown, smallest valid block is 512
+    for (let i = 1; i < values.length; i++) {
+        if (length <= values[i].length) {
+            return values[i].blockSize;
+        }
+    }
+    // This should never happen since we've already handled values larger than BlockSize.Huge
+    return BlockSize.Huge;
+}
+/**
+ * Convert a BlockSize enum value to its string representation.
+ * @param blockSize - The BlockSize enum value
+ * @returns The human-readable name of the block size
+ * @throws Error if the block size is invalid
+ */
+function blockSizeToSizeString(blockSize) {
+    return (0, i18n_1.translate)(exports.blockSizeStringNames[blockSize]);
+}
+//# sourceMappingURL=blockSize.js.map

package/src/lib/enumerations/blockSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockSize.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/blockSize.ts"],"names":[],"mappings":"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"}

package/src/lib/enumerations/blockStatusType.d.ts

@@ -0,0 +1,6 @@
+export declare enum BlockStatusType {
+    Active = "ACTIVE",
+    Pending = "PENDING",
+    Offline = "OFFLINE"
+}
+//# sourceMappingURL=blockStatusType.d.ts.map

package/src/lib/enumerations/blockStatusType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockStatusType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/blockStatusType.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB"}

package/src/lib/enumerations/blockStatusType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockStatusType = void 0;
+var BlockStatusType;
+(function (BlockStatusType) {
+    BlockStatusType["Active"] = "ACTIVE";
+    BlockStatusType["Pending"] = "PENDING";
+    BlockStatusType["Offline"] = "OFFLINE";
+})(BlockStatusType || (exports.BlockStatusType = BlockStatusType = {}));
+//# sourceMappingURL=blockStatusType.js.map

package/src/lib/enumerations/blockStatusType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockStatusType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/blockStatusType.ts"],"names":[],"mappings":";;;AAAA,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;IACnB,sCAAmB,CAAA;AACrB,CAAC,EAJW,eAAe,+BAAf,eAAe,QAI1B"}

package/src/lib/enumerations/blockType.d.ts

@@ -0,0 +1,118 @@
+/**
+ * BlockType defines the different types of blocks in the Owner Free Filesystem (OFF).
+ * In OFF, blocks are organized in a hierarchy where each type serves a specific purpose:
+ *
+ * Data Storage:
+ * - RawData: Basic data storage without additional features
+ * - OwnedDataBlock: Data blocks with ownership information
+ * - EncryptedOwnedDataBlock: Encrypted data blocks with ownership
+ *
+ * Privacy & Security:
+ * - OwnerFreeWhitenedBlock: Data XORed with random blocks for privacy
+ * - Random: Random data blocks used for whitening
+ * - FECData: Forward Error Correction data for recovery
+ *
+ * Organization & Management:
+ * - ConstituentBlockList (CBL): Lists of block references and metadata
+ * - Handle: References to blocks stored elsewhere
+ */
+export declare enum BlockType {
+    /**
+     * Used for uninitialized or invalid blocks
+     */
+    Unknown = -1,
+    /**
+     * A block that has been XORed with random data for privacy.
+     * Key features:
+     * 1. Data is obscured through XOR operations
+     * 2. Original data can be recovered with the random blocks
+     * 3. Provides privacy without encryption overhead
+     */
+    OwnerFreeWhitenedBlock = 0,
+    /**
+     * A block containing random data.
+     * Used for:
+     * 1. Whitening other blocks through XOR
+     * 2. Adding entropy to the system
+     * 3. Supporting privacy features
+     */
+    Random = 1,
+    /**
+     * A basic block containing raw data.
+     * Features:
+     * 1. Simple data storage
+     * 2. No additional metadata
+     * 3. Maximum storage efficiency
+     */
+    RawData = 2,
+    /**
+     * A block containing Forward Error Correction data.
+     * Used for:
+     * 1. Data recovery
+     * 2. Error detection
+     * 3. System reliability
+     */
+    FECData = 3,
+    /**
+     * A block containing data with ownership information.
+     * Features:
+     * 1. Owner identification
+     * 2. Access control
+     * 3. Metadata support
+     */
+    EphemeralOwnedDataBlock = 10,
+    /**
+     * A block containing references to other blocks.
+     * Used for:
+     * 1. Organizing related blocks
+     * 2. Storing metadata
+     * 3. Building hierarchies
+     */
+    ConstituentBlockList = 20,
+    /**
+     * An extended CBL with file metadata.
+     * Features:
+     * 1. File name preservation
+     * 2. MIME type tracking
+     * 3. File system integration
+     */
+    ExtendedConstituentBlockListBlock = 21,
+    /**
+     * An encrypted block with ownership information.
+     * Features:
+     * 1. Data encryption
+     * 2. Owner identification
+     * 3. Access control
+     */
+    EncryptedOwnedDataBlock = 30,
+    /**
+     * An encrypted block containing block references.
+     */
+    EncryptedConstituentBlockListBlock = 31,
+    /**
+     * An encrypted block containing block references and metadata.
+     */
+    EncryptedExtendedConstituentBlockListBlock = 32,
+    /**
+     * A block that has been encrypted multiple times.
+     */
+    MultiEncryptedBlock = 33,
+    /**
+     * A reference to a block stored elsewhere.
+     * Features:
+     * 1. Lazy loading
+     * 2. Memory efficiency
+     * 3. Remote storage support
+     */
+    Handle = 40
+}
+/**
+ * Block types that are ephemeral and do not have a persistent ID.
+ */
+export declare const EphemeralBlockTypes: readonly BlockType[];
+/**
+ * Block types that are encrypted
+ */
+export declare const EncryptedBlockTypes: readonly BlockType[];
+export default BlockType;
+//# sourceMappingURL=blockType.d.ts.map

package/src/lib/enumerations/blockType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/blockType.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,oBAAY,SAAS;IACnB;;OAEG;IACH,OAAO,KAAK;IAEZ;;;;;;OAMG;IACH,sBAAsB,IAAI;IAE1B;;;;;;OAMG;IACH,MAAM,IAAI;IAEV;;;;;;OAMG;IACH,OAAO,IAAI;IAEX;;;;;;OAMG;IACH,OAAO,IAAI;IAEX;;;;;;OAMG;IACH,uBAAuB,KAAK;IAE5B;;;;;;OAMG;IACH,oBAAoB,KAAK;IAEzB;;;;;;OAMG;IACH,iCAAiC,KAAK;IAEtC;;;;;;OAMG;IACH,uBAAuB,KAAK;IAE5B;;OAEG;IACH,kCAAkC,KAAK;IAEvC;;OAEG;IACH,0CAA0C,KAAK;IAE/C;;OAEG;IACH,mBAAmB,KAAK;IAExB;;;;;;OAMG;IACH,MAAM,KAAK;CACZ;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,SAAS,EAQ1C,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,SAAS,EAI1C,CAAC;AAEX,eAAe,SAAS,CAAC"}

package/src/lib/enumerations/blockType.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedBlockTypes = exports.EphemeralBlockTypes = exports.BlockType = void 0;
+/**
+ * BlockType defines the different types of blocks in the Owner Free Filesystem (OFF).
+ * In OFF, blocks are organized in a hierarchy where each type serves a specific purpose:
+ *
+ * Data Storage:
+ * - RawData: Basic data storage without additional features
+ * - OwnedDataBlock: Data blocks with ownership information
+ * - EncryptedOwnedDataBlock: Encrypted data blocks with ownership
+ *
+ * Privacy & Security:
+ * - OwnerFreeWhitenedBlock: Data XORed with random blocks for privacy
+ * - Random: Random data blocks used for whitening
+ * - FECData: Forward Error Correction data for recovery
+ *
+ * Organization & Management:
+ * - ConstituentBlockList (CBL): Lists of block references and metadata
+ * - Handle: References to blocks stored elsewhere
+ */
+var BlockType;
+(function (BlockType) {
+    /**
+     * Used for uninitialized or invalid blocks
+     */
+    BlockType[BlockType["Unknown"] = -1] = "Unknown";
+    /**
+     * A block that has been XORed with random data for privacy.
+     * Key features:
+     * 1. Data is obscured through XOR operations
+     * 2. Original data can be recovered with the random blocks
+     * 3. Provides privacy without encryption overhead
+     */
+    BlockType[BlockType["OwnerFreeWhitenedBlock"] = 0] = "OwnerFreeWhitenedBlock";
+    /**
+     * A block containing random data.
+     * Used for:
+     * 1. Whitening other blocks through XOR
+     * 2. Adding entropy to the system
+     * 3. Supporting privacy features
+     */
+    BlockType[BlockType["Random"] = 1] = "Random";
+    /**
+     * A basic block containing raw data.
+     * Features:
+     * 1. Simple data storage
+     * 2. No additional metadata
+     * 3. Maximum storage efficiency
+     */
+    BlockType[BlockType["RawData"] = 2] = "RawData";
+    /**
+     * A block containing Forward Error Correction data.
+     * Used for:
+     * 1. Data recovery
+     * 2. Error detection
+     * 3. System reliability
+     */
+    BlockType[BlockType["FECData"] = 3] = "FECData";
+    /**
+     * A block containing data with ownership information.
+     * Features:
+     * 1. Owner identification
+     * 2. Access control
+     * 3. Metadata support
+     */
+    BlockType[BlockType["EphemeralOwnedDataBlock"] = 10] = "EphemeralOwnedDataBlock";
+    /**
+     * A block containing references to other blocks.
+     * Used for:
+     * 1. Organizing related blocks
+     * 2. Storing metadata
+     * 3. Building hierarchies
+     */
+    BlockType[BlockType["ConstituentBlockList"] = 20] = "ConstituentBlockList";
+    /**
+     * An extended CBL with file metadata.
+     * Features:
+     * 1. File name preservation
+     * 2. MIME type tracking
+     * 3. File system integration
+     */
+    BlockType[BlockType["ExtendedConstituentBlockListBlock"] = 21] = "ExtendedConstituentBlockListBlock";
+    /**
+     * An encrypted block with ownership information.
+     * Features:
+     * 1. Data encryption
+     * 2. Owner identification
+     * 3. Access control
+     */
+    BlockType[BlockType["EncryptedOwnedDataBlock"] = 30] = "EncryptedOwnedDataBlock";
+    /**
+     * An encrypted block containing block references.
+     */
+    BlockType[BlockType["EncryptedConstituentBlockListBlock"] = 31] = "EncryptedConstituentBlockListBlock";
+    /**
+     * An encrypted block containing block references and metadata.
+     */
+    BlockType[BlockType["EncryptedExtendedConstituentBlockListBlock"] = 32] = "EncryptedExtendedConstituentBlockListBlock";
+    /**
+     * A block that has been encrypted multiple times.
+     */
+    BlockType[BlockType["MultiEncryptedBlock"] = 33] = "MultiEncryptedBlock";
+    /**
+     * A reference to a block stored elsewhere.
+     * Features:
+     * 1. Lazy loading
+     * 2. Memory efficiency
+     * 3. Remote storage support
+     */
+    BlockType[BlockType["Handle"] = 40] = "Handle";
+})(BlockType || (exports.BlockType = BlockType = {}));
+/**
+ * Block types that are ephemeral and do not have a persistent ID.
+ */
+exports.EphemeralBlockTypes = [
+    BlockType.ConstituentBlockList,
+    BlockType.EphemeralOwnedDataBlock,
+    BlockType.ExtendedConstituentBlockListBlock,
+    BlockType.FECData,
+    BlockType.OwnerFreeWhitenedBlock,
+    BlockType.Random,
+    BlockType.RawData,
+];
+/**
+ * Block types that are encrypted
+ */
+exports.EncryptedBlockTypes = [
+    BlockType.EncryptedConstituentBlockListBlock,
+    BlockType.EncryptedExtendedConstituentBlockListBlock,
+    BlockType.EncryptedOwnedDataBlock,
+];
+exports.default = BlockType;
+//# sourceMappingURL=blockType.js.map

package/src/lib/enumerations/blockType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/blockType.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAY,SAqGX;AArGD,WAAY,SAAS;IACnB;;OAEG;IACH,gDAAY,CAAA;IAEZ;;;;;;OAMG;IACH,6EAA0B,CAAA;IAE1B;;;;;;OAMG;IACH,6CAAU,CAAA;IAEV;;;;;;OAMG;IACH,+CAAW,CAAA;IAEX;;;;;;OAMG;IACH,+CAAW,CAAA;IAEX;;;;;;OAMG;IACH,gFAA4B,CAAA;IAE5B;;;;;;OAMG;IACH,0EAAyB,CAAA;IAEzB;;;;;;OAMG;IACH,oGAAsC,CAAA;IAEtC;;;;;;OAMG;IACH,gFAA4B,CAAA;IAE5B;;OAEG;IACH,sGAAuC,CAAA;IAEvC;;OAEG;IACH,sHAA+C,CAAA;IAE/C;;OAEG;IACH,wEAAwB,CAAA;IAExB;;;;;;OAMG;IACH,8CAAW,CAAA;AACb,CAAC,EArGW,SAAS,yBAAT,SAAS,QAqGpB;AAED;;GAEG;AACU,QAAA,mBAAmB,GAAyB;IACvD,SAAS,CAAC,oBAAoB;IAC9B,SAAS,CAAC,uBAAuB;IACjC,SAAS,CAAC,iCAAiC;IAC3C,SAAS,CAAC,OAAO;IACjB,SAAS,CAAC,sBAAsB;IAChC,SAAS,CAAC,MAAM;IAChB,SAAS,CAAC,OAAO;CACT,CAAC;AAEX;;GAEG;AACU,QAAA,mBAAmB,GAAyB;IACvD,SAAS,CAAC,kCAAkC;IAC5C,SAAS,CAAC,0CAA0C;IACpD,SAAS,CAAC,uBAAuB;CACzB,CAAC;AAEX,kBAAe,SAAS,CAAC"}