@brightchain/brightchain-lib 0.1.0

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

@@ -0,0 +1,16 @@
+export declare enum ValidationErrorType {
+    FileNameRequired = "FileNameRequired",
+    FileNameEmpty = "FileNameEmpty",
+    FileNameWhitespace = "FileNameWhitespace",
+    FileNameTooLong = "FileNameTooLong",
+    FileNameInvalidChar = "FileNameInvalidChar",
+    FileNameControlChars = "FileNameControlChars",
+    FileNamePathTraversal = "FileNamePathTraversal",
+    MimeTypeRequired = "MimeTypeRequired",
+    MimeTypeEmpty = "MimeTypeEmpty",
+    MimeTypeWhitespace = "MimeTypeWhitespace",
+    MimeTypeLowercase = "MimeTypeLowercase",
+    MimeTypeTooLong = "MimeTypeTooLong",
+    MimeTypeInvalidFormat = "MimeTypeInvalidFormat"
+}
+//# sourceMappingURL=validationErrorType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validationErrorType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/validationErrorType.ts"],"names":[],"mappings":"AAAA,oBAAY,mBAAmB;IAC7B,gBAAgB,qBAAqB;IACrC,aAAa,kBAAkB;IAC/B,kBAAkB,uBAAuB;IACzC,eAAe,oBAAoB;IACnC,mBAAmB,wBAAwB;IAC3C,oBAAoB,yBAAyB;IAC7C,qBAAqB,0BAA0B;IAC/C,gBAAgB,qBAAqB;IACrC,aAAa,kBAAkB;IAC/B,kBAAkB,uBAAuB;IACzC,iBAAiB,sBAAsB;IACvC,eAAe,oBAAoB;IACnC,qBAAqB,0BAA0B;CAChD"}

package/src/lib/enumerations/validationErrorType.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationErrorType = void 0;
+var ValidationErrorType;
+(function (ValidationErrorType) {
+    ValidationErrorType["FileNameRequired"] = "FileNameRequired";
+    ValidationErrorType["FileNameEmpty"] = "FileNameEmpty";
+    ValidationErrorType["FileNameWhitespace"] = "FileNameWhitespace";
+    ValidationErrorType["FileNameTooLong"] = "FileNameTooLong";
+    ValidationErrorType["FileNameInvalidChar"] = "FileNameInvalidChar";
+    ValidationErrorType["FileNameControlChars"] = "FileNameControlChars";
+    ValidationErrorType["FileNamePathTraversal"] = "FileNamePathTraversal";
+    ValidationErrorType["MimeTypeRequired"] = "MimeTypeRequired";
+    ValidationErrorType["MimeTypeEmpty"] = "MimeTypeEmpty";
+    ValidationErrorType["MimeTypeWhitespace"] = "MimeTypeWhitespace";
+    ValidationErrorType["MimeTypeLowercase"] = "MimeTypeLowercase";
+    ValidationErrorType["MimeTypeTooLong"] = "MimeTypeTooLong";
+    ValidationErrorType["MimeTypeInvalidFormat"] = "MimeTypeInvalidFormat";
+})(ValidationErrorType || (exports.ValidationErrorType = ValidationErrorType = {}));
+//# sourceMappingURL=validationErrorType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validationErrorType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/validationErrorType.ts"],"names":[],"mappings":";;;AAAA,IAAY,mBAcX;AAdD,WAAY,mBAAmB;IAC7B,4DAAqC,CAAA;IACrC,sDAA+B,CAAA;IAC/B,gEAAyC,CAAA;IACzC,0DAAmC,CAAA;IACnC,kEAA2C,CAAA;IAC3C,oEAA6C,CAAA;IAC7C,sEAA+C,CAAA;IAC/C,4DAAqC,CAAA;IACrC,sDAA+B,CAAA;IAC/B,gEAAyC,CAAA;IACzC,8DAAuC,CAAA;IACvC,0DAAmC,CAAA;IACnC,sEAA+C,CAAA;AACjD,CAAC,EAdW,mBAAmB,mCAAnB,mBAAmB,QAc9B"}

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

@@ -0,0 +1,17 @@
+import { StringNames } from './stringNames';
+export declare enum VotingDerivationErrorType {
+    FailedToGeneratePrime = "FailedToGeneratePrime",
+    IdenticalPrimes = "IdenticalPrimes",
+    KeyPairTooSmall = "KeyPairTooSmall",
+    KeyPairValidationFailed = "KeyPairValidationFailed",
+    ModularInverseDoesNotExist = "ModularInverseDoesNotExist",
+    PrivateKeyMustBeBuffer = "PrivateKeyMustBeBuffer",
+    PublicKeyMustBeBuffer = "PublicKeyMustBeBuffer",
+    InvalidPublicKeyFormat = "InvalidPublicKeyFormat",
+    InvalidEcdhKeyPair = "InvalidEcdhKeyPair",
+    FailedToDeriveVotingKeys = "FailedToDeriveVotingKeys"
+}
+export declare const VotingDerivationErrorTypes: {
+    [key in VotingDerivationErrorType]: StringNames;
+};
+//# sourceMappingURL=votingDerivationErrorType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"votingDerivationErrorType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/votingDerivationErrorType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,oBAAY,yBAAyB;IACnC,qBAAqB,0BAA0B;IAC/C,eAAe,oBAAoB;IACnC,eAAe,oBAAoB;IACnC,uBAAuB,4BAA4B;IACnD,0BAA0B,+BAA+B;IACzD,sBAAsB,2BAA2B;IACjD,qBAAqB,0BAA0B;IAC/C,sBAAsB,2BAA2B;IACjD,kBAAkB,uBAAuB;IACzC,wBAAwB,6BAA6B;CACtD;AAED,eAAO,MAAM,0BAA0B,EAAE;KACtC,GAAG,IAAI,yBAAyB,GAAG,WAAW;CAsBhD,CAAC"}

package/src/lib/enumerations/votingDerivationErrorType.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VotingDerivationErrorTypes = exports.VotingDerivationErrorType = void 0;
+const stringNames_1 = require("./stringNames");
+var VotingDerivationErrorType;
+(function (VotingDerivationErrorType) {
+    VotingDerivationErrorType["FailedToGeneratePrime"] = "FailedToGeneratePrime";
+    VotingDerivationErrorType["IdenticalPrimes"] = "IdenticalPrimes";
+    VotingDerivationErrorType["KeyPairTooSmall"] = "KeyPairTooSmall";
+    VotingDerivationErrorType["KeyPairValidationFailed"] = "KeyPairValidationFailed";
+    VotingDerivationErrorType["ModularInverseDoesNotExist"] = "ModularInverseDoesNotExist";
+    VotingDerivationErrorType["PrivateKeyMustBeBuffer"] = "PrivateKeyMustBeBuffer";
+    VotingDerivationErrorType["PublicKeyMustBeBuffer"] = "PublicKeyMustBeBuffer";
+    VotingDerivationErrorType["InvalidPublicKeyFormat"] = "InvalidPublicKeyFormat";
+    VotingDerivationErrorType["InvalidEcdhKeyPair"] = "InvalidEcdhKeyPair";
+    VotingDerivationErrorType["FailedToDeriveVotingKeys"] = "FailedToDeriveVotingKeys";
+})(VotingDerivationErrorType || (exports.VotingDerivationErrorType = VotingDerivationErrorType = {}));
+exports.VotingDerivationErrorTypes = {
+    [VotingDerivationErrorType.FailedToGeneratePrime]: stringNames_1.StringNames.Error_VotingDerivationErrorFailedToGeneratePrime,
+    [VotingDerivationErrorType.IdenticalPrimes]: stringNames_1.StringNames.Error_VotingDerivationErrorIdenticalPrimes,
+    [VotingDerivationErrorType.KeyPairTooSmall]: stringNames_1.StringNames.Error_VotingDerivationErrorKeyPairTooSmallTemplate,
+    [VotingDerivationErrorType.KeyPairValidationFailed]: stringNames_1.StringNames.Error_VotingDerivationErrorKeyPairValidationFailed,
+    [VotingDerivationErrorType.ModularInverseDoesNotExist]: stringNames_1.StringNames.Error_VotingDerivationErrorModularInverseDoesNotExist,
+    [VotingDerivationErrorType.PrivateKeyMustBeBuffer]: stringNames_1.StringNames.Error_VotingDerivationErrorPrivateKeyMustBeBuffer,
+    [VotingDerivationErrorType.PublicKeyMustBeBuffer]: stringNames_1.StringNames.Error_VotingDerivationErrorPublicKeyMustBeBuffer,
+    [VotingDerivationErrorType.InvalidPublicKeyFormat]: stringNames_1.StringNames.Error_VotingDerivationErrorInvalidPublicKeyFormat,
+    [VotingDerivationErrorType.InvalidEcdhKeyPair]: stringNames_1.StringNames.Error_VotingDerivationErrorInvalidEcdhKeyPair,
+    [VotingDerivationErrorType.FailedToDeriveVotingKeys]: stringNames_1.StringNames.Error_VotingDerivationErrorFailedToDeriveVotingKeysTemplate,
+};
+//# sourceMappingURL=votingDerivationErrorType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"votingDerivationErrorType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/votingDerivationErrorType.ts"],"names":[],"mappings":";;;AAAA,+CAA4C;AAE5C,IAAY,yBAWX;AAXD,WAAY,yBAAyB;IACnC,4EAA+C,CAAA;IAC/C,gEAAmC,CAAA;IACnC,gEAAmC,CAAA;IACnC,gFAAmD,CAAA;IACnD,sFAAyD,CAAA;IACzD,8EAAiD,CAAA;IACjD,4EAA+C,CAAA;IAC/C,8EAAiD,CAAA;IACjD,sEAAyC,CAAA;IACzC,kFAAqD,CAAA;AACvD,CAAC,EAXW,yBAAyB,yCAAzB,yBAAyB,QAWpC;AAEY,QAAA,0BAA0B,GAEnC;IACF,CAAC,yBAAyB,CAAC,qBAAqB,CAAC,EAC/C,yBAAW,CAAC,gDAAgD;IAC9D,CAAC,yBAAyB,CAAC,eAAe,CAAC,EACzC,yBAAW,CAAC,0CAA0C;IACxD,CAAC,yBAAyB,CAAC,eAAe,CAAC,EACzC,yBAAW,CAAC,kDAAkD;IAChE,CAAC,yBAAyB,CAAC,uBAAuB,CAAC,EACjD,yBAAW,CAAC,kDAAkD;IAChE,CAAC,yBAAyB,CAAC,0BAA0B,CAAC,EACpD,yBAAW,CAAC,qDAAqD;IACnE,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,EAChD,yBAAW,CAAC,iDAAiD;IAC/D,CAAC,yBAAyB,CAAC,qBAAqB,CAAC,EAC/C,yBAAW,CAAC,gDAAgD;IAC9D,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,EAChD,yBAAW,CAAC,iDAAiD;IAC/D,CAAC,yBAAyB,CAAC,kBAAkB,CAAC,EAC5C,yBAAW,CAAC,6CAA6C;IAC3D,CAAC,yBAAyB,CAAC,wBAAwB,CAAC,EAClD,yBAAW,CAAC,2DAA2D;CAC1E,CAAC"}

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

@@ -0,0 +1,35 @@
+export declare enum VotingErrorType {
+    InvalidKeyPairPublicKeyNotIsolated = "InvalidKeyPairPublicKeyNotIsolated",
+    InvalidKeyPairPrivateKeyNotIsolated = "InvalidKeyPairPrivateKeyNotIsolated",
+    InvalidPublicKeyNotIsolated = "InvalidPublicKeyNotIsolated",
+    InvalidPublicKeyBufferTooShort = "InvalidPublicKeyBufferTooShort",
+    InvalidPublicKeyBufferWrongMagic = "InvalidPublicKeyBufferWrongMagic",
+    UnsupportedPublicKeyVersion = "UnsupportedPublicKeyVersion",
+    InvalidPublicKeyBufferIncompleteN = "InvalidPublicKeyBufferIncompleteN",
+    InvalidPublicKeyBufferFailedToParseN = "InvalidPublicKeyBufferFailedToParseN",
+    InvalidPublicKeyIdMismatch = "InvalidPublicKeyIdMismatch",
+    PrivateKeyMustBeBuffer = "PrivateKeyMustBeBuffer",
+    PublicKeyMustBeBuffer = "PublicKeyMustBeBuffer",
+    InvalidPublicKeyFormat = "InvalidPublicKeyFormat",
+    InvalidEcdhKeyPair = "InvalidEcdhKeyPair",
+    FailedToDeriveVotingKeys = "FailedToDeriveVotingKeys",
+    FailedToGeneratePrime = "FailedToGeneratePrime",
+    IdenticalPrimes = "IdenticalPrimes",
+    KeyPairTooSmall = "KeyPairTooSmall",
+    KeyPairValidationFailed = "KeyPairValidationFailed",
+    InvalidVotingKeys = "InvalidVotingKeys",
+    InvalidKeyPair = "InvalidKeyPair",
+    InvalidPublicKey = "InvalidPublicKey",
+    InvalidPrivateKey = "InvalidPrivateKey",
+    InvalidEncryptedKey = "InvalidEncryptedKey",
+    ModularInverseDoesNotExist = "ModularInverseDoesNotExist",
+    InvalidPrivateKeyBufferTooShort = "InvalidPrivateKeyBufferTooShort",
+    InvalidPrivateKeyBufferWrongMagic = "InvalidPrivateKeyBufferWrongMagic",
+    UnsupportedPrivateKeyVersion = "UnsupportedPrivateKeyVersion",
+    InvalidPrivateKeyBufferIncompleteLambda = "InvalidPrivateKeyBufferIncompleteLambda",
+    InvalidPrivateKeyBufferIncompleteMuLength = "InvalidPrivateKeyBufferIncompleteMuLength",
+    InvalidPrivateKeyBufferIncompleteMu = "InvalidPrivateKeyBufferIncompleteMu",
+    InvalidPrivateKeyBufferFailedToParse = "InvalidPrivateKeyBufferFailedToParse",
+    InvalidPrivateKeyBufferFailedToCreate = "InvalidPrivateKeyBufferFailedToCreate"
+}
+//# sourceMappingURL=votingErrorType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"votingErrorType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/votingErrorType.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,kCAAkC,uCAAuC;IACzE,mCAAmC,wCAAwC;IAC3E,2BAA2B,gCAAgC;IAC3D,8BAA8B,mCAAmC;IACjE,gCAAgC,qCAAqC;IACrE,2BAA2B,gCAAgC;IAC3D,iCAAiC,sCAAsC;IACvE,oCAAoC,yCAAyC;IAC7E,0BAA0B,+BAA+B;IACzD,sBAAsB,2BAA2B;IACjD,qBAAqB,0BAA0B;IAC/C,sBAAsB,2BAA2B;IACjD,kBAAkB,uBAAuB;IACzC,wBAAwB,6BAA6B;IACrD,qBAAqB,0BAA0B;IAC/C,eAAe,oBAAoB;IACnC,eAAe,oBAAoB;IACnC,uBAAuB,4BAA4B;IACnD,iBAAiB,sBAAsB;IACvC,cAAc,mBAAmB;IACjC,gBAAgB,qBAAqB;IACrC,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,0BAA0B,+BAA+B;IACzD,+BAA+B,oCAAoC;IACnE,iCAAiC,sCAAsC;IACvE,4BAA4B,iCAAiC;IAC7D,uCAAuC,4CAA4C;IACnF,yCAAyC,8CAA8C;IACvF,mCAAmC,wCAAwC;IAC3E,oCAAoC,yCAAyC;IAC7E,qCAAqC,0CAA0C;CAChF"}

package/src/lib/enumerations/votingErrorType.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VotingErrorType = void 0;
+var VotingErrorType;
+(function (VotingErrorType) {
+    VotingErrorType["InvalidKeyPairPublicKeyNotIsolated"] = "InvalidKeyPairPublicKeyNotIsolated";
+    VotingErrorType["InvalidKeyPairPrivateKeyNotIsolated"] = "InvalidKeyPairPrivateKeyNotIsolated";
+    VotingErrorType["InvalidPublicKeyNotIsolated"] = "InvalidPublicKeyNotIsolated";
+    VotingErrorType["InvalidPublicKeyBufferTooShort"] = "InvalidPublicKeyBufferTooShort";
+    VotingErrorType["InvalidPublicKeyBufferWrongMagic"] = "InvalidPublicKeyBufferWrongMagic";
+    VotingErrorType["UnsupportedPublicKeyVersion"] = "UnsupportedPublicKeyVersion";
+    VotingErrorType["InvalidPublicKeyBufferIncompleteN"] = "InvalidPublicKeyBufferIncompleteN";
+    VotingErrorType["InvalidPublicKeyBufferFailedToParseN"] = "InvalidPublicKeyBufferFailedToParseN";
+    VotingErrorType["InvalidPublicKeyIdMismatch"] = "InvalidPublicKeyIdMismatch";
+    VotingErrorType["PrivateKeyMustBeBuffer"] = "PrivateKeyMustBeBuffer";
+    VotingErrorType["PublicKeyMustBeBuffer"] = "PublicKeyMustBeBuffer";
+    VotingErrorType["InvalidPublicKeyFormat"] = "InvalidPublicKeyFormat";
+    VotingErrorType["InvalidEcdhKeyPair"] = "InvalidEcdhKeyPair";
+    VotingErrorType["FailedToDeriveVotingKeys"] = "FailedToDeriveVotingKeys";
+    VotingErrorType["FailedToGeneratePrime"] = "FailedToGeneratePrime";
+    VotingErrorType["IdenticalPrimes"] = "IdenticalPrimes";
+    VotingErrorType["KeyPairTooSmall"] = "KeyPairTooSmall";
+    VotingErrorType["KeyPairValidationFailed"] = "KeyPairValidationFailed";
+    VotingErrorType["InvalidVotingKeys"] = "InvalidVotingKeys";
+    VotingErrorType["InvalidKeyPair"] = "InvalidKeyPair";
+    VotingErrorType["InvalidPublicKey"] = "InvalidPublicKey";
+    VotingErrorType["InvalidPrivateKey"] = "InvalidPrivateKey";
+    VotingErrorType["InvalidEncryptedKey"] = "InvalidEncryptedKey";
+    VotingErrorType["ModularInverseDoesNotExist"] = "ModularInverseDoesNotExist";
+    VotingErrorType["InvalidPrivateKeyBufferTooShort"] = "InvalidPrivateKeyBufferTooShort";
+    VotingErrorType["InvalidPrivateKeyBufferWrongMagic"] = "InvalidPrivateKeyBufferWrongMagic";
+    VotingErrorType["UnsupportedPrivateKeyVersion"] = "UnsupportedPrivateKeyVersion";
+    VotingErrorType["InvalidPrivateKeyBufferIncompleteLambda"] = "InvalidPrivateKeyBufferIncompleteLambda";
+    VotingErrorType["InvalidPrivateKeyBufferIncompleteMuLength"] = "InvalidPrivateKeyBufferIncompleteMuLength";
+    VotingErrorType["InvalidPrivateKeyBufferIncompleteMu"] = "InvalidPrivateKeyBufferIncompleteMu";
+    VotingErrorType["InvalidPrivateKeyBufferFailedToParse"] = "InvalidPrivateKeyBufferFailedToParse";
+    VotingErrorType["InvalidPrivateKeyBufferFailedToCreate"] = "InvalidPrivateKeyBufferFailedToCreate";
+})(VotingErrorType || (exports.VotingErrorType = VotingErrorType = {}));
+//# sourceMappingURL=votingErrorType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"votingErrorType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/votingErrorType.ts"],"names":[],"mappings":";;;AAAA,IAAY,eAiCX;AAjCD,WAAY,eAAe;IACzB,4FAAyE,CAAA;IACzE,8FAA2E,CAAA;IAC3E,8EAA2D,CAAA;IAC3D,oFAAiE,CAAA;IACjE,wFAAqE,CAAA;IACrE,8EAA2D,CAAA;IAC3D,0FAAuE,CAAA;IACvE,gGAA6E,CAAA;IAC7E,4EAAyD,CAAA;IACzD,oEAAiD,CAAA;IACjD,kEAA+C,CAAA;IAC/C,oEAAiD,CAAA;IACjD,4DAAyC,CAAA;IACzC,wEAAqD,CAAA;IACrD,kEAA+C,CAAA;IAC/C,sDAAmC,CAAA;IACnC,sDAAmC,CAAA;IACnC,sEAAmD,CAAA;IACnD,0DAAuC,CAAA;IACvC,oDAAiC,CAAA;IACjC,wDAAqC,CAAA;IACrC,0DAAuC,CAAA;IACvC,8DAA2C,CAAA;IAC3C,4EAAyD,CAAA;IACzD,sFAAmE,CAAA;IACnE,0FAAuE,CAAA;IACvE,gFAA6D,CAAA;IAC7D,sGAAmF,CAAA;IACnF,0GAAuF,CAAA;IACvF,8FAA2E,CAAA;IAC3E,gGAA6E,CAAA;IAC7E,kGAA+E,CAAA;AACjF,CAAC,EAjCW,eAAe,+BAAf,eAAe,QAiC1B"}

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

@@ -0,0 +1,7 @@
+export declare enum WhitenedErrorType {
+    BlockNotReadable = "BlockNotReadable",
+    BlockSizeMismatch = "BlockSizeMismatch",
+    DataLengthMismatch = "DataLengthMismatch",
+    InvalidBlockSize = "InvalidBlockSize"
+}
+//# sourceMappingURL=whitenedErrorType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whitenedErrorType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/whitenedErrorType.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,gBAAgB,qBAAqB;IACrC,iBAAiB,sBAAsB;IACvC,kBAAkB,uBAAuB;IACzC,gBAAgB,qBAAqB;CACtC"}

package/src/lib/enumerations/whitenedErrorType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhitenedErrorType = void 0;
+var WhitenedErrorType;
+(function (WhitenedErrorType) {
+    WhitenedErrorType["BlockNotReadable"] = "BlockNotReadable";
+    WhitenedErrorType["BlockSizeMismatch"] = "BlockSizeMismatch";
+    WhitenedErrorType["DataLengthMismatch"] = "DataLengthMismatch";
+    WhitenedErrorType["InvalidBlockSize"] = "InvalidBlockSize";
+})(WhitenedErrorType || (exports.WhitenedErrorType = WhitenedErrorType = {}));
+//# sourceMappingURL=whitenedErrorType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whitenedErrorType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/whitenedErrorType.ts"],"names":[],"mappings":";;;AAAA,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,0DAAqC,CAAA;IACrC,4DAAuC,CAAA;IACvC,8DAAyC,CAAA;IACzC,0DAAqC,CAAA;AACvC,CAAC,EALW,iBAAiB,iCAAjB,iBAAiB,QAK5B"}

package/src/lib/ephemeralBlockMetadata.d.ts

@@ -0,0 +1,20 @@
+import { Member, type PlatformID } from '@digitaldefiance/ecies-lib';
+import { BlockMetadata } from './blockMetadata';
+import { BlockDataType } from './enumerations/blockDataType';
+import { BlockSize } from './enumerations/blockSize';
+import { BlockType } from './enumerations/blockType';
+import { IEphemeralBlockMetadata } from './interfaces/blocks/metadata/ephemeralBlockMetadata';
+export declare class EphemeralBlockMetadata<TID extends PlatformID = Uint8Array> extends BlockMetadata implements IEphemeralBlockMetadata<TID> {
+    private readonly _creator;
+    constructor(size: BlockSize, type: BlockType, dataType: BlockDataType, lengthWithoutPadding: number, creator: Member<TID>, dateCreated?: Date);
+    get creator(): Member<TID>;
+    toJson(): string;
+    static fromJsonValidator(data: any): void;
+    static fromJsonAdditionalData<T extends Record<string, any>, TID extends PlatformID = Uint8Array>(data: any): {
+        creator: Member<TID>;
+    } & T;
+    static fromJson<B extends EphemeralBlockMetadata, T extends Record<string, any> & {
+        creator?: Member<TID>;
+    }, TID extends PlatformID = Uint8Array>(json: string): EphemeralBlockMetadata & T;
+}
+//# sourceMappingURL=ephemeralBlockMetadata.d.ts.map

package/src/lib/ephemeralBlockMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeralBlockMetadata.d.ts","sourceRoot":"","sources":["../../../../brightchain-lib/src/lib/ephemeralBlockMetadata.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAGrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,qDAAqD,CAAC;AAE9F,qBAAa,sBAAsB,CAAC,GAAG,SAAS,UAAU,GAAG,UAAU,CACrE,SAAQ,aACR,YAAW,uBAAuB,CAAC,GAAG,CAAC;IAEvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;gBAErC,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,aAAa,EACvB,oBAAoB,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,EACpB,WAAW,CAAC,EAAE,IAAI;IAKpB,IAAW,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,CAEhC;IAEe,MAAM,IAAI,MAAM;WAWT,iBAAiB,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI;WAOlC,sBAAsB,CAC3C,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,GAAG,SAAS,UAAU,GAAG,UAAU,EACnC,IAAI,EAAE,GAAG,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;KAAE,GAAG,CAAC;WASnB,QAAQ,CAC7B,CAAC,SAAS,sBAAsB,EAChC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;KAAE,EACzD,GAAG,SAAS,UAAU,GAAG,UAAU,EACnC,IAAI,EAAE,MAAM,GAAG,sBAAsB,GAAG,CAAC;CAG5C"}

package/src/lib/ephemeralBlockMetadata.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EphemeralBlockMetadata = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
+const blockMetadata_1 = require("./blockMetadata");
+const blockValidationErrorType_1 = require("./enumerations/blockValidationErrorType");
+const block_1 = require("./errors/block");
+class EphemeralBlockMetadata extends blockMetadata_1.BlockMetadata {
+    constructor(size, type, dataType, lengthWithoutPadding, creator, dateCreated) {
+        super(size, type, dataType, lengthWithoutPadding, dateCreated);
+        this._creator = creator;
+    }
+    get creator() {
+        return this._creator;
+    }
+    toJson() {
+        return JSON.stringify({
+            size: this.size,
+            type: this.type,
+            dataType: this.dataType,
+            lengthWithoutPadding: this.lengthWithoutPadding,
+            dateCreated: this.dateCreated,
+            creator: ecies_lib_1.Constants.idProvider.serialize(this.creator.idBytes),
+        });
+    }
+    static fromJsonValidator(data) {
+        super.fromJsonValidator(data);
+        if (!data.creator) {
+            throw new block_1.BlockValidationError(blockValidationErrorType_1.BlockValidationErrorType.InvalidCreator);
+        }
+    }
+    static fromJsonAdditionalData(data) {
+        return {
+            ...super.fromJsonAdditionalData(data),
+            creator: ecies_lib_1.Constants.idProvider.fromBytes(ecies_lib_1.Constants.idProvider.deserialize(data.creator)),
+        };
+    }
+    static fromJson(json) {
+        return super.fromJson(json);
+    }
+}
+exports.EphemeralBlockMetadata = EphemeralBlockMetadata;
+//# sourceMappingURL=ephemeralBlockMetadata.js.map

package/src/lib/ephemeralBlockMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeralBlockMetadata.js","sourceRoot":"","sources":["../../../../brightchain-lib/src/lib/ephemeralBlockMetadata.ts"],"names":[],"mappings":";;;AAAA,uDAAuD;AACvD,0DAAgF;AAChF,mDAAgD;AAIhD,sFAAmF;AACnF,0CAAsD;AAGtD,MAAa,sBACX,SAAQ,6BAAa;IAIrB,YACE,IAAe,EACf,IAAe,EACf,QAAuB,EACvB,oBAA4B,EAC5B,OAAoB,EACpB,WAAkB;QAElB,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,WAAW,CAAC,CAAC;QAC/D,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAEe,MAAM;QACpB,OAAO,IAAI,CAAC,SAAS,CAAC;YACpB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,qBAAS,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;SAC9D,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAU,iBAAiB,CAAC,IAAS;QAChD,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,4BAAoB,CAAC,mDAAwB,CAAC,cAAc,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAEM,MAAM,CAAU,sBAAsB,CAG3C,IAAS;QACT,OAAO;YACL,GAAG,KAAK,CAAC,sBAAsB,CAAI,IAAI,CAAC;YACxC,OAAO,EAAE,qBAAS,CAAC,UAAU,CAAC,SAAS,CACrC,qBAAS,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAChC;SACe,CAAC;IACpC,CAAC;IAEM,MAAM,CAAU,QAAQ,CAI7B,IAAY;QACZ,OAAO,KAAK,CAAC,QAAQ,CAA8B,IAAI,CAAU,CAAC;IACpE,CAAC;CACF;AAzDD,wDAyDC"}

package/src/lib/errors/block/blockAccess.d.ts

@@ -0,0 +1,10 @@
+import { BlockAccessErrorType } from '../../enumerations/blockAccessErrorType';
+import { StringLanguages } from '../../enumerations/stringLanguages';
+import { StringNames } from '../../enumerations/stringNames';
+import { TypedWithReasonError } from '../typedWithReasonError';
+export declare class BlockAccessError extends TypedWithReasonError<BlockAccessErrorType> {
+    readonly file?: string;
+    get reasonMap(): Record<BlockAccessErrorType, StringNames>;
+    constructor(type: BlockAccessErrorType, file?: string, _language?: StringLanguages);
+}
+//# sourceMappingURL=blockAccess.d.ts.map

package/src/lib/errors/block/blockAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockAccess.d.ts","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockAccess.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/D,qBAAa,gBAAiB,SAAQ,oBAAoB,CAAC,oBAAoB,CAAC;IAC9E,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;IAC9B,IAAW,SAAS,IAAI,MAAM,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAehE;gBAEC,IAAI,EAAE,oBAAoB,EAC1B,IAAI,CAAC,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,eAAe;CAU9B"}

package/src/lib/errors/block/blockAccess.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAccessError = void 0;
+const blockAccessErrorType_1 = require("../../enumerations/blockAccessErrorType");
+const stringNames_1 = require("../../enumerations/stringNames");
+const typedWithReasonError_1 = require("../typedWithReasonError");
+class BlockAccessError extends typedWithReasonError_1.TypedWithReasonError {
+    get reasonMap() {
+        return {
+            [blockAccessErrorType_1.BlockAccessErrorType.BlockAlreadyExists]: stringNames_1.StringNames.Error_BlockAccessErrorBlockAlreadyExists,
+            [blockAccessErrorType_1.BlockAccessErrorType.BlockFileNotFound]: stringNames_1.StringNames.Error_BlockAccessErrorBlockFileNotFoundTemplate,
+            [blockAccessErrorType_1.BlockAccessErrorType.BlockIsNotPersistable]: stringNames_1.StringNames.Error_BlockAccessErrorBlockIsNotPersistable,
+            [blockAccessErrorType_1.BlockAccessErrorType.BlockIsNotReadable]: stringNames_1.StringNames.Error_BlockAccessErrorBlockIsNotReadable,
+            [blockAccessErrorType_1.BlockAccessErrorType.CBLCannotBeEncrypted]: stringNames_1.StringNames.Error_BlockAccessCBLCannotBeEncrypted,
+            [blockAccessErrorType_1.BlockAccessErrorType.CreatorMustBeProvided]: stringNames_1.StringNames.Error_BlockAccessErrorCreatorMustBeProvided,
+        };
+    }
+    constructor(type, file, _language) {
+        super(stringNames_1.StringNames.Error_BlockAccessTemplate, type, file ? { FILE: file } : {});
+        this.name = 'BlockAccessError';
+        this.file = file;
+    }
+}
+exports.BlockAccessError = BlockAccessError;
+//# sourceMappingURL=blockAccess.js.map

package/src/lib/errors/block/blockAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockAccess.js","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockAccess.ts"],"names":[],"mappings":";;;AAAA,kFAA+E;AAE/E,gEAA6D;AAC7D,kEAA+D;AAE/D,MAAa,gBAAiB,SAAQ,2CAA0C;IAE9E,IAAW,SAAS;QAClB,OAAO;YACL,CAAC,2CAAoB,CAAC,kBAAkB,CAAC,EACvC,yBAAW,CAAC,wCAAwC;YACtD,CAAC,2CAAoB,CAAC,iBAAiB,CAAC,EACtC,yBAAW,CAAC,+CAA+C;YAC7D,CAAC,2CAAoB,CAAC,qBAAqB,CAAC,EAC1C,yBAAW,CAAC,2CAA2C;YACzD,CAAC,2CAAoB,CAAC,kBAAkB,CAAC,EACvC,yBAAW,CAAC,wCAAwC;YACtD,CAAC,2CAAoB,CAAC,oBAAoB,CAAC,EACzC,yBAAW,CAAC,qCAAqC;YACnD,CAAC,2CAAoB,CAAC,qBAAqB,CAAC,EAC1C,yBAAW,CAAC,2CAA2C;SAC1D,CAAC;IACJ,CAAC;IACD,YACE,IAA0B,EAC1B,IAAa,EACb,SAA2B;QAE3B,KAAK,CACH,yBAAW,CAAC,yBAAyB,EACrC,IAAI,EACJ,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAC3B,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AA/BD,4CA+BC"}

package/src/lib/errors/block/blockCapacity.d.ts

@@ -0,0 +1,9 @@
+import { BlockCapacityErrorType } from '../../enumerations/blockCapacityErrorType';
+import { StringLanguages } from '../../enumerations/stringLanguages';
+import StringNames from '../../enumerations/stringNames';
+import { TypedError } from '../typedError';
+export declare class BlockCapacityError extends TypedError<BlockCapacityErrorType> {
+    protected get reasonMap(): Record<BlockCapacityErrorType, StringNames>;
+    constructor(type: BlockCapacityErrorType, language?: StringLanguages, otherVars?: Record<string, string | number>);
+}
+//# sourceMappingURL=blockCapacity.d.ts.map

package/src/lib/errors/block/blockCapacity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockCapacity.d.ts","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockCapacity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,WAAW,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,qBAAa,kBAAmB,SAAQ,UAAU,CAAC,sBAAsB,CAAC;IACxE,SAAS,KAAK,SAAS,IAAI,MAAM,CAAC,sBAAsB,EAAE,WAAW,CAAC,CAiBrE;gBAGC,IAAI,EAAE,sBAAsB,EAC5B,QAAQ,CAAC,EAAE,eAAe,EAC1B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAQ9C"}

package/src/lib/errors/block/blockCapacity.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockCapacityError = void 0;
+const blockCapacityErrorType_1 = require("../../enumerations/blockCapacityErrorType");
+const stringNames_1 = require("../../enumerations/stringNames");
+const typedError_1 = require("../typedError");
+class BlockCapacityError extends typedError_1.TypedError {
+    get reasonMap() {
+        return {
+            [blockCapacityErrorType_1.BlockCapacityErrorType.InvalidBlockSize]: stringNames_1.default.Error_BlockCapacityInvalidBlockSize,
+            [blockCapacityErrorType_1.BlockCapacityErrorType.InvalidBlockType]: stringNames_1.default.Error_BlockCapacityInvalidBlockType,
+            [blockCapacityErrorType_1.BlockCapacityErrorType.CapacityExceeded]: stringNames_1.default.Error_BlockCapacityCapacityExceeded,
+            [blockCapacityErrorType_1.BlockCapacityErrorType.InvalidFileName]: stringNames_1.default.Error_BlockCapacityInvalidFileName,
+            [blockCapacityErrorType_1.BlockCapacityErrorType.InvalidMimeType]: stringNames_1.default.Error_BlockCapacityInvalidMimetype,
+            [blockCapacityErrorType_1.BlockCapacityErrorType.InvalidRecipientCount]: stringNames_1.default.Error_BlockCapacityInvalidRecipientCount,
+            [blockCapacityErrorType_1.BlockCapacityErrorType.InvalidExtendedCblData]: stringNames_1.default.Error_BlockCapacityInvalidExtendedCblData,
+        };
+    }
+    constructor(type, language, otherVars) {
+        super(type, undefined, otherVars);
+        this.name = 'BlockCapacityError';
+        // Ensure proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, BlockCapacityError.prototype);
+    }
+}
+exports.BlockCapacityError = BlockCapacityError;
+//# sourceMappingURL=blockCapacity.js.map

package/src/lib/errors/block/blockCapacity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockCapacity.js","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockCapacity.ts"],"names":[],"mappings":";;;AAAA,sFAAmF;AAEnF,gEAAyD;AACzD,8CAA2C;AAE3C,MAAa,kBAAmB,SAAQ,uBAAkC;IACxE,IAAc,SAAS;QACrB,OAAO;YACL,CAAC,+CAAsB,CAAC,gBAAgB,CAAC,EACvC,qBAAW,CAAC,mCAAmC;YACjD,CAAC,+CAAsB,CAAC,gBAAgB,CAAC,EACvC,qBAAW,CAAC,mCAAmC;YACjD,CAAC,+CAAsB,CAAC,gBAAgB,CAAC,EACvC,qBAAW,CAAC,mCAAmC;YACjD,CAAC,+CAAsB,CAAC,eAAe,CAAC,EACtC,qBAAW,CAAC,kCAAkC;YAChD,CAAC,+CAAsB,CAAC,eAAe,CAAC,EACtC,qBAAW,CAAC,kCAAkC;YAChD,CAAC,+CAAsB,CAAC,qBAAqB,CAAC,EAC5C,qBAAW,CAAC,wCAAwC;YACtD,CAAC,+CAAsB,CAAC,sBAAsB,CAAC,EAC7C,qBAAW,CAAC,yCAAyC;SACxD,CAAC;IACJ,CAAC;IAED,YACE,IAA4B,EAC5B,QAA0B,EAC1B,SAA2C;QAE3C,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QAEjC,sDAAsD;QACtD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5D,CAAC;CACF;AA/BD,gDA+BC"}

package/src/lib/errors/block/blockError.d.ts

@@ -0,0 +1,9 @@
+import { BlockErrorType } from '../../enumerations/blockErrorType';
+import { StringLanguages } from '../../enumerations/stringLanguages';
+import StringNames from '../../enumerations/stringNames';
+import { TypedError } from '../typedError';
+export declare class BlockError extends TypedError<BlockErrorType> {
+    get reasonMap(): Record<BlockErrorType, StringNames>;
+    constructor(type: BlockErrorType, language?: StringLanguages, otherVars?: Record<string, string | number>);
+}
+//# sourceMappingURL=blockError.d.ts.map

package/src/lib/errors/block/blockError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockError.d.ts","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,WAAW,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,qBAAa,UAAW,SAAQ,UAAU,CAAC,cAAc,CAAC;IACxD,IAAW,SAAS,IAAI,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,CA8B1D;gBAGC,IAAI,EAAE,cAAc,EACpB,QAAQ,CAAC,EAAE,eAAe,EAC1B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAK9C"}

package/src/lib/errors/block/blockError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockError = void 0;
+const blockErrorType_1 = require("../../enumerations/blockErrorType");
+const stringNames_1 = require("../../enumerations/stringNames");
+const typedError_1 = require("../typedError");
+class BlockError extends typedError_1.TypedError {
+    get reasonMap() {
+        return {
+            [blockErrorType_1.BlockErrorType.CreatorRequiredForEncryption]: stringNames_1.default.Error_BlockErrorCreatorRequiredForEncryption,
+            [blockErrorType_1.BlockErrorType.CannotEncrypt]: stringNames_1.default.Error_BlockErrorCannotEncrypt,
+            [blockErrorType_1.BlockErrorType.CannotDecrypt]: stringNames_1.default.Error_BlockErrorCannotEncrypt,
+            [blockErrorType_1.BlockErrorType.ActualDataLengthExceedsDataLength]: stringNames_1.default.Error_BlockErrorActualDataLengthExceedsDataLength,
+            [blockErrorType_1.BlockErrorType.ActualDataLengthNegative]: stringNames_1.default.Error_BlockErrorActualDataLengthNegative,
+            [blockErrorType_1.BlockErrorType.CreatorRequired]: stringNames_1.default.Error_BlockErrorCreatorRequired,
+            [blockErrorType_1.BlockErrorType.DataRequired]: stringNames_1.default.Error_BlockErrorDataRequired,
+            [blockErrorType_1.BlockErrorType.DataLengthExceedsCapacity]: stringNames_1.default.Error_BlockErrorDataLengthExceedsCapacity,
+            [blockErrorType_1.BlockErrorType.UnexpectedEncryptedBlockType]: stringNames_1.default.Error_BlockErrorUnexpectedEncryptedBlockType,
+            [blockErrorType_1.BlockErrorType.CreatorPrivateKeyRequired]: stringNames_1.default.Error_BlockErrorCreatorPrivateKeyRequired,
+            [blockErrorType_1.BlockErrorType.InvalidMultiEncryptionRecipientCount]: stringNames_1.default.Error_BlockErrorInvalidMultiEncryptionRecipientCount,
+            [blockErrorType_1.BlockErrorType.InvalidNewBlockType]: stringNames_1.default.Error_BlockErrorInvalidNewBlockType,
+            [blockErrorType_1.BlockErrorType.UnexpectedEphemeralBlockType]: stringNames_1.default.Error_BlockErrorUnexpectedEphemeralBlockType,
+            [blockErrorType_1.BlockErrorType.RecipientRequired]: stringNames_1.default.Error_BlockErrorRecipientRequired,
+            [blockErrorType_1.BlockErrorType.RecipientKeyRequired]: stringNames_1.default.Error_BlockErrorRecipientKeyRequired,
+        };
+    }
+    constructor(type, language, otherVars) {
+        super(type, undefined, otherVars);
+        this.name = 'BlockError';
+    }
+}
+exports.BlockError = BlockError;
+//# sourceMappingURL=blockError.js.map

package/src/lib/errors/block/blockError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockError.js","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockError.ts"],"names":[],"mappings":";;;AAAA,sEAAmE;AAEnE,gEAAyD;AACzD,8CAA2C;AAE3C,MAAa,UAAW,SAAQ,uBAA0B;IACxD,IAAW,SAAS;QAClB,OAAO;YACL,CAAC,+BAAc,CAAC,4BAA4B,CAAC,EAC3C,qBAAW,CAAC,4CAA4C;YAC1D,CAAC,+BAAc,CAAC,aAAa,CAAC,EAAE,qBAAW,CAAC,6BAA6B;YACzE,CAAC,+BAAc,CAAC,aAAa,CAAC,EAAE,qBAAW,CAAC,6BAA6B;YACzE,CAAC,+BAAc,CAAC,iCAAiC,CAAC,EAChD,qBAAW,CAAC,iDAAiD;YAC/D,CAAC,+BAAc,CAAC,wBAAwB,CAAC,EACvC,qBAAW,CAAC,wCAAwC;YACtD,CAAC,+BAAc,CAAC,eAAe,CAAC,EAC9B,qBAAW,CAAC,+BAA+B;YAC7C,CAAC,+BAAc,CAAC,YAAY,CAAC,EAAE,qBAAW,CAAC,4BAA4B;YACvE,CAAC,+BAAc,CAAC,yBAAyB,CAAC,EACxC,qBAAW,CAAC,yCAAyC;YACvD,CAAC,+BAAc,CAAC,4BAA4B,CAAC,EAC3C,qBAAW,CAAC,4CAA4C;YAC1D,CAAC,+BAAc,CAAC,yBAAyB,CAAC,EACxC,qBAAW,CAAC,yCAAyC;YACvD,CAAC,+BAAc,CAAC,oCAAoC,CAAC,EACnD,qBAAW,CAAC,oDAAoD;YAClE,CAAC,+BAAc,CAAC,mBAAmB,CAAC,EAClC,qBAAW,CAAC,mCAAmC;YACjD,CAAC,+BAAc,CAAC,4BAA4B,CAAC,EAC3C,qBAAW,CAAC,4CAA4C;YAC1D,CAAC,+BAAc,CAAC,iBAAiB,CAAC,EAChC,qBAAW,CAAC,iCAAiC;YAC/C,CAAC,+BAAc,CAAC,oBAAoB,CAAC,EACnC,qBAAW,CAAC,oCAAoC;SACnD,CAAC;IACJ,CAAC;IAED,YACE,IAAoB,EACpB,QAA0B,EAC1B,SAA2C;QAE3C,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAzCD,gCAyCC"}

package/src/lib/errors/block/blockMetadata.d.ts

@@ -0,0 +1,9 @@
+import { BlockMetadataErrorType } from '../../enumerations/blockMetadataErrorType';
+import { StringLanguages } from '../../enumerations/stringLanguages';
+import { StringNames } from '../../enumerations/stringNames';
+import { TypedWithReasonError } from '../typedWithReasonError';
+export declare class BlockMetadataError extends TypedWithReasonError<BlockMetadataErrorType> {
+    get reasonMap(): Record<BlockMetadataErrorType, StringNames>;
+    constructor(type: BlockMetadataErrorType, _language?: StringLanguages);
+}
+//# sourceMappingURL=blockMetadata.d.ts.map

package/src/lib/errors/block/blockMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockMetadata.d.ts","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/D,qBAAa,kBAAmB,SAAQ,oBAAoB,CAAC,sBAAsB,CAAC;IAClF,IAAW,SAAS,IAAI,MAAM,CAAC,sBAAsB,EAAE,WAAW,CAAC,CAelE;gBACW,IAAI,EAAE,sBAAsB,EAAE,SAAS,CAAC,EAAE,eAAe;CAItE"}

package/src/lib/errors/block/blockMetadata.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockMetadataError = void 0;
+const blockMetadataErrorType_1 = require("../../enumerations/blockMetadataErrorType");
+const stringNames_1 = require("../../enumerations/stringNames");
+const typedWithReasonError_1 = require("../typedWithReasonError");
+class BlockMetadataError extends typedWithReasonError_1.TypedWithReasonError {
+    get reasonMap() {
+        return {
+            [blockMetadataErrorType_1.BlockMetadataErrorType.CreatorRequired]: stringNames_1.StringNames.Error_BlockMetadataErrorCreatorRequired,
+            [blockMetadataErrorType_1.BlockMetadataErrorType.EncryptorRequired]: stringNames_1.StringNames.Error_BlockMetadataErrorEncryptorRequired,
+            [blockMetadataErrorType_1.BlockMetadataErrorType.InvalidBlockMetadata]: stringNames_1.StringNames.Error_BlockMetadataErrorInvalidBlockMetadata,
+            [blockMetadataErrorType_1.BlockMetadataErrorType.MetadataRequired]: stringNames_1.StringNames.Error_BlockMetadataErrorMetadataRequired,
+            [blockMetadataErrorType_1.BlockMetadataErrorType.MissingRequiredMetadata]: stringNames_1.StringNames.Error_BlockMetadataErrorMissingRequiredMetadata,
+            [blockMetadataErrorType_1.BlockMetadataErrorType.CreatorIdMismatch]: stringNames_1.StringNames.Error_BlockMetadataErrorCreatorIdMismatch,
+        };
+    }
+    constructor(type, _language) {
+        super(stringNames_1.StringNames.Error_BlockMetadataTemplate, type, undefined);
+        this.name = 'BlockMetadataError';
+    }
+}
+exports.BlockMetadataError = BlockMetadataError;
+//# sourceMappingURL=blockMetadata.js.map

package/src/lib/errors/block/blockMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockMetadata.js","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockMetadata.ts"],"names":[],"mappings":";;;AAAA,sFAAmF;AAEnF,gEAA6D;AAC7D,kEAA+D;AAE/D,MAAa,kBAAmB,SAAQ,2CAA4C;IAClF,IAAW,SAAS;QAClB,OAAO;YACL,CAAC,+CAAsB,CAAC,eAAe,CAAC,EACtC,yBAAW,CAAC,uCAAuC;YACrD,CAAC,+CAAsB,CAAC,iBAAiB,CAAC,EACxC,yBAAW,CAAC,yCAAyC;YACvD,CAAC,+CAAsB,CAAC,oBAAoB,CAAC,EAC3C,yBAAW,CAAC,4CAA4C;YAC1D,CAAC,+CAAsB,CAAC,gBAAgB,CAAC,EACvC,yBAAW,CAAC,wCAAwC;YACtD,CAAC,+CAAsB,CAAC,uBAAuB,CAAC,EAC9C,yBAAW,CAAC,+CAA+C;YAC7D,CAAC,+CAAsB,CAAC,iBAAiB,CAAC,EACxC,yBAAW,CAAC,yCAAyC;SACxD,CAAC;IACJ,CAAC;IACD,YAAY,IAA4B,EAAE,SAA2B;QACnE,KAAK,CAAC,yBAAW,CAAC,2BAA2B,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AArBD,gDAqBC"}

package/src/lib/errors/block/blockValidation.d.ts

@@ -0,0 +1,20 @@
+import BlockType from '../../enumerations/blockType';
+import { BlockValidationErrorType } from '../../enumerations/blockValidationErrorType';
+import { StringLanguages } from '../../enumerations/stringLanguages';
+import { StringNames } from '../../enumerations/stringNames';
+import { TypedWithReasonError } from '../typedWithReasonError';
+export declare class BlockValidationError extends TypedWithReasonError<BlockValidationErrorType> {
+    readonly blockType?: BlockType;
+    readonly addressLength?: {
+        index: number;
+        length: number;
+        expectedLength: number;
+    };
+    get reasonMap(): Record<BlockValidationErrorType, StringNames>;
+    constructor(type: BlockValidationErrorType, blockType?: BlockType, addressLength?: {
+        index: number;
+        length: number;
+        expectedLength: number;
+    }, _language?: StringLanguages);
+}
+//# sourceMappingURL=blockValidation.d.ts.map

package/src/lib/errors/block/blockValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockValidation.d.ts","sourceRoot":"","sources":["../../../../../../brightchain-lib/src/lib/errors/block/blockValidation.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,8BAA8B,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;AACvF,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/D,qBAAa,oBAAqB,SAAQ,oBAAoB,CAAC,wBAAwB,CAAC;IACtF,SAAgB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtC,SAAgB,aAAa,CAAC,EAAE;QAC9B,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,IAAW,SAAS,IAAI,MAAM,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAuEpE;gBAEC,IAAI,EAAE,wBAAwB,EAC9B,SAAS,CAAC,EAAE,SAAS,EACrB,aAAa,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,EACzE,SAAS,CAAC,EAAE,eAAe;CAoB9B"}

package/src/lib/errors/block/blockValidation.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockValidationError = void 0;
+const blockValidationErrorType_1 = require("../../enumerations/blockValidationErrorType");
+const stringNames_1 = require("../../enumerations/stringNames");
+const typedWithReasonError_1 = require("../typedWithReasonError");
+class BlockValidationError extends typedWithReasonError_1.TypedWithReasonError {
+    get reasonMap() {
+        return {
+            [blockValidationErrorType_1.BlockValidationErrorType.ActualDataLengthUnknown]: stringNames_1.StringNames.Error_BlockValidationErrorActualDataLengthUnknown,
+            [blockValidationErrorType_1.BlockValidationErrorType.AddressCountExceedsCapacity]: stringNames_1.StringNames.Error_BlockValidationErrorAddressCountExceedsCapacity,
+            [blockValidationErrorType_1.BlockValidationErrorType.BlockDataNotBuffer]: stringNames_1.StringNames.Error_BlockValidationErrorBlockDataNotBuffer,
+            [blockValidationErrorType_1.BlockValidationErrorType.BlockSizeNegative]: stringNames_1.StringNames.Error_BlockValidationErrorBlockSizeNegative,
+            [blockValidationErrorType_1.BlockValidationErrorType.DataBufferIsTruncated]: stringNames_1.StringNames.Error_BlockValidationErrorDataBufferIsTruncated,
+            [blockValidationErrorType_1.BlockValidationErrorType.DataCannotBeEmpty]: stringNames_1.StringNames.Error_BlockValidationErrorDataCannotBeEmpty,
+            [blockValidationErrorType_1.BlockValidationErrorType.CreatorIDMismatch]: stringNames_1.StringNames.Error_BlockValidationErrorCreatorIDMismatch,
+            [blockValidationErrorType_1.BlockValidationErrorType.DataLengthExceedsCapacity]: stringNames_1.StringNames.Error_BlockValidationErrorDataLengthExceedsCapacity,
+            [blockValidationErrorType_1.BlockValidationErrorType.DataLengthTooShort]: stringNames_1.StringNames.Error_BlockValidationErrorDataLengthTooShort,
+            [blockValidationErrorType_1.BlockValidationErrorType.DataLengthTooShortForCBLHeader]: stringNames_1.StringNames.Error_BlockValidationErrorDataLengthTooShortForCBLHeader,
+            [blockValidationErrorType_1.BlockValidationErrorType.DataLengthTooShortForEncryptedCBL]: stringNames_1.StringNames.Error_BlockValidationErrorDataLengthTooShortForEncryptedCBL,
+            [blockValidationErrorType_1.BlockValidationErrorType.EphemeralBlockOnlySupportsBufferData]: stringNames_1.StringNames.Error_BlockValidationErrorEphemeralBlockOnlySupportsBufferData,
+            [blockValidationErrorType_1.BlockValidationErrorType.FutureCreationDate]: stringNames_1.StringNames.Error_BlockValidationErrorFutureCreationDate,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidAddressLength]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidAddressLengthTemplate,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidAuthTagLength]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidAuthTagLength,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidBlockType]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidBlockTypeTemplate,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidCBLAddressCount]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidCBLAddressCount,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidCBLDataLength]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidCBLDataLength,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidDateCreated]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidDateCreated,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidEncryptionHeaderLength]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidEncryptionHeaderLength,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidEphemeralPublicKeyLength]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidEphemeralPublicKeyLength,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidIVLength]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidIVLength,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidSignature]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidSignature,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidTupleSize]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidTupleSizeTemplate,
+            [blockValidationErrorType_1.BlockValidationErrorType.MethodMustBeImplementedByDerivedClass]: stringNames_1.StringNames.Error_BlockValidationErrorMethodMustBeImplementedByDerivedClass,
+            [blockValidationErrorType_1.BlockValidationErrorType.NoChecksum]: stringNames_1.StringNames.Error_BlockValidationErrorNoChecksum,
+            [blockValidationErrorType_1.BlockValidationErrorType.OriginalDataLengthNegative]: stringNames_1.StringNames.Error_BlockValidationErrorOriginalDataLengthNegative,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidRecipientCount]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidRecipientCount,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidRecipientIds]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidRecipientIds,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidEncryptionType]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidEncryptionType,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidCreator]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidCreator,
+            [blockValidationErrorType_1.BlockValidationErrorType.EncryptionRecipientNotFoundInRecipients]: stringNames_1.StringNames.Error_BlockValidationErrorEncryptionRecipientNotFoundInRecipients,
+            [blockValidationErrorType_1.BlockValidationErrorType.EncryptionRecipientHasNoPrivateKey]: stringNames_1.StringNames.Error_BlockValidationErrorEncryptionRecipientHasNoPrivateKey,
+            [blockValidationErrorType_1.BlockValidationErrorType.InvalidRecipientKeys]: stringNames_1.StringNames.Error_BlockValidationErrorInvalidRecipientKeys,
+        };
+    }
+    constructor(type, blockType, addressLength, _language) {
+        super(stringNames_1.StringNames.Error_BlockValidationErrorTemplate, type, {
+            ...(blockType
+                ? {
+                    TYPE: 'BlockType',
+                }
+                : {}),
+            ...(addressLength
+                ? {
+                    INDEX: addressLength.index,
+                    LENGTH: addressLength.length,
+                    EXPECTED_LENGTH: addressLength.expectedLength,
+                }
+                : {}),
+        });
+        this.name = 'BlockValidationError';
+        this.blockType = blockType;
+        this.addressLength = addressLength;
+    }
+}
+exports.BlockValidationError = BlockValidationError;
+//# sourceMappingURL=blockValidation.js.map