@bsv/sdk 1.3.12 → 1.3.14

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,6 +20,7 @@ describe('CachedKeyDeriver', () => {
 
     // Replace the internal keyDeriver instance with the mocked one
     cachedKeyDeriver = new CachedKeyDeriver(rootKey)
+    // @ts-expect-error: Accessing private property for testing purposes
     cachedKeyDeriver.keyDeriver = mockKeyDeriver
   })
 
@@ -33,12 +34,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 +67,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 +93,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 +123,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 +151,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 +213,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 +245,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)
     })
@@ -210,14 +267,14 @@ describe('CachedKeyDeriver', () => {
     it('should not exceed the max cache size and evict least recently used items', () => {
       const maxCacheSize = 5
       // Create a new CachedKeyDeriver with a small cache size
-      cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize })
-      cachedKeyDeriver.keyDeriver = mockKeyDeriver
+      cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize });
+      (cachedKeyDeriver as unknown as { keyDeriver: KeyDeriver }).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(() => new PublicKey(0))
 
       mockKeyDeriver.derivePublicKey
         .mockReturnValueOnce(mockResults[0])
@@ -233,7 +290,7 @@ describe('CachedKeyDeriver', () => {
       }
 
       // Cache should be full now
-      expect(cachedKeyDeriver.cache.size).toBe(maxCacheSize)
+      expect((cachedKeyDeriver as unknown as { cache: Map<string, PublicKey | PrivateKey | SymmetricKey | number[]> }).cache.size).toBe(maxCacheSize)
 
       // Access one of the earlier keys to make it recently used
       cachedKeyDeriver.derivePublicKey(protocolID, 'key0', counterparty)
@@ -242,11 +299,11 @@ describe('CachedKeyDeriver', () => {
       cachedKeyDeriver.derivePublicKey(protocolID, 'key5', counterparty)
 
       // Cache size should still be maxCacheSize
-      expect(cachedKeyDeriver.cache.size).toBe(maxCacheSize)
+      expect((cachedKeyDeriver as unknown as { cache: Map<string, PublicKey | PrivateKey | SymmetricKey | number[]> }).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 unknown as { cache: Map<string, PublicKey | PrivateKey | SymmetricKey | number[]> }).cache.keys())).toEqual([
         expect.stringContaining('key2'),
         expect.stringContaining('key3'),
         expect.stringContaining('key4'),
@@ -257,8 +314,8 @@ describe('CachedKeyDeriver', () => {
 
     it('should update the recentness of cache entries on access', () => {
       const maxCacheSize = 3
-      cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize })
-      cachedKeyDeriver.keyDeriver = mockKeyDeriver
+      cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize });
+      (cachedKeyDeriver as unknown as { keyDeriver: KeyDeriver }).keyDeriver = mockKeyDeriver
 
       const protocolID: [0, string] = [0, 'testprotocol']
       const counterparty = 'self'
@@ -285,7 +342,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 unknown as { cache: Map<string, PublicKey | PrivateKey | SymmetricKey | number[]> }).cache.keys())).toEqual([
         expect.stringContaining('key3'),
         expect.stringContaining('key1'),
         expect.stringContaining('key4')
@@ -303,7 +360,9 @@ 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) {
+          // Intentional busy wait for 50ms
+        } // Busy wait for 50ms
         return publicKey
       })
 

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

@@ -1,5 +1,11 @@
-import { PrivateKey, PublicKey, SymmetricKey, Utils, Hash } from '../../../dist/cjs/src/primitives/index.js'
-import KeyDeriver from '../../../dist/cjs/src/wallet/KeyDeriver.js'
+import {
+  PrivateKey,
+  PublicKey,
+  SymmetricKey,
+  Utils,
+  Hash
+} from '../../primitives/index'
+import KeyDeriver from '../../wallet/KeyDeriver'
 
 describe('KeyDeriver', () => {
   const rootPrivateKey = new PrivateKey(42)
@@ -18,7 +24,10 @@ describe('KeyDeriver', () => {
   })
 
   test('should compute the correct invoice number', () => {
-    const invoiceNumber = (keyDeriver as any).computeInvoiceNumber(protocolID, keyID)
+    const invoiceNumber = (keyDeriver as any).computeInvoiceNumber(
+      protocolID,
+      keyID
+    )
     expect(invoiceNumber).toBe('0-testprotocol-12345')
   })
 
@@ -37,57 +46,113 @@ describe('KeyDeriver', () => {
   })
 
   test('should normalize counterparty correctly when given as a hex string', () => {
-    const normalized = (keyDeriver as any).normalizeCounterparty(counterpartyPublicKey.toString())
+    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)
+    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)
+    const derivedPublicKey = anyoneDeriver.derivePublicKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    )
     expect(derivedPublicKey).toBeInstanceOf(PublicKey)
-    expect(derivedPublicKey.toString()).toEqual(counterpartyPublicKey.deriveChild(new PrivateKey(1), '0-testprotocol-12345').toString())
+    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)
+    const derivedPublicKey = keyDeriver.derivePublicKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    )
     expect(derivedPublicKey).toBeInstanceOf(PublicKey)
-    expect(derivedPublicKey.toString()).toEqual(counterpartyPublicKey.deriveChild(rootPrivateKey, '0-testprotocol-12345').toString())
+    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)
+    const derivedPublicKey = keyDeriver.derivePublicKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey,
+      true
+    )
     expect(derivedPublicKey).toBeInstanceOf(PublicKey)
-    expect(derivedPublicKey.toString()).toEqual(rootPrivateKey.deriveChild(counterpartyPublicKey, '0-testprotocol-12345').toPublicKey().toString())
+    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)
+    const derivedPrivateKey = keyDeriver.derivePrivateKey(
+      protocolID,
+      keyID,
+      counterpartyPublicKey
+    )
     expect(derivedPrivateKey).toBeInstanceOf(PrivateKey)
-    expect(derivedPrivateKey.toString()).toEqual(rootPrivateKey.deriveChild(counterpartyPublicKey, '0-testprotocol-12345').toString())
+    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)
+    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())
+    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()
+    expect(() =>
+      keyDeriver.deriveSymmetricKey(protocolID, keyID, 'anyone')
+    ).not.toThrow()
   })
 
   test('should reveal the correct counterparty shared secret', () => {
-    const sharedSecret = keyDeriver.revealCounterpartySecret(counterpartyPublicKey)
+    const sharedSecret = keyDeriver.revealCounterpartySecret(
+      counterpartyPublicKey
+    )
     expect(sharedSecret).toBeInstanceOf(Array)
     expect(sharedSecret.length).toBeGreaterThan(0)
-    expect(sharedSecret).toEqual(rootPrivateKey.deriveSharedSecret(counterpartyPublicKey).encode(true))
+    expect(sharedSecret).toEqual(
+      rootPrivateKey.deriveSharedSecret(counterpartyPublicKey).encode(true)
+    )
   })
 
   test('should not reveal shared secret for self', () => {
@@ -96,23 +161,61 @@ describe('KeyDeriver', () => {
   })
 
   test('should reveal the specific key association', () => {
-    const specificSecret = keyDeriver.revealSpecificSecret(counterpartyPublicKey, protocolID, keyID)
+    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))
+    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()
+    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()
   })
 })