@digitaldefiance/node-ecies-lib 4.4.1 → 4.4.3

package/src/interfaces/stream-config.ts

@@ -0,0 +1,9 @@
+export interface IStreamConfig {
+  chunkSize: number;
+  includeChecksums: boolean;
+}
+
+export const DEFAULT_STREAM_CONFIG: IStreamConfig = {
+  chunkSize: 65536, // 64KB
+  includeChecksums: false,
+};

package/src/interfaces/stream-progress.ts

@@ -0,0 +1,7 @@
+export interface IStreamProgress {
+  processedBytes: number;
+  totalBytes: number;
+  percentComplete: number;
+  throughputBytesPerSec: number;
+  estimatedTimeRemainingMs: number;
+}

package/src/interfaces/{wallet-seed.d.ts → wallet-seed.ts}

@@ -1,7 +1,7 @@
 import { SecureBuffer } from '@digitaldefiance/ecies-lib';
 import { Wallet } from '@ethereumjs/wallet';
+
 export interface IWalletSeed {
-    wallet: Wallet;
-    seed: SecureBuffer;
+  wallet: Wallet;
+  seed: SecureBuffer;
 }
-//# sourceMappingURL=wallet-seed.d.ts.map

package/src/interfaces/wrapped-key-consts.ts

@@ -0,0 +1,6 @@
+export interface IWrappedKeyConsts {
+  SALT_SIZE: number;
+  IV_SIZE: number;
+  MASTER_KEY_SIZE: number;
+  MIN_ITERATIONS: number;
+}

package/src/lib/crypto-container.ts

@@ -0,0 +1,32 @@
+import { ECIESService } from '../services/ecies';
+import { Pbkdf2Service } from '../services/pbkdf2';
+import { AESGCMService } from '../services/aes-gcm';
+import { IConstants } from '../interfaces/constants';
+import { Constants } from '../constants';
+
+export enum CryptoServiceKey {
+  ECIES = 'ecies',
+  PBKDF2 = 'pbkdf2',
+  AES_GCM = 'aes-gcm',
+}
+
+export class CryptoContainer {
+  private services = new Map<CryptoServiceKey, unknown>();
+
+  private constructor(config: IConstants) {
+    this.services.set(CryptoServiceKey.ECIES, new ECIESService(undefined, config.ECIES));
+    this.services.set(
+      CryptoServiceKey.PBKDF2,
+      new Pbkdf2Service(config.PBKDF2_PROFILES, config.ECIES, config.PBKDF2)
+    );
+    this.services.set(CryptoServiceKey.AES_GCM, new AESGCMService(config));
+  }
+
+  static create(config: IConstants = Constants): CryptoContainer {
+    return new CryptoContainer(config);
+  }
+
+  get<T>(key: CryptoServiceKey): T {
+    return this.services.get(key) as T;
+  }
+}

package/src/lib/{index.d.ts → index.ts}

@@ -1,4 +1,3 @@
 export * from './crypto-container';
 export * from './invariant-validator';
 export * from './invariants';
-//# sourceMappingURL=index.d.ts.map

package/src/lib/invariant-validator.ts

@@ -0,0 +1,124 @@
+import { 
+  InvariantValidator as BaseInvariantValidator,
+  IInvariant 
+} from '@digitaldefiance/ecies-lib';
+import { TranslatableGenericError } from '@digitaldefiance/i18n-lib';
+import { IConstants } from '../interfaces/constants';
+import { RecipientIdConsistencyInvariant } from './invariants/recipient-id-consistency';
+import { NodeEciesStringKey, NodeEciesComponentId } from '../i18n/node-keys';
+import { getNodeEciesI18nEngine } from '../i18n/node-ecies-i18n-setup';
+
+/**
+ * Node.js-specific invariant validator.
+ * 
+ * Extends the base ecies-lib validator with Node.js-specific invariants.
+ * Validates configuration consistency to prevent bugs like the 12 vs 32-byte
+ * recipient ID discrepancy.
+ * 
+ * @example
+ * ```typescript
+ * import { InvariantValidator } from '@digitaldefiance/node-ecies-lib';
+ * import { MyCustomInvariant } from './my-invariants';
+ * 
+ * // Register a custom invariant
+ * InvariantValidator.registerInvariant(new MyCustomInvariant());
+ * 
+ * // Validate configuration
+ * InvariantValidator.validateAll(config); // throws if any invariant fails
+ * ```
+ */
+export class InvariantValidator {
+  /**
+   * Node-specific invariants registered by default.
+   */
+  private static readonly NODE_DEFAULT_INVARIANTS: IInvariant[] = [
+    new RecipientIdConsistencyInvariant(),
+  ];
+
+  private static customInvariants: IInvariant[] = [];
+
+  /**
+   * Register a custom invariant to be checked during validation.
+   * 
+   * @param invariant - The invariant to register
+   */
+  static registerInvariant(invariant: IInvariant): void {
+    this.customInvariants.push(invariant);
+    // Also register with base validator for consistency
+    BaseInvariantValidator.registerInvariant(invariant);
+  }
+
+  /**
+   * Unregister a custom invariant by name.
+   * 
+   * @param name - The name of the invariant to unregister
+   * @returns true if the invariant was found and removed, false otherwise
+   */
+  static unregisterInvariant(name: string): boolean {
+    const index = this.customInvariants.findIndex((inv) => inv.name === name);
+    if (index === -1) {
+      return false;
+    }
+    this.customInvariants.splice(index, 1);
+    return true;
+  }
+
+  /**
+   * Get all registered invariants (default + custom).
+   */
+  static getAllInvariants(): readonly IInvariant[] {
+    return [...this.NODE_DEFAULT_INVARIANTS, ...this.customInvariants];
+  }
+
+  /**
+   * Validate all registered invariants against a configuration.
+   * 
+   * This checks both:
+   * - Base ecies-lib invariants (via BaseInvariantValidator)
+   * - Node-specific invariants
+   * 
+   * @param config - The configuration to validate
+   * @throws Error if any invariant check fails
+   */
+  static validateAll(config: IConstants): void {
+    const failures: string[] = [];
+
+    // First, validate base ecies-lib invariants, excluding the one we are replacing
+    const baseInvariants = BaseInvariantValidator.getAllInvariants();
+    for (const invariant of baseInvariants) {
+      if (invariant.name === 'RecipientIdConsistency') {
+        continue;
+      }
+      if (!invariant.check(config)) {
+        failures.push(invariant.errorMessage(config));
+      }
+    }
+
+    // Then validate Node-specific invariants
+    for (const invariant of this.getAllInvariants()) {
+      if (!invariant.check(config)) {
+        failures.push(invariant.errorMessage(config));
+      }
+    }
+
+    if (failures.length > 0) {
+      const engine = getNodeEciesI18nEngine();
+      throw TranslatableGenericError.withEngine(
+        engine,
+        NodeEciesComponentId,
+        NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate,
+        { failures: failures.join('\n\n') },
+        undefined,
+        { invariantCount: failures.length }
+      );
+    }
+  }
+
+  /**
+   * Clear all custom invariants.
+   * Default invariants are not affected.
+   */
+  static clearCustomInvariants(): void {
+    this.customInvariants = [];
+  }
+}

package/src/lib/invariants/{index.d.ts → index.ts}

@@ -1,8 +1,8 @@
 /**
  * Node.js-specific invariants for configuration validation.
- *
+ * 
  * These invariants extend and complement the base ecies-lib invariants
  * with Node.js-specific validation rules.
  */
+
 export { RecipientIdConsistencyInvariant } from './recipient-id-consistency';
-//# sourceMappingURL=index.d.ts.map

package/src/lib/invariants/recipient-id-consistency.ts

@@ -0,0 +1,77 @@
+import { BaseInvariant } from '@digitaldefiance/ecies-lib';
+import { IConstants } from '../../interfaces/constants';
+import { NodeEciesStringKey } from '../../i18n/node-keys';
+import { getNodeEciesTranslation } from '../../i18n/ecies-i18n-factory';
+
+/**
+ * Node.js-specific recipient ID consistency invariant.
+ * 
+ * Extends the base ecies-lib invariant to also validate node-specific
+ * ENCRYPTION.RECIPIENT_ID_SIZE constant.
+ * 
+ * This invariant would have caught the 12 vs 32 byte discrepancy.
+ * 
+ * Checks:
+ * - MEMBER_ID_LENGTH === idProvider.byteLength
+ * - ECIES.MULTIPLE.RECIPIENT_ID_SIZE === idProvider.byteLength
+ * - ENCRYPTION.RECIPIENT_ID_SIZE === idProvider.byteLength (Node-specific)
+ * - All values must be in sync
+ */
+export class RecipientIdConsistencyInvariant extends BaseInvariant {
+  constructor() {
+    super(
+      'NodeRecipientIdConsistency',
+      'All recipient ID size configurations must match the ID provider byte length (including Node-specific ENCRYPTION constant)'
+    );
+  }
+
+  check(config: IConstants): boolean {
+    const baseChecks = 
+      config.MEMBER_ID_LENGTH === config.idProvider.byteLength &&
+      config.ECIES.MULTIPLE.RECIPIENT_ID_SIZE === config.idProvider.byteLength;
+    
+    // ENCRYPTION is node-specific and may not exist in all configs
+    if (config.ENCRYPTION && 'RECIPIENT_ID_SIZE' in config.ENCRYPTION) {
+      return baseChecks && config.ENCRYPTION.RECIPIENT_ID_SIZE === config.idProvider.byteLength;
+    }
+    
+    return baseChecks;
+  }
+
+  errorMessage(config: IConstants): string {
+    const issues: string[] = [];
+
+    if (config.MEMBER_ID_LENGTH !== config.idProvider.byteLength) {
+      issues.push(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate, {
+          actual: config.MEMBER_ID_LENGTH,
+          expected: config.idProvider.byteLength,
+        })
+      );
+    }
+
+    if (config.ECIES.MULTIPLE.RECIPIENT_ID_SIZE !== config.idProvider.byteLength) {
+      issues.push(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate, {
+          actual: config.ECIES.MULTIPLE.RECIPIENT_ID_SIZE,
+          expected: config.idProvider.byteLength,
+        })
+      );
+    }
+
+    if (config.ENCRYPTION && 'RECIPIENT_ID_SIZE' in config.ENCRYPTION) {
+      if (config.ENCRYPTION.RECIPIENT_ID_SIZE !== config.idProvider.byteLength) {
+        issues.push(
+          getNodeEciesTranslation(NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate, {
+            actual: config.ENCRYPTION.RECIPIENT_ID_SIZE,
+            expected: config.idProvider.byteLength,
+          })
+        );
+      }
+    }
+
+    return getNodeEciesTranslation(NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate, {
+      issues: issues.join('\n  '),
+    });
+  }
+}