@bsv/sdk 1.3.12 → 1.3.13

package/src/wallet/__tests/CachedKeyDeriver.test.ts

@@ -1,6 +1,6 @@
-import { PrivateKey, PublicKey, SymmetricKey } from '../../../dist/cjs/src/primitives/index.js'
-import CachedKeyDeriver from '../../../dist/cjs/src/wallet/CachedKeyDeriver.js'
-import KeyDeriver from '../../../dist/cjs/src/wallet/KeyDeriver.js'
+import { PrivateKey, PublicKey, SymmetricKey } from '../../primitives/index'
+import CachedKeyDeriver from '../../wallet/CachedKeyDeriver'
+import KeyDeriver from '../../wallet/KeyDeriver'
 
 describe('CachedKeyDeriver', () => {
   let mockKeyDeriver: jest.Mocked<KeyDeriver>
@@ -20,7 +20,7 @@ describe('CachedKeyDeriver', () => {
 
     // Replace the internal keyDeriver instance with the mocked one
     cachedKeyDeriver = new CachedKeyDeriver(rootKey)
-    cachedKeyDeriver.keyDeriver = mockKeyDeriver
+    ;(cachedKeyDeriver as any).keyDeriver = mockKeyDeriver
   })
 
   describe('derivePublicKey', () => {
@@ -33,12 +33,20 @@ describe('CachedKeyDeriver', () => {
       mockKeyDeriver.derivePublicKey.mockReturnValue(publicKey)
 
       // First call - should invoke the underlying method
-      const result1 = cachedKeyDeriver.derivePublicKey(protocolID, keyID, counterparty)
+      const result1 = cachedKeyDeriver.derivePublicKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(mockKeyDeriver.derivePublicKey).toHaveBeenCalledTimes(1)
       expect(result1).toBe(publicKey)
 
       // Second call with the same parameters - should retrieve from cache
-      const result2 = cachedKeyDeriver.derivePublicKey(protocolID, keyID, counterparty)
+      const result2 = cachedKeyDeriver.derivePublicKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(mockKeyDeriver.derivePublicKey).toHaveBeenCalledTimes(1) // No additional calls
       expect(result2).toBe(publicKey)
     })
@@ -58,8 +66,16 @@ describe('CachedKeyDeriver', () => {
         .mockReturnValueOnce(publicKey2)
 
       // Different parameters - should not hit cache
-      const result1 = cachedKeyDeriver.derivePublicKey(protocolID1, keyID1, counterparty1)
-      const result2 = cachedKeyDeriver.derivePublicKey(protocolID2, keyID2, counterparty2)
+      const result1 = cachedKeyDeriver.derivePublicKey(
+        protocolID1,
+        keyID1,
+        counterparty1
+      )
+      const result2 = cachedKeyDeriver.derivePublicKey(
+        protocolID2,
+        keyID2,
+        counterparty2
+      )
       expect(mockKeyDeriver.derivePublicKey).toHaveBeenCalledTimes(2)
       expect(result1).toBe(publicKey1)
       expect(result2).toBe(publicKey2)
@@ -76,12 +92,20 @@ describe('CachedKeyDeriver', () => {
       mockKeyDeriver.derivePrivateKey.mockReturnValue(privateKey)
 
       // First call - should invoke the underlying method
-      const result1 = cachedKeyDeriver.derivePrivateKey(protocolID, keyID, counterparty)
+      const result1 = cachedKeyDeriver.derivePrivateKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(mockKeyDeriver.derivePrivateKey).toHaveBeenCalledTimes(1)
       expect(result1).toBe(privateKey)
 
       // Second call with the same parameters - should retrieve from cache
-      const result2 = cachedKeyDeriver.derivePrivateKey(protocolID, keyID, counterparty)
+      const result2 = cachedKeyDeriver.derivePrivateKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(mockKeyDeriver.derivePrivateKey).toHaveBeenCalledTimes(1)
       expect(result2).toBe(privateKey)
     })
@@ -98,11 +122,19 @@ describe('CachedKeyDeriver', () => {
         .mockReturnValueOnce(privateKey2)
 
       // First call
-      const result1 = cachedKeyDeriver.derivePrivateKey(protocolID, keyID, counterparty)
+      const result1 = cachedKeyDeriver.derivePrivateKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(result1).toBe(privateKey1)
 
       // Second call with different keyID
-      const result2 = cachedKeyDeriver.derivePrivateKey(protocolID, 'key2', counterparty)
+      const result2 = cachedKeyDeriver.derivePrivateKey(
+        protocolID,
+        'key2',
+        counterparty
+      )
       expect(result2).toBe(privateKey2)
       expect(mockKeyDeriver.derivePrivateKey).toHaveBeenCalledTimes(2)
     })
@@ -118,12 +150,20 @@ describe('CachedKeyDeriver', () => {
       mockKeyDeriver.deriveSymmetricKey.mockReturnValue(symmetricKey)
 
       // First call
-      const result1 = cachedKeyDeriver.deriveSymmetricKey(protocolID, keyID, counterparty)
+      const result1 = cachedKeyDeriver.deriveSymmetricKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(mockKeyDeriver.deriveSymmetricKey).toHaveBeenCalledTimes(1)
       expect(result1).toBe(symmetricKey)
 
       // Second call with same parameters
-      const result2 = cachedKeyDeriver.deriveSymmetricKey(protocolID, keyID, counterparty)
+      const result2 = cachedKeyDeriver.deriveSymmetricKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       expect(mockKeyDeriver.deriveSymmetricKey).toHaveBeenCalledTimes(1)
       expect(result2).toBe(symmetricKey)
     })
@@ -172,12 +212,20 @@ describe('CachedKeyDeriver', () => {
       mockKeyDeriver.revealSpecificSecret.mockReturnValue(secret)
 
       // First call
-      const result1 = cachedKeyDeriver.revealSpecificSecret(counterparty, protocolID, keyID)
+      const result1 = cachedKeyDeriver.revealSpecificSecret(
+        counterparty,
+        protocolID,
+        keyID
+      )
       expect(mockKeyDeriver.revealSpecificSecret).toHaveBeenCalledTimes(1)
       expect(result1).toBe(secret)
 
       // Second call with same parameters
-      const result2 = cachedKeyDeriver.revealSpecificSecret(counterparty, protocolID, keyID)
+      const result2 = cachedKeyDeriver.revealSpecificSecret(
+        counterparty,
+        protocolID,
+        keyID
+      )
       expect(mockKeyDeriver.revealSpecificSecret).toHaveBeenCalledTimes(1)
       expect(result2).toBe(secret)
     })
@@ -196,11 +244,19 @@ describe('CachedKeyDeriver', () => {
         .mockReturnValueOnce(secret2)
 
       // First call
-      const result1 = cachedKeyDeriver.revealSpecificSecret(counterparty, protocolID1, keyID1)
+      const result1 = cachedKeyDeriver.revealSpecificSecret(
+        counterparty,
+        protocolID1,
+        keyID1
+      )
       expect(result1).toBe(secret1)
 
       // Second call with different parameters
-      const result2 = cachedKeyDeriver.revealSpecificSecret(counterparty, protocolID2, keyID2)
+      const result2 = cachedKeyDeriver.revealSpecificSecret(
+        counterparty,
+        protocolID2,
+        keyID2
+      )
       expect(result2).toBe(secret2)
       expect(mockKeyDeriver.revealSpecificSecret).toHaveBeenCalledTimes(2)
     })
@@ -211,13 +267,13 @@ describe('CachedKeyDeriver', () => {
       const maxCacheSize = 5
       // Create a new CachedKeyDeriver with a small cache size
       cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize })
-      cachedKeyDeriver.keyDeriver = mockKeyDeriver
+      ;(cachedKeyDeriver as any).keyDeriver = mockKeyDeriver
 
       const protocolID: [0, string] = [0, 'testprotocol']
       const counterparty = 'self'
 
       // Mock return values
-      const mockResults = [1, 2, 3, 4, 5, 6].map((n) => new PublicKey(0))
+      const mockResults = [1, 2, 3, 4, 5, 6].map(n => new PublicKey(0))
 
       mockKeyDeriver.derivePublicKey
         .mockReturnValueOnce(mockResults[0])
@@ -233,7 +289,7 @@ describe('CachedKeyDeriver', () => {
       }
 
       // Cache should be full now
-      expect(cachedKeyDeriver.cache.size).toBe(maxCacheSize)
+      expect((cachedKeyDeriver as any).cache.size).toBe(maxCacheSize)
 
       // Access one of the earlier keys to make it recently used
       cachedKeyDeriver.derivePublicKey(protocolID, 'key0', counterparty)
@@ -242,11 +298,11 @@ describe('CachedKeyDeriver', () => {
       cachedKeyDeriver.derivePublicKey(protocolID, 'key5', counterparty)
 
       // Cache size should still be maxCacheSize
-      expect(cachedKeyDeriver.cache.size).toBe(maxCacheSize)
+      expect((cachedKeyDeriver as any).cache.size).toBe(maxCacheSize)
 
       // The least recently used item (key1) should have been evicted
       // The cache should contain keys: key0, key2, key3, key4, key5
-      expect(Array.from(cachedKeyDeriver.cache.keys())).toEqual([
+      expect(Array.from((cachedKeyDeriver as any).cache.keys())).toEqual([
         expect.stringContaining('key2'),
         expect.stringContaining('key3'),
         expect.stringContaining('key4'),
@@ -258,7 +314,7 @@ describe('CachedKeyDeriver', () => {
     it('should update the recentness of cache entries on access', () => {
       const maxCacheSize = 3
       cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize })
-      cachedKeyDeriver.keyDeriver = mockKeyDeriver
+      ;(cachedKeyDeriver as any).keyDeriver = mockKeyDeriver
 
       const protocolID: [0, string] = [0, 'testprotocol']
       const counterparty = 'self'
@@ -271,7 +327,7 @@ describe('CachedKeyDeriver', () => {
         .mockReturnValueOnce(publicKeys[2])
 
       // Fill the cache
-      keys.forEach((keyID) => {
+      keys.forEach(keyID => {
         cachedKeyDeriver.derivePublicKey(protocolID, keyID, counterparty)
       })
 
@@ -285,7 +341,7 @@ describe('CachedKeyDeriver', () => {
       cachedKeyDeriver.derivePublicKey(protocolID, newKeyID, counterparty)
 
       // 'key2' should be evicted as it is the least recently used
-      expect(Array.from(cachedKeyDeriver.cache.keys())).toEqual([
+      expect(Array.from((cachedKeyDeriver as any).cache.keys())).toEqual([
         expect.stringContaining('key3'),
         expect.stringContaining('key1'),
         expect.stringContaining('key4')
@@ -303,7 +359,7 @@ describe('CachedKeyDeriver', () => {
       // Simulate an expensive operation
       mockKeyDeriver.derivePublicKey.mockImplementation(() => {
         const start = Date.now()
-        while (Date.now() - start < 50) { } // Busy wait for 50ms
+        while (Date.now() - start < 50) {} // Busy wait for 50ms
         return publicKey
       })
 

package/src/wallet/__tests/KeyDeriver.test.ts

@@ -1,118 +1,221 @@
-import { PrivateKey, PublicKey, SymmetricKey, Utils, Hash } from '../../../dist/cjs/src/primitives/index.js'
-import KeyDeriver from '../../../dist/cjs/src/wallet/KeyDeriver.js'
-
-describe('KeyDeriver', () => {
-  const rootPrivateKey = new PrivateKey(42)
-  const rootPublicKey = rootPrivateKey.toPublicKey()
-  const counterpartyPrivateKey = new PrivateKey(69)
-  const counterpartyPublicKey = counterpartyPrivateKey.toPublicKey()
-  const anyonePublicKey = new PrivateKey(1).toPublicKey()
-
-  const protocolID: [0 | 1 | 2, string] = [0, 'testprotocol']
-  const keyID = '12345'
-
-  let keyDeriver: KeyDeriver
+import {
+  PrivateKey,
+  PublicKey,
+  SymmetricKey,
+  Utils,
+  Hash,
+} from "../../primitives/index";
+import KeyDeriver from "../../wallet/KeyDeriver";
+
+describe("KeyDeriver", () => {
+  const rootPrivateKey = new PrivateKey(42);
+  const rootPublicKey = rootPrivateKey.toPublicKey();
+  const counterpartyPrivateKey = new PrivateKey(69);
+  const counterpartyPublicKey = counterpartyPrivateKey.toPublicKey();
+  const anyonePublicKey = new PrivateKey(1).toPublicKey();
+
+  const protocolID: [0 | 1 | 2, string] = [0, "testprotocol"];
+  const keyID = "12345";
+
+  let keyDeriver: KeyDeriver;
 
   beforeEach(() => {
-    keyDeriver = new KeyDeriver(rootPrivateKey)
-  })
-
-  test('should compute the correct invoice number', () => {
-    const invoiceNumber = (keyDeriver as any).computeInvoiceNumber(protocolID, keyID)
-    expect(invoiceNumber).toBe('0-testprotocol-12345')
-  })
-
-  test('should throw if no co counterparty given', () => {
-    expect(() => (keyDeriver as any).normalizeCounterparty()).toThrow()
-  })
-
-  test('should normalize counterparty correctly for self', () => {
-    const normalized = (keyDeriver as any).normalizeCounterparty('self')
-    expect(normalized.toString()).toBe(rootPublicKey.toString())
-  })
-
-  test('should normalize counterparty correctly for anyone', () => {
-    const normalized = (keyDeriver as any).normalizeCounterparty('anyone')
-    expect(normalized.toString()).toBe(anyonePublicKey.toString())
-  })
-
-  test('should normalize counterparty correctly when given as a hex string', () => {
-    const normalized = (keyDeriver as any).normalizeCounterparty(counterpartyPublicKey.toString())
-    expect(normalized.toString()).toBe(counterpartyPublicKey.toString())
-  })
-
-  test('should normalize counterparty correctly when given as a public key', () => {
-    const normalized = (keyDeriver as any).normalizeCounterparty(counterpartyPublicKey)
-    expect(normalized.toString()).toBe(counterpartyPublicKey.toString())
-  })
-
-  test('should allow public key derivation as anyone', () => {
-    const anyoneDeriver = new KeyDeriver('anyone')
-    const derivedPublicKey = anyoneDeriver.derivePublicKey(protocolID, keyID, counterpartyPublicKey)
-    expect(derivedPublicKey).toBeInstanceOf(PublicKey)
-    expect(derivedPublicKey.toString()).toEqual(counterpartyPublicKey.deriveChild(new PrivateKey(1), '0-testprotocol-12345').toString())
-  })
-
-  test('should derive the correct public key for counterparty', () => {
-    const derivedPublicKey = keyDeriver.derivePublicKey(protocolID, keyID, counterpartyPublicKey)
-    expect(derivedPublicKey).toBeInstanceOf(PublicKey)
-    expect(derivedPublicKey.toString()).toEqual(counterpartyPublicKey.deriveChild(rootPrivateKey, '0-testprotocol-12345').toString())
-  })
-
-  test('should derive the correct public key for self', () => {
-    const derivedPublicKey = keyDeriver.derivePublicKey(protocolID, keyID, counterpartyPublicKey, true)
-    expect(derivedPublicKey).toBeInstanceOf(PublicKey)
-    expect(derivedPublicKey.toString()).toEqual(rootPrivateKey.deriveChild(counterpartyPublicKey, '0-testprotocol-12345').toPublicKey().toString())
-  })
-
-  test('should derive the correct private key', () => {
-    const derivedPrivateKey = keyDeriver.derivePrivateKey(protocolID, keyID, counterpartyPublicKey)
-    expect(derivedPrivateKey).toBeInstanceOf(PrivateKey)
-    expect(derivedPrivateKey.toString()).toEqual(rootPrivateKey.deriveChild(counterpartyPublicKey, '0-testprotocol-12345').toString())
-  })
-
-  test('should derive the correct symmetric key', () => {
-    const derivedSymmetricKey = keyDeriver.deriveSymmetricKey(protocolID, keyID, counterpartyPublicKey)
-    expect(derivedSymmetricKey).toBeInstanceOf(SymmetricKey)
-    const priv = rootPrivateKey.deriveChild(counterpartyPublicKey, '0-testprotocol-12345')
-    const pub = counterpartyPublicKey.deriveChild(rootPrivateKey, '0-testprotocol-12345')
-    expect(derivedSymmetricKey.toHex()).toEqual(new SymmetricKey(priv.deriveSharedSecret(pub).x?.toArray()).toHex())
-  })
-
-  test('should be able to derive symmetric key with anyone', () => {
-    expect(() => keyDeriver.deriveSymmetricKey(protocolID, keyID, 'anyone')).not.toThrow()
-  })
-
-  test('should reveal the correct counterparty shared secret', () => {
-    const sharedSecret = keyDeriver.revealCounterpartySecret(counterpartyPublicKey)
-    expect(sharedSecret).toBeInstanceOf(Array)
-    expect(sharedSecret.length).toBeGreaterThan(0)
-    expect(sharedSecret).toEqual(rootPrivateKey.deriveSharedSecret(counterpartyPublicKey).encode(true))
-  })
-
-  test('should not reveal shared secret for self', () => {
-    expect(() => keyDeriver.revealCounterpartySecret('self')).toThrow()
-    expect(() => keyDeriver.revealCounterpartySecret(rootPublicKey)).toThrow()
-  })
-
-  test('should reveal the specific key association', () => {
-    const specificSecret = keyDeriver.revealSpecificSecret(counterpartyPublicKey, protocolID, keyID)
-    expect(specificSecret).toBeInstanceOf(Array)
-    expect(specificSecret.length).toBeGreaterThan(0)
-    const sharedSecret = rootPrivateKey.deriveSharedSecret(counterpartyPublicKey)
-    const invoiceNumberBin = Utils.toArray((keyDeriver as any).computeInvoiceNumber(protocolID, keyID), 'utf8')
-    expect(specificSecret).toEqual(Hash.sha256hmac(sharedSecret.encode(true), invoiceNumberBin))
-  })
-
-  test('should throw an error for invalid protocol names', () => {
-    expect(() => (keyDeriver as any).computeInvoiceNumber(protocolID, 'long' + 'a'.repeat(800))).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber(protocolID, '')).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([-3, 'otherwise valid'], keyID)).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([2, 'double  space'], keyID)).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([0, ''], keyID)).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([0, ' a'], keyID)).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([0, 'long' + 'a'.repeat(400)], keyID)).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([2, 'redundant protocol protocol'], keyID)).toThrow()
-    expect(() => (keyDeriver as any).computeInvoiceNumber([2, 'üñî√é®sål ©0på'], keyID)).toThrow()
-  })
-})
+    keyDeriver = new KeyDeriver(rootPrivateKey);
+  });
+
+  test("should compute the correct invoice number", () => {
+    const invoiceNumber = (keyDeriver as any).computeInvoiceNumber(
+      protocolID,
+      keyID
+    );
+    expect(invoiceNumber).toBe("0-testprotocol-12345");
+  });
+
+  test("should throw if no co counterparty given", () => {
+    expect(() => (keyDeriver as any).normalizeCounterparty()).toThrow();
+  });
+
+  test("should normalize counterparty correctly for self", () => {
+    const normalized = (keyDeriver as any).normalizeCounterparty("self");
+    expect(normalized.toString()).toBe(rootPublicKey.toString());
+  });
+
+  test("should normalize counterparty correctly for anyone", () => {
+    const normalized = (keyDeriver as any).normalizeCounterparty("anyone");
+    expect(normalized.toString()).toBe(anyonePublicKey.toString());
+  });
+
+  test("should normalize counterparty correctly when given as a hex string", () => {
+    const normalized = (keyDeriver as any).normalizeCounterparty(
+      counterpartyPublicKey.toString()
+    );
+    expect(normalized.toString()).toBe(counterpartyPublicKey.toString());
+  });
+
+  test("should normalize counterparty correctly when given as a public key", () => {
+    const normalized = (keyDeriver as any).normalizeCounterparty(
+      counterpartyPublicKey
+    );
+    expect(normalized.toString()).toBe(counterpartyPublicKey.toString());
+  });
+
+  test("should allow public key derivation as anyone", () => {
+    const anyoneDeriver = new KeyDeriver("anyone");
+    const derivedPublicKey = anyoneDeriver.derivePublicKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    );
+    expect(derivedPublicKey).toBeInstanceOf(PublicKey);
+    expect(derivedPublicKey.toString()).toEqual(
+      counterpartyPublicKey
+        .deriveChild(new PrivateKey(1), "0-testprotocol-12345")
+        .toString()
+    );
+  });
+
+  test("should derive the correct public key for counterparty", () => {
+    const derivedPublicKey = keyDeriver.derivePublicKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    );
+    expect(derivedPublicKey).toBeInstanceOf(PublicKey);
+    expect(derivedPublicKey.toString()).toEqual(
+      counterpartyPublicKey
+        .deriveChild(rootPrivateKey, "0-testprotocol-12345")
+        .toString()
+    );
+  });
+
+  test("should derive the correct public key for self", () => {
+    const derivedPublicKey = keyDeriver.derivePublicKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey,
+      true
+    );
+    expect(derivedPublicKey).toBeInstanceOf(PublicKey);
+    expect(derivedPublicKey.toString()).toEqual(
+      rootPrivateKey
+        .deriveChild(counterpartyPublicKey, "0-testprotocol-12345")
+        .toPublicKey()
+        .toString()
+    );
+  });
+
+  test("should derive the correct private key", () => {
+    const derivedPrivateKey = keyDeriver.derivePrivateKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    );
+    expect(derivedPrivateKey).toBeInstanceOf(PrivateKey);
+    expect(derivedPrivateKey.toString()).toEqual(
+      rootPrivateKey
+        .deriveChild(counterpartyPublicKey, "0-testprotocol-12345")
+        .toString()
+    );
+  });
+
+  test("should derive the correct symmetric key", () => {
+    const derivedSymmetricKey = keyDeriver.deriveSymmetricKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    );
+    expect(derivedSymmetricKey).toBeInstanceOf(SymmetricKey);
+    const priv = rootPrivateKey.deriveChild(
+      counterpartyPublicKey,
+      "0-testprotocol-12345"
+    );
+    const pub = counterpartyPublicKey.deriveChild(
+      rootPrivateKey,
+      "0-testprotocol-12345"
+    );
+    expect(derivedSymmetricKey.toHex()).toEqual(
+      new SymmetricKey(priv.deriveSharedSecret(pub).x?.toArray()).toHex()
+    );
+  });
+
+  test("should be able to derive symmetric key with anyone", () => {
+    expect(() =>
+      keyDeriver.deriveSymmetricKey(protocolID, keyID, "anyone")
+    ).not.toThrow();
+  });
+
+  test("should reveal the correct counterparty shared secret", () => {
+    const sharedSecret = keyDeriver.revealCounterpartySecret(
+      counterpartyPublicKey
+    );
+    expect(sharedSecret).toBeInstanceOf(Array);
+    expect(sharedSecret.length).toBeGreaterThan(0);
+    expect(sharedSecret).toEqual(
+      rootPrivateKey.deriveSharedSecret(counterpartyPublicKey).encode(true)
+    );
+  });
+
+  test("should not reveal shared secret for self", () => {
+    expect(() => keyDeriver.revealCounterpartySecret("self")).toThrow();
+    expect(() => keyDeriver.revealCounterpartySecret(rootPublicKey)).toThrow();
+  });
+
+  test("should reveal the specific key association", () => {
+    const specificSecret = keyDeriver.revealSpecificSecret(
+      counterpartyPublicKey,
+      protocolID,
+      keyID
+    );
+    expect(specificSecret).toBeInstanceOf(Array);
+    expect(specificSecret.length).toBeGreaterThan(0);
+    const sharedSecret = rootPrivateKey.deriveSharedSecret(
+      counterpartyPublicKey
+    );
+    const invoiceNumberBin = Utils.toArray(
+      (keyDeriver as any).computeInvoiceNumber(protocolID, keyID),
+      "utf8"
+    );
+    expect(specificSecret).toEqual(
+      Hash.sha256hmac(sharedSecret.encode(true), invoiceNumberBin)
+    );
+  });
+
+  test("should throw an error for invalid protocol names", () => {
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber(
+        protocolID,
+        "long" + "a".repeat(800)
+      )
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber(protocolID, "")
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber([-3, "otherwise valid"], keyID)
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber([2, "double  space"], keyID)
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber([0, ""], keyID)
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber([0, " a"], keyID)
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber(
+        [0, "long" + "a".repeat(400)],
+        keyID
+      )
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber(
+        [2, "redundant protocol protocol"],
+        keyID
+      )
+    ).toThrow();
+    expect(() =>
+      (keyDeriver as any).computeInvoiceNumber([2, "üñî√é®sål ©0på"], keyID)
+    ).toThrow();
+  });
+});