@brightchain/brightchain-lib 0.1.4 → 0.1.6

package/src/lib/services/cblService.js

@@ -11,9 +11,24 @@ const cblErrorType_1 = require("../enumerations/cblErrorType");
 const extendedCblErrorType_1 = require("../enumerations/extendedCblErrorType");
 const cblError_1 = require("../errors/cblError");
 const extendedCblError_1 = require("../errors/extendedCblError");
+const checksum_1 = require("../types/checksum");
+const validator_1 = require("../utils/validator");
 const blockCapacity_service_1 = require("./blockCapacity.service");
 /**
- * Service for creating and verifying CBL blocks
+ * Service for creating and verifying CBL blocks.
+ *
+ * This service provides functionality for:
+ * - Creating CBL headers with proper validation
+ * - Parsing CBL headers from data
+ * - Validating file names and MIME types
+ * - Calculating CBL address capacity
+ *
+ * @remarks
+ * - All methods validate inputs before processing
+ * - Errors are wrapped in CblError or ExtendedCblError with appropriate context
+ * - The service supports both standard and extended CBL blocks
+ *
+ * @see Requirements 5.1, 5.2, 5.3, 12.1, 12.2, 12.7
  */
 class CBLService {
     /**
@@ -48,66 +63,142 @@ class CBLService {
         return this.enhancedProvider.byteLength;
     }
     /**
-     * Static creator length for backward compatibility
-     * @deprecated Use instance method creatorLength instead
+     * Offset of the date field in the header (instance method for dynamic provider support)
      */
-    static get CreatorLength() {
-        // Use default provider for backward compatibility
-        return (0, ecies_lib_1.getEnhancedIdProvider)().byteLength;
+    get dateCreatedOffset() {
+        return this.creatorLength;
     }
     /**
-     * Offset of the date field in the header
+     * Offset of the date field in the header (static for backward compatibility)
+     * @deprecated Use instance method dateCreatedOffset instead
      */
     static get DateCreatedOffset() {
-        return CBLService.CreatorLength;
+        return CBLService.CreatorIdLength;
     }
     /**
-     * Offset of the address count field in the header
+     * Offset of the address count field in the header (instance method)
+     */
+    get cblAddressCountOffset() {
+        return this.dateCreatedOffset + CBLService.DateSize;
+    }
+    /**
+     * Offset of the address count field in the header (static for backward compatibility)
+     * @deprecated Use instance method cblAddressCountOffset instead
      */
     static get CblAddressCountOffset() {
         return CBLService.DateCreatedOffset + CBLService.DateSize;
     }
     /**
-     * Offset of the tuple size field in the header
+     * Offset of the tuple size field in the header (instance method)
+     */
+    get tupleSizeOffset() {
+        return this.cblAddressCountOffset + CBLService.AddressCountSize;
+    }
+    /**
+     * Offset of the tuple size field in the header (static for backward compatibility)
+     * @deprecated Use instance method tupleSizeOffset instead
      */
     static get TupleSizeOffset() {
         return CBLService.CblAddressCountOffset + CBLService.AddressCountSize;
     }
     /**
-     * Offset of the original data length field in the header
+     * Offset of the original data length field in the header (instance method)
+     */
+    get originalDataLengthOffset() {
+        return this.tupleSizeOffset + CBLService.TupleSizeSize;
+    }
+    /**
+     * Offset of the original data length field in the header (static for backward compatibility)
+     * @deprecated Use instance method originalDataLengthOffset instead
      */
     static get OriginalDataLengthOffset() {
         return CBLService.TupleSizeOffset + CBLService.TupleSizeSize;
     }
+    /**
+     * Offset of the original checksum field in the header (instance method)
+     */
+    get originalChecksumOffset() {
+        return this.originalDataLengthOffset + CBLService.DataLengthSize;
+    }
+    /**
+     * Static offset for backward compatibility
+     * @deprecated Use instance method originalChecksumOffset instead
+     */
     static get OriginalChecksumOffset() {
         return CBLService.OriginalDataLengthOffset + CBLService.DataLengthSize;
     }
     /**
-     * Offset of the is extended header field in the header
+     * Offset of the is extended header field in the header (instance method)
+     */
+    get isExtendedHeaderOffset() {
+        return this.originalChecksumOffset + CBLService.DataChecksumSize;
+    }
+    /**
+     * Offset of the is extended header field in the header (static for backward compatibility)
+     * @deprecated Use instance method isExtendedHeaderOffset instead
      */
     static get IsExtendedHeaderOffset() {
         return CBLService.OriginalChecksumOffset + CBLService.DataChecksumSize;
     }
     /**
-     * Offset of the creator signature field in the header
+     * Offset of the creator signature field in the header (instance method)
+     */
+    get baseHeaderCreatorSignatureOffset() {
+        return this.isExtendedHeaderOffset + CBLService.IsExtendedHeaderSize;
+    }
+    /**
+     * Offset of the creator signature field in the header (static for backward compatibility)
+     * @deprecated Use instance method baseHeaderCreatorSignatureOffset instead
      */
     static get BaseHeaderCreatorSignatureOffset() {
         return CBLService.IsExtendedHeaderOffset + CBLService.IsExtendedHeaderSize;
     }
     /**
-     * Length of the base header with signature
+     * Length of the base header with signature (instance method)
+     */
+    get baseHeaderSize() {
+        return (this.baseHeaderCreatorSignatureOffset + CBLService.CreatorSignatureSize);
+    }
+    /**
+     * Length of the base header with signature (static for backward compatibility)
+     * @deprecated Use instance method baseHeaderSize instead
      */
     static get BaseHeaderSize() {
-        return CBLService.BaseHeaderCreatorSignatureOffset + CBLService.CreatorSignatureSize;
+        return (CBLService.BaseHeaderCreatorSignatureOffset +
+            CBLService.CreatorSignatureSize);
+    }
+    /**
+     * Offset of the file name length field in the header (instance method)
+     */
+    get fileNameLengthOffset() {
+        return this.baseHeaderCreatorSignatureOffset;
     }
     /**
-     * Offset of the file name length field in the header
+     * Offset of the file name length field in the header (static for backward compatibility)
+     * @deprecated Use instance method fileNameLengthOffset instead
      */
     static get FileNameLengthOffset() {
         return CBLService.BaseHeaderCreatorSignatureOffset;
     }
+    /**
+     * Instance offsets for dynamic provider support
+     */
+    get headerOffsets() {
+        return {
+            CreatorId: 0,
+            DateCreated: this.dateCreatedOffset,
+            CblAddressCount: this.cblAddressCountOffset,
+            TupleSize: this.tupleSizeOffset,
+            OriginalDataLength: this.originalDataLengthOffset,
+            OriginalDataChecksum: this.originalChecksumOffset,
+            CreatorSignature: this.baseHeaderCreatorSignatureOffset,
+            IsExtendedHeader: this.isExtendedHeaderOffset,
+            FileNameLength: this.fileNameLengthOffset,
+        };
+    }
     /**
      * Static offsets for backward compatibility
+     * @deprecated Use instance method headerOffsets instead
      */
     static get HeaderOffsets() {
         return {
@@ -130,6 +221,59 @@ class CBLService {
     isEncrypted(data) {
         return data[0] === constants_1.ECIES.PUBLIC_KEY_MAGIC;
     }
+    /**
+     * Check if the header is a message CBL
+     */
+    isMessageHeader(header) {
+        if (this.isEncrypted(header)) {
+            throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
+        }
+        const offset = this.baseHeaderCreatorSignatureOffset;
+        return header.length > offset && header[offset] === 2;
+    }
+    /**
+     * Get message header offsets
+     */
+    getMessageHeaderOffsets(header) {
+        if (this.isEncrypted(header)) {
+            throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
+        }
+        if (!this.isMessageHeader(header)) {
+            throw new cblError_1.CblError(cblErrorType_1.CblErrorType.InvalidStructure, 'Not a message CBL');
+        }
+        let offset = this.baseHeaderCreatorSignatureOffset + constants_1.default['UINT8_SIZE'];
+        const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+        const messageTypeLength = view.getUint16(offset, false);
+        const messageTypeOffset = offset + constants_1.default['UINT16_SIZE'];
+        offset = messageTypeOffset + messageTypeLength;
+        const senderIdLength = view.getUint16(offset, false);
+        const senderIdOffset = offset + constants_1.default['UINT16_SIZE'];
+        offset = senderIdOffset + senderIdLength;
+        const recipientCount = view.getUint16(offset, false);
+        const recipientsOffset = offset + constants_1.default['UINT16_SIZE'];
+        offset = recipientsOffset + recipientCount * constants_1.default['UINT16_SIZE'];
+        for (let i = 0; i < recipientCount; i++) {
+            const recipientLength = view.getUint16(recipientsOffset + i * constants_1.default['UINT16_SIZE'], false);
+            offset += recipientLength;
+        }
+        const priorityOffset = offset;
+        offset += constants_1.default['UINT8_SIZE'];
+        const encryptionSchemeLength = header[offset];
+        const encryptionSchemeOffset = offset + constants_1.default['UINT8_SIZE'];
+        offset = encryptionSchemeOffset + encryptionSchemeLength;
+        return {
+            messageTypeLength,
+            messageTypeOffset,
+            senderIdLength,
+            senderIdOffset,
+            recipientCount,
+            recipientsOffset,
+            priorityOffset,
+            encryptionSchemeLength,
+            encryptionSchemeOffset,
+            signatureOffset: offset,
+        };
+    }
     /**
      * Helper function to check if a string contains control characters
      * @param str The string to check
@@ -149,32 +293,12 @@ class CBLService {
      * Get the creator ID from the header
      */
     getCreatorId(header) {
-        try {
-            const idBytes = header.subarray(CBLService.HeaderOffsets.CreatorId, CBLService.HeaderOffsets.CreatorId + this.creatorLength);
-            // Validate the byte length before attempting to parse
-            if (idBytes.length !== this.creatorLength) {
-                console.warn(`Creator ID byte length mismatch: got ${idBytes.length}, expected ${this.creatorLength}`);
-                // Return a default ID or throw a more specific error
-                // For now, we'll create a padded version
-                const paddedBytes = new Uint8Array(this.creatorLength);
-                paddedBytes.set(idBytes.subarray(0, Math.min(idBytes.length, this.creatorLength)));
-                return this.enhancedProvider.fromBytes(paddedBytes);
-            }
-            return this.enhancedProvider.fromBytes(idBytes);
-        }
-        catch (error) {
-            // Return a default ID to allow tests to continue
-            // Create a valid GUID with all zeros
-            const defaultBytes = new Uint8Array(this.creatorLength);
-            try {
-                return this.enhancedProvider.fromBytes(defaultBytes);
-            }
-            catch (fallbackError) {
-                // If even the default fails, create a minimal valid ID
-                // For Uint8Array, just return the bytes directly
-                return defaultBytes;
-            }
+        const idBytes = header.subarray(this.headerOffsets.CreatorId, this.headerOffsets.CreatorId + this.creatorLength);
+        // Validate the byte length matches expected
+        if (idBytes.length !== this.creatorLength) {
+            throw new cblError_1.CblError(cblErrorType_1.CblErrorType.InvalidStructure, `Creator ID byte length mismatch: got ${idBytes.length}, expected ${this.creatorLength}`);
         }
+        return this.enhancedProvider.fromBytes(idBytes);
     }
     /**
      * Get the date created from the header
@@ -184,8 +308,8 @@ class CBLService {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
         const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
-        const high = view.getUint32(CBLService.HeaderOffsets.DateCreated, false);
-        const low = view.getUint32(CBLService.HeaderOffsets.DateCreated + constants_1.default['UINT32_SIZE'], false);
+        const high = view.getUint32(this.headerOffsets.DateCreated, false);
+        const low = view.getUint32(this.headerOffsets.DateCreated + constants_1.default['UINT32_SIZE'], false);
         return new Date(high * 0x100000000 + low);
     }
     /**
@@ -196,7 +320,7 @@ class CBLService {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
         const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
-        return view.getUint32(CBLService.HeaderOffsets.CblAddressCount, false);
+        return view.getUint32(this.headerOffsets.CblAddressCount, false);
     }
     /**
      * Get the tuple size from the header
@@ -205,7 +329,7 @@ class CBLService {
         if (this.isEncrypted(header)) {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
-        return header[CBLService.HeaderOffsets.TupleSize];
+        return header[this.headerOffsets.TupleSize];
     }
     /**
      * Get the original data length from the header
@@ -215,7 +339,7 @@ class CBLService {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
         const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
-        const bigIntValue = view.getBigUint64(CBLService.HeaderOffsets.OriginalDataLength, false);
+        const bigIntValue = view.getBigUint64(this.headerOffsets.OriginalDataLength, false);
         return Number(bigIntValue);
     }
     /**
@@ -227,7 +351,8 @@ class CBLService {
         if (this.isEncrypted(header)) {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
-        return header.subarray(CBLService.HeaderOffsets.OriginalDataChecksum, CBLService.HeaderOffsets.OriginalDataChecksum + CBLService.DataChecksumSize);
+        const checksumData = header.subarray(this.headerOffsets.OriginalDataChecksum, this.headerOffsets.OriginalDataChecksum + CBLService.DataChecksumSize);
+        return checksum_1.Checksum.fromUint8Array(checksumData);
     }
     /**
      * Get the is extended header from the header
@@ -236,7 +361,7 @@ class CBLService {
         if (this.isEncrypted(header)) {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
-        return header[CBLService.HeaderOffsets.IsExtendedHeader] === 1;
+        return header[this.headerOffsets.IsExtendedHeader] === 1;
     }
     /**
      * Get cached extended header information
@@ -248,7 +373,7 @@ class CBLService {
         if (!this.isExtendedHeader(header)) {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.NotExtendedCbl);
         }
-        let offset = CBLService.BaseHeaderCreatorSignatureOffset;
+        let offset = this.baseHeaderCreatorSignatureOffset;
         const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
         // Read file name length
         const fileNameLength = view.getUint16(offset, false);
@@ -326,7 +451,7 @@ class CBLService {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
         const signatureOffset = !this.isExtendedHeader(header)
-            ? CBLService.HeaderOffsets.CreatorSignature
+            ? this.headerOffsets.CreatorSignature
             : this.getExtendedHeaderOffsets(header).signatureOffset;
         return header.subarray(signatureOffset, signatureOffset + CBLService.CreatorSignatureSize);
     }
@@ -338,7 +463,7 @@ class CBLService {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.CblEncrypted);
         }
         if (!this.isExtendedHeader(data)) {
-            return CBLService.BaseHeaderSize;
+            return this.baseHeaderSize;
         }
         const { signatureOffset } = this.getExtendedHeaderOffsets(data);
         return signatureOffset + CBLService.CreatorSignatureSize;
@@ -373,7 +498,8 @@ class CBLService {
         const addresses = new Array(addressCount);
         for (let i = 0; i < addressCount; i++) {
             const addressOffset = i * constants_1.CHECKSUM.SHA3_BUFFER_LENGTH;
-            addresses[i] = addressData.subarray(addressOffset, addressOffset + constants_1.CHECKSUM.SHA3_BUFFER_LENGTH);
+            const checksumData = addressData.subarray(addressOffset, addressOffset + constants_1.CHECKSUM.SHA3_BUFFER_LENGTH);
+            addresses[i] = checksum_1.Checksum.fromUint8Array(checksumData);
         }
         return addresses;
     }
@@ -412,7 +538,7 @@ class CBLService {
         ]);
         const checksum = this.checksumService.calculateChecksum(toSign);
         const signature = this.getSignature(data);
-        return this.eciesService.verifyMessage(creator.publicKey, checksum, signature);
+        return this.eciesService.verifyMessage(creator.publicKey, checksum.toUint8Array(), signature);
     }
     /**
      * Validate the file name format
@@ -482,6 +608,53 @@ class CBLService {
             constants_1.default['UINT8_SIZE'] +
             mimeType.length);
     }
+    /**
+     * Create message CBL header extension
+     */
+    makeMessageHeader(messageType, senderId, recipients, priority, encryptionScheme) {
+        const encoder = new TextEncoder();
+        const messageTypeBytes = encoder.encode(messageType);
+        const senderIdBytes = encoder.encode(senderId);
+        const recipientBytes = recipients.map((r) => encoder.encode(r));
+        const encryptionSchemeBytes = encoder.encode(encryptionScheme);
+        const totalLength = constants_1.default['UINT8_SIZE'] + // isMessage flag
+            constants_1.default['UINT16_SIZE'] +
+            messageTypeBytes.length +
+            constants_1.default['UINT16_SIZE'] +
+            senderIdBytes.length +
+            constants_1.default['UINT16_SIZE'] +
+            recipientBytes.reduce((sum, r) => sum + constants_1.default['UINT16_SIZE'] + r.length, 0) +
+            constants_1.default['UINT8_SIZE'] + // priority
+            constants_1.default['UINT8_SIZE'] +
+            encryptionSchemeBytes.length;
+        const result = new Uint8Array(totalLength);
+        const view = new DataView(result.buffer);
+        let offset = 0;
+        result[offset] = 2; // isMessage flag
+        offset += constants_1.default['UINT8_SIZE'];
+        view.setUint16(offset, messageTypeBytes.length, false);
+        offset += constants_1.default['UINT16_SIZE'];
+        result.set(messageTypeBytes, offset);
+        offset += messageTypeBytes.length;
+        view.setUint16(offset, senderIdBytes.length, false);
+        offset += constants_1.default['UINT16_SIZE'];
+        result.set(senderIdBytes, offset);
+        offset += senderIdBytes.length;
+        view.setUint16(offset, recipients.length, false);
+        offset += constants_1.default['UINT16_SIZE'];
+        for (const recipientByte of recipientBytes) {
+            view.setUint16(offset, recipientByte.length, false);
+            offset += constants_1.default['UINT16_SIZE'];
+            result.set(recipientByte, offset);
+            offset += recipientByte.length;
+        }
+        result[offset] = priority;
+        offset += constants_1.default['UINT8_SIZE'];
+        result[offset] = encryptionSchemeBytes.length;
+        offset += constants_1.default['UINT8_SIZE'];
+        result.set(encryptionSchemeBytes, offset);
+        return result;
+    }
     /**
      * Create an extended header for CBL
      */
@@ -506,9 +679,60 @@ class CBLService {
         return result;
     }
     /**
-     * Create a CBL header
+     * Parse message CBL header
+     */
+    parseMessageHeader(data, creatorForValidation) {
+        const cblData = this.parseBaseHeader(data, creatorForValidation);
+        const offsets = this.getMessageHeaderOffsets(data);
+        const decoder = new TextDecoder('utf-8');
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const messageType = decoder.decode(data.subarray(offsets.messageTypeOffset, offsets.messageTypeOffset + offsets.messageTypeLength));
+        const senderId = decoder.decode(data.subarray(offsets.senderIdOffset, offsets.senderIdOffset + offsets.senderIdLength));
+        const recipients = [];
+        let recipientOffset = offsets.recipientsOffset;
+        for (let i = 0; i < offsets.recipientCount; i++) {
+            const recipientLength = view.getUint16(recipientOffset, false);
+            recipientOffset += constants_1.default['UINT16_SIZE'];
+            recipients.push(decoder.decode(data.subarray(recipientOffset, recipientOffset + recipientLength)));
+            recipientOffset += recipientLength;
+        }
+        const priority = data[offsets.priorityOffset];
+        const encryptionScheme = decoder.decode(data.subarray(offsets.encryptionSchemeOffset, offsets.encryptionSchemeOffset + offsets.encryptionSchemeLength));
+        return {
+            ...cblData,
+            isMessage: true,
+            messageType,
+            senderId,
+            recipients,
+            priority,
+            encryptionScheme,
+        };
+    }
+    /**
+     * Create a CBL header.
+     *
+     * @param creator - The member creating the CBL
+     * @param dateCreated - The creation date
+     * @param cblAddressCount - Number of addresses in the CBL
+     * @param fileDataLength - Length of the original file data
+     * @param addressList - The list of block addresses
+     * @param blockSize - The block size
+     * @param encryptionType - The encryption type
+     * @param extendedCBL - Optional extended CBL data (fileName, mimeType)
+     * @param tupleSize - The tuple size (defaults to TUPLE.SIZE)
+     * @returns Object containing headerData and signature
+     * @throws {EnhancedValidationError} If block size or encryption type is invalid
+     * @throws {CblError} If CBL-specific validation fails
+     *
+     * @see Requirements 5.1, 5.2, 5.3, 12.1, 12.2, 12.7
      */
     makeCblHeader(creator, dateCreated, cblAddressCount, fileDataLength, addressList, blockSize, encryptionType, extendedCBL, tupleSize = constants_1.TUPLE.SIZE) {
+        // Validate inputs using Validator
+        validator_1.Validator.validateRequired(creator, 'creator', 'makeCblHeader');
+        validator_1.Validator.validateRequired(dateCreated, 'dateCreated', 'makeCblHeader');
+        validator_1.Validator.validateRequired(addressList, 'addressList', 'makeCblHeader');
+        validator_1.Validator.validateBlockSize(blockSize, 'makeCblHeader');
+        validator_1.Validator.validateEncryptionType(encryptionType, 'makeCblHeader');
         if (fileDataLength > constants_1.CBL.MAX_INPUT_FILE_SIZE) {
             throw new cblError_1.CblError(cblErrorType_1.CblErrorType.FileSizeTooLarge);
         }
@@ -544,20 +768,11 @@ class CBLService {
         buffers.dataChecksum.set(dataChecksum);
         // Use the provider to convert creator ID to bytes
         const creatorIdBytes = this.enhancedProvider.toBytes(creator.id);
-        // Use the actual provider's ID length
-        const expectedLength = this.creatorLength;
-        const creatorId = new Uint8Array(expectedLength);
-        if (creatorIdBytes.length === expectedLength) {
-            creatorId.set(creatorIdBytes);
-        }
-        else if (creatorIdBytes.length < expectedLength) {
-            // Right-align shorter IDs (pad with zeros on the left)
-            creatorId.set(creatorIdBytes, expectedLength - creatorIdBytes.length);
-        }
-        else {
-            // Truncate longer IDs from the right
-            creatorId.set(creatorIdBytes.subarray(0, expectedLength));
+        // Validate that the provider returns the expected length
+        if (creatorIdBytes.length !== this.creatorLength) {
+            throw new cblError_1.CblError(cblErrorType_1.CblErrorType.InvalidStructure, `Creator ID provider returned ${creatorIdBytes.length} bytes, expected ${this.creatorLength}`);
         }
+        const creatorId = creatorIdBytes;
         // Create base header
         const baseHeaderSize = creatorId.length +
             buffers.dateCreated.length +
@@ -601,24 +816,22 @@ class CBLService {
         signOffset += buffers.blockSize.length;
         toSign.set(addressList, signOffset);
         const checksum = this.checksumService.calculateChecksum(toSign);
-        let signatureBytes = creator instanceof ecies_lib_1.Member && creator.privateKey
-            ? new Uint8Array(this.eciesService.signMessage(creator.privateKey.value, checksum))
-            : new Uint8Array(constants_1.ECIES.SIGNATURE_LENGTH);
+        const signatureBytes = (creator instanceof ecies_lib_1.Member && creator.privateKey
+            ? new Uint8Array(this.eciesService.signMessage(creator.privateKey.value, checksum.toUint8Array()))
+            : new Uint8Array(constants_1.ECIES.SIGNATURE_LENGTH));
+        // Validate signature length
         if (signatureBytes.length !== constants_1.ECIES.SIGNATURE_LENGTH) {
-            const padded = new Uint8Array(constants_1.ECIES.SIGNATURE_LENGTH);
-            padded.set(signatureBytes, constants_1.ECIES.SIGNATURE_LENGTH - signatureBytes.length);
-            signatureBytes = padded;
+            throw new cblError_1.CblError(cblErrorType_1.CblErrorType.InvalidSignature, `Signature length mismatch: got ${signatureBytes.length}, expected ${constants_1.ECIES.SIGNATURE_LENGTH}`);
         }
-        const finalSignature = signatureBytes;
         // Construct final header
-        const headerData = new Uint8Array(baseHeader.length + extendedHeaderData.length + finalSignature.length);
+        const headerData = new Uint8Array(baseHeader.length + extendedHeaderData.length + signatureBytes.length);
         let headerOffset = 0;
         headerData.set(baseHeader, headerOffset);
         headerOffset += baseHeader.length;
         headerData.set(extendedHeaderData, headerOffset);
         headerOffset += extendedHeaderData.length;
-        headerData.set(finalSignature, headerOffset);
-        return { headerData, signature: finalSignature };
+        headerData.set(signatureBytes, headerOffset);
+        return { headerData, signature: signatureBytes };
     }
     /**
      * Parse the header of a constituent block list block
@@ -750,6 +963,11 @@ CBLService.IsExtendedHeaderSize = constants_1.default['UINT8_SIZE'];
  * Length of the creator signature field in the header
  */
 CBLService.CreatorSignatureSize = constants_1.ECIES.SIGNATURE_LENGTH;
+/**
+ * Length of the creator ID field (GUID size) - static default for backward compatibility
+ * @deprecated Use instance method creatorLength instead for dynamic provider support
+ */
+CBLService.CreatorIdLength = constants_1.default['ENCRYPTION'].RECIPIENT_ID_SIZE;
 /**
  * Length of the file name length field in the header
  */