@brightchain/brightchain-lib 0.24.1 → 0.25.0

package/src/lib/stores/memoryBlockStore.d.ts

@@ -20,8 +20,11 @@ import { MemoryBlockMetadataStore } from './memoryBlockMetadataStore';
  * @see IBlockStore for the interface definition
  */
 export declare class MemoryBlockStore implements IBlockStore {
+    /**
+     * Per-size block maps. Only maps for configured supportedBlockSizes are initialized.
+     */
     private readonly blocks;
-    private readonly _blockSize;
+    private readonly _supportedBlockSizes;
     /**
      * Optional FEC service for parity generation and recovery.
      * If not provided, FEC operations will return errors or no-ops.
@@ -38,11 +41,16 @@ export declare class MemoryBlockStore implements IBlockStore {
     private readonly parityBlocks;
     /**
      * Create a new MemoryBlockStore.
-     * @param blockSize - The block size for this store
+     * @param blockSizeOrSizes - A single BlockSize (backward compat) or an array of supported BlockSize values
      * @param fecService - Optional FEC service for parity generation and recovery
      * @param metadataStore - Optional metadata store (creates new one if not provided)
      */
-    constructor(blockSize: BlockSize, fecService?: IFecService | null, metadataStore?: MemoryBlockMetadataStore);
+    constructor(blockSizeOrSizes: BlockSize | readonly BlockSize[], fecService?: IFecService | null, metadataStore?: MemoryBlockMetadataStore);
+    get supportedBlockSizes(): readonly BlockSize[];
+    /**
+     * Backward-compatible getter: returns the first supported block size.
+     * @deprecated Use supportedBlockSizes instead.
+     */
     get blockSize(): BlockSize;
     /**
      * Get the FEC service if available.
@@ -67,29 +75,47 @@ export declare class MemoryBlockStore implements IBlockStore {
      */
     private hexToChecksum;
     /**
-     * Check if a block exists
+     * Find a block by key across all configured size maps.
+     * @returns The block if found, or undefined
+     */
+    private findBlock;
+    /**
+     * Check if a block exists in any size map (synchronous, no metadata).
+     */
+    private hasBlock;
+    /**
+     * Set a block directly in the correct size map (for internal use like recovery).
+     */
+    private setBlock;
+    /**
+     * Check if a block exists (searches across all configured size maps)
      */
     has(key: Checksum | string): Promise<boolean>;
     /**
-     * Get a block's data
+     * Get a block's data (searches across all configured size maps)
      */
     getData(key: Checksum): Promise<RawDataBlock>;
     /**
      * Store a block's data with optional durability settings.
+     * Validates that block.blockSize is in supportedBlockSizes before accepting.
      * @param block - The block to store
      * @param options - Optional storage options including durability level and expiration
      */
     setData(block: RawDataBlock, options?: BlockStoreOptions): Promise<void>;
     /**
-     * Delete a block's data (and associated parity blocks and metadata)
+     * Delete a block's data (and associated parity blocks and metadata).
+     * Searches across all configured size maps.
      */
     deleteData(key: Checksum): Promise<void>;
     /**
-     * Get random block checksums from the store
+     * Get random block checksums from the store for a specific block size.
+     * @param count - Number of random block checksums to return
+     * @param blockSize - The block size pool to draw from (must be in supportedBlockSizes)
      */
-    getRandomBlocks(count: number): Promise<Checksum[]>;
+    getRandomBlocks(count: number, blockSize: BlockSize): Promise<Checksum[]>;
     /**
-     * Store a block's data (alias for setData)
+     * Store raw data with a key (convenience method).
+     * Uses the first supported block size for block creation.
      */
     put(key: Checksum | string, data: Uint8Array, options?: BlockStoreOptions): Promise<void>;
     /**
@@ -101,15 +127,15 @@ export declare class MemoryBlockStore implements IBlockStore {
      */
     static randomId(): string;
     /**
-     * Clear all blocks, metadata, and parity data
+     * Clear all blocks, metadata, and parity data across all size maps
      */
     clear(): void;
     /**
-     * Get total number of blocks
+     * Get total number of blocks across all size maps
      */
     size(): number;
     /**
-     * Get a handle to a block
+     * Get a handle to a block (searches across all configured size maps)
      */
     get<T extends BaseBlock>(key: Checksum | string): BlockHandle<T>;
     /**

package/src/lib/stores/memoryBlockStore.d.ts.map

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

package/src/lib/stores/memoryBlockStore.js

@@ -39,8 +39,11 @@ function toStorageKey(hex) {
  * @see IBlockStore for the interface definition
  */
 class MemoryBlockStore {
+    /**
+     * Per-size block maps. Only maps for configured supportedBlockSizes are initialized.
+     */
     blocks = new Map();
-    _blockSize;
+    _supportedBlockSizes;
     /**
      * Optional FEC service for parity generation and recovery.
      * If not provided, FEC operations will return errors or no-ops.
@@ -57,17 +60,30 @@ class MemoryBlockStore {
     parityBlocks = new Map();
     /**
      * Create a new MemoryBlockStore.
-     * @param blockSize - The block size for this store
+     * @param blockSizeOrSizes - A single BlockSize (backward compat) or an array of supported BlockSize values
      * @param fecService - Optional FEC service for parity generation and recovery
      * @param metadataStore - Optional metadata store (creates new one if not provided)
      */
-    constructor(blockSize, fecService, metadataStore) {
-        this._blockSize = blockSize;
+    constructor(blockSizeOrSizes, fecService, metadataStore) {
+        this._supportedBlockSizes = Array.isArray(blockSizeOrSizes)
+            ? blockSizeOrSizes
+            : [blockSizeOrSizes];
+        // Initialize per-size maps only for configured sizes
+        for (const size of this._supportedBlockSizes) {
+            this.blocks.set(size, new Map());
+        }
         this.fecService = fecService ?? null;
         this.metadataStore = metadataStore ?? new memoryBlockMetadataStore_1.MemoryBlockMetadataStore();
     }
+    get supportedBlockSizes() {
+        return this._supportedBlockSizes;
+    }
+    /**
+     * Backward-compatible getter: returns the first supported block size.
+     * @deprecated Use supportedBlockSizes instead.
+     */
     get blockSize() {
-        return this._blockSize;
+        return this._supportedBlockSizes[0];
     }
     /**
      * Get the FEC service if available.
@@ -100,37 +116,85 @@ class MemoryBlockStore {
         return checksum_1.Checksum.fromHex(hex);
     }
     /**
-     * Check if a block exists
+     * Find a block by key across all configured size maps.
+     * @returns The block if found, or undefined
+     */
+    findBlock(keyHex) {
+        for (const sizeMap of this.blocks.values()) {
+            const block = sizeMap.get(keyHex);
+            if (block)
+                return block;
+        }
+        return undefined;
+    }
+    /**
+     * Check if a block exists in any size map (synchronous, no metadata).
+     */
+    hasBlock(keyHex) {
+        for (const sizeMap of this.blocks.values()) {
+            if (sizeMap.has(keyHex))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Set a block directly in the correct size map (for internal use like recovery).
+     */
+    setBlock(keyHex, block) {
+        const sizeMap = this.blocks.get(block.blockSize);
+        if (sizeMap) {
+            sizeMap.set(keyHex, block);
+        }
+    }
+    /**
+     * Check if a block exists (searches across all configured size maps)
      */
     async has(key) {
         const keyHex = this.keyToHex(key);
-        return this.blocks.has(keyHex);
+        for (const sizeMap of this.blocks.values()) {
+            if (sizeMap.has(keyHex)) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
-     * Get a block's data
+     * Get a block's data (searches across all configured size maps)
      */
     async getData(key) {
         const keyHex = this.keyToHex(key);
-        const block = this.blocks.get(keyHex);
-        if (!block) {
-            throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound, undefined, {
-                KEY: keyHex,
-            });
-        }
-        // Record access in metadata
-        if (this.metadataStore.has(keyHex)) {
-            await this.metadataStore.recordAccess(toStorageKey(keyHex));
+        for (const sizeMap of this.blocks.values()) {
+            const block = sizeMap.get(keyHex);
+            if (block) {
+                // Record access in metadata
+                if (this.metadataStore.has(keyHex)) {
+                    await this.metadataStore.recordAccess(toStorageKey(keyHex));
+                }
+                return block;
+            }
         }
-        return block;
+        throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound, undefined, {
+            KEY: keyHex,
+        });
     }
     /**
      * Store a block's data with optional durability settings.
+     * Validates that block.blockSize is in supportedBlockSizes before accepting.
      * @param block - The block to store
      * @param options - Optional storage options including durability level and expiration
      */
     async setData(block, options) {
+        // Validate block size membership
+        if (!this._supportedBlockSizes.includes(block.blockSize)) {
+            throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.BlockValidationFailed);
+        }
         const keyHex = block.idChecksum.toHex();
-        if (this.blocks.has(keyHex)) {
+        // Check idempotency across all size maps
+        const sizeMap = this.blocks.get(block.blockSize);
+        if (!sizeMap) {
+            throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.BlockValidationFailed);
+        }
+        if (sizeMap.has(keyHex)) {
             return; // Idempotent - block already exists
         }
         try {
@@ -139,11 +203,9 @@ class MemoryBlockStore {
         catch {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.BlockValidationFailed);
         }
-        // Store the block
-        this.blocks.set(keyHex, block);
+        // Store the block in the correct size-specific map
+        sizeMap.set(keyHex, block);
         // Create metadata for the block
-        // keyHex is the SHA3-512 checksum hex (128 chars) used as the storage key.
-        // We cast it directly to BlockId since it serves as an opaque storage key here.
         const metadata = (0, blockMetadata_1.createDefaultBlockMetadata)(keyHex, block.data.length, keyHex, options);
         await this.metadataStore.create(metadata);
         // Generate parity blocks based on durability level
@@ -160,15 +222,22 @@ class MemoryBlockStore {
         }
     }
     /**
-     * Delete a block's data (and associated parity blocks and metadata)
+     * Delete a block's data (and associated parity blocks and metadata).
+     * Searches across all configured size maps.
      */
     async deleteData(key) {
         const keyHex = this.keyToHex(key);
-        if (!this.blocks.has(keyHex)) {
+        let found = false;
+        for (const sizeMap of this.blocks.values()) {
+            if (sizeMap.has(keyHex)) {
+                sizeMap.delete(keyHex);
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound);
         }
-        // Delete the block data
-        this.blocks.delete(keyHex);
         // Delete parity blocks
         this.parityBlocks.delete(keyHex);
         // Delete metadata (if exists)
@@ -177,10 +246,19 @@ class MemoryBlockStore {
         }
     }
     /**
-     * Get random block checksums from the store
+     * Get random block checksums from the store for a specific block size.
+     * @param count - Number of random block checksums to return
+     * @param blockSize - The block size pool to draw from (must be in supportedBlockSizes)
      */
-    async getRandomBlocks(count) {
-        const allKeys = Array.from(this.blocks.keys());
+    async getRandomBlocks(count, blockSize) {
+        if (!this._supportedBlockSizes.includes(blockSize)) {
+            throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.BlockValidationFailed);
+        }
+        const sizeMap = this.blocks.get(blockSize);
+        if (!sizeMap) {
+            return [];
+        }
+        const allKeys = Array.from(sizeMap.keys());
         const result = [];
         const actualCount = Math.min(count, allKeys.length);
         const shuffled = [...allKeys].sort(() => Math.random() - 0.5);
@@ -191,14 +269,17 @@ class MemoryBlockStore {
         return result;
     }
     /**
-     * Store a block's data (alias for setData)
+     * Store raw data with a key (convenience method).
+     * Uses the first supported block size for block creation.
      */
     async put(key, data, options) {
-        if (this._blockSize !== blockSize_1.BlockSize.Unknown &&
-            data.length > this._blockSize) {
+        // Determine the appropriate block size for this data
+        const targetSize = this._supportedBlockSizes.find((size) => size === blockSize_1.BlockSize.Unknown || data.length <= size) ?? this._supportedBlockSizes[0];
+        if (targetSize !== blockSize_1.BlockSize.Unknown &&
+            data.length > targetSize) {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.BlockValidationFailed);
         }
-        const block = new rawData_1.RawDataBlock(this._blockSize, data);
+        const block = new rawData_1.RawDataBlock(targetSize, data);
         await this.setData(block, options);
     }
     /**
@@ -217,32 +298,40 @@ class MemoryBlockStore {
         return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
     }
     /**
-     * Clear all blocks, metadata, and parity data
+     * Clear all blocks, metadata, and parity data across all size maps
      */
     clear() {
-        this.blocks.clear();
+        for (const sizeMap of this.blocks.values()) {
+            sizeMap.clear();
+        }
         this.parityBlocks.clear();
         this.metadataStore.clear();
     }
     /**
-     * Get total number of blocks
+     * Get total number of blocks across all size maps
      */
     size() {
-        return this.blocks.size;
+        let total = 0;
+        for (const sizeMap of this.blocks.values()) {
+            total += sizeMap.size;
+        }
+        return total;
     }
     /**
-     * Get a handle to a block
+     * Get a handle to a block (searches across all configured size maps)
      */
     get(key) {
         const keyHex = this.keyToHex(key);
-        const block = this.blocks.get(keyHex);
-        if (!block) {
-            throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound, undefined, {
-                KEY: keyHex,
-            });
+        for (const sizeMap of this.blocks.values()) {
+            const block = sizeMap.get(keyHex);
+            if (block) {
+                const checksum = typeof key === 'string' ? this.hexToChecksum(key) : key;
+                return (0, handle_1.createBlockHandle)(rawData_1.RawDataBlock, block.blockSize, block.data, checksum, block.canRead, block.canPersist);
+            }
         }
-        const checksum = typeof key === 'string' ? this.hexToChecksum(key) : key;
-        return (0, handle_1.createBlockHandle)(rawData_1.RawDataBlock, block.blockSize, block.data, checksum, block.canRead, block.canPersist);
+        throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound, undefined, {
+            KEY: keyHex,
+        });
     }
     // === Metadata Operations ===
     /**
@@ -285,7 +374,7 @@ class MemoryBlockStore {
             });
         }
         // Check if block exists
-        const block = this.blocks.get(keyHex);
+        const block = this.findBlock(keyHex);
         if (!block) {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound, undefined, {
                 KEY: keyHex,
@@ -366,15 +455,19 @@ class MemoryBlockStore {
         }
         try {
             // Get corrupted data if block still exists
-            const existingBlock = this.blocks.get(keyHex);
+            const existingBlock = this.findBlock(keyHex);
             const corruptedData = existingBlock ? existingBlock.data : null;
             // Attempt recovery
             const result = await this.fecService.recoverFileData(corruptedData, parityData, metadata.size);
             if (result.recovered) {
+                // Determine the block size from existing block or first supported size
+                const recoveryBlockSize = existingBlock
+                    ? existingBlock.blockSize
+                    : this._supportedBlockSizes[0];
                 // Create a new block with recovered data
-                const recoveredBlock = new rawData_1.RawDataBlock(this._blockSize, new Uint8Array(result.data));
-                // Update the stored block
-                this.blocks.set(keyHex, recoveredBlock);
+                const recoveredBlock = new rawData_1.RawDataBlock(recoveryBlockSize, new Uint8Array(result.data));
+                // Update the stored block in the correct size map
+                this.setBlock(keyHex, recoveredBlock);
                 return {
                     success: true,
                     recoveredBlock,
@@ -404,16 +497,16 @@ class MemoryBlockStore {
         // Check if FEC service is available
         if (!this.fecService) {
             // Without FEC service, we can only verify the block exists
-            return this.blocks.has(keyHex);
+            return this.hasBlock(keyHex);
         }
         // Check if FEC service is available in the environment
         const isAvailable = await this.fecService.isAvailable();
         if (!isAvailable) {
             // Without FEC service, we can only verify the block exists
-            return this.blocks.has(keyHex);
+            return this.hasBlock(keyHex);
         }
         // Get block data
-        const block = this.blocks.get(keyHex);
+        const block = this.findBlock(keyHex);
         if (!block) {
             return false;
         }
@@ -527,14 +620,14 @@ class MemoryBlockStore {
     async brightenBlock(key, randomBlockCount) {
         const keyHex = this.keyToHex(key);
         // Verify source block exists
-        const sourceBlock = this.blocks.get(keyHex);
+        const sourceBlock = this.findBlock(keyHex);
         if (!sourceBlock) {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.KeyNotFound, undefined, {
                 KEY: keyHex,
             });
         }
-        // Get random blocks for XOR operation
-        const randomBlockChecksums = await this.getRandomBlocks(randomBlockCount);
+        // Get random blocks for XOR operation (same size as source block)
+        const randomBlockChecksums = await this.getRandomBlocks(randomBlockCount, sourceBlock.blockSize);
         // Check if we have enough random blocks
         if (randomBlockChecksums.length < randomBlockCount) {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.InsufficientRandomBlocks, undefined, {
@@ -555,11 +648,11 @@ class MemoryBlockStore {
         ];
         // Perform XOR operation using XorService: source XOR random1 XOR random2 XOR ...
         const brightenedData = xor_1.XorService.xorMultiple(allBlockData);
-        // Create the brightened block
-        const brightenedBlock = new rawData_1.RawDataBlock(this._blockSize, brightenedData);
+        // Create the brightened block (same size as source)
+        const brightenedBlock = new rawData_1.RawDataBlock(sourceBlock.blockSize, brightenedData);
         const brightenedBlockId = brightenedBlock.idChecksum.toHex();
         // Store the brightened block if it doesn't already exist
-        if (!this.blocks.has(brightenedBlockId)) {
+        if (!this.hasBlock(brightenedBlockId)) {
             await this.setData(brightenedBlock);
         }
         // Get the random block IDs as hex strings
@@ -595,13 +688,15 @@ class MemoryBlockStore {
             });
         }
         // 1. Pad CBL to block size (includes length prefix)
-        const paddedCbl = (0, xorUtils_1.padToBlockSize)(cblData, this._blockSize);
+        // Use the first supported block size for CBL operations
+        const cblBlockSize = this._supportedBlockSizes[0];
+        const paddedCbl = (0, xorUtils_1.padToBlockSize)(cblData, cblBlockSize);
         // Validate that padded CBL fits within block size
-        if (paddedCbl.length > this._blockSize) {
+        if (paddedCbl.length > cblBlockSize) {
             throw new storeError_1.StoreError(storeErrorType_1.StoreErrorType.BlockValidationFailed, undefined, {
                 ERROR: (0, i18n_1.translate)(enumerations_1.BrightChainStrings.MemoryBlockStore_CBLDataTooLargeTemplate, {
                     LENGTH: paddedCbl.length,
-                    BLOCK_SIZE: this._blockSize,
+                    BLOCK_SIZE: cblBlockSize,
                 }),
             });
         }
@@ -618,7 +713,7 @@ class MemoryBlockStore {
             // 4. Store first block (R - the randomizer block)
             // Note: If this was selected from existing blocks, it's already stored
             // We still create a block handle for it to get the ID
-            const block1 = new rawData_1.RawDataBlock(this._blockSize, randomBlock);
+            const block1 = new rawData_1.RawDataBlock(cblBlockSize, randomBlock);
             const block1Checksum = block1.idChecksum;
             // Only store if not already in the store
             if (!(await this.has(block1Checksum))) {
@@ -627,7 +722,7 @@ class MemoryBlockStore {
             }
             block1Id = toStorageKey(block1Checksum.toHex());
             // 5. Store second block (CBL XOR R)
-            const block2 = new rawData_1.RawDataBlock(this._blockSize, xorResult);
+            const block2 = new rawData_1.RawDataBlock(cblBlockSize, xorResult);
             await this.setData(block2, options);
             const block2Id = toStorageKey(block2.idChecksum.toHex());
             // 6. Get parity block IDs if FEC redundancy was applied
@@ -642,11 +737,11 @@ class MemoryBlockStore {
                 block2ParityIds = block2Meta.parityBlockIds;
             }
             // 7. Generate magnet URL
-            const magnetUrl = this.generateCBLMagnetUrl(block1Id, block2Id, this._blockSize, block1ParityIds, block2ParityIds, options?.isEncrypted);
+            const magnetUrl = this.generateCBLMagnetUrl(block1Id, block2Id, cblBlockSize, block1ParityIds, block2ParityIds, options?.isEncrypted);
             return {
                 blockId1: block1Id,
                 blockId2: block2Id,
-                blockSize: this._blockSize,
+                blockSize: cblBlockSize,
                 magnetUrl,
                 block1ParityIds,
                 block2ParityIds,
@@ -678,15 +773,20 @@ class MemoryBlockStore {
      * @returns A Uint8Array containing the randomizer data
      */
     async selectOrGenerateRandomizer(size) {
-        // Get all block IDs from the store
-        const blockIds = Array.from(this.blocks.keys());
+        // Collect all block keys across all size maps
+        const blockIds = [];
+        for (const sizeMap of this.blocks.values()) {
+            for (const key of sizeMap.keys()) {
+                blockIds.push(key);
+            }
+        }
         // If we have existing blocks, try to use one as a randomizer
         if (blockIds.length > 0) {
             // Select a random block from the existing blocks
             const randomIndex = Math.floor(Math.random() * blockIds.length);
             const selectedBlockId = blockIds[randomIndex];
             try {
-                const block = this.blocks.get(selectedBlockId);
+                const block = this.findBlock(selectedBlockId);
                 if (block && block.data.length >= size) {
                     // Use the first 'size' bytes of the existing block as the randomizer
                     return block.data.slice(0, size);