@bsv/sdk 1.3.13 → 1.3.14

package/src/wallet/WalletClient.ts

@@ -3,22 +3,17 @@ import {
   AcquireCertificateResult,
   Base64String,
   BasketStringUnder300Bytes,
-  BEEF,
   BooleanDefaultFalse,
-  BooleanDefaultTrue,
   Byte,
   CertificateFieldNameUnder50Bytes,
   CreateActionArgs,
   CreateActionResult,
   DescriptionString5to50Bytes,
   DiscoverCertificatesResult,
-  EntityIconURLStringMax500Bytes,
-  EntityNameStringMax100Bytes,
   HexString,
   InternalizeActionArgs,
   ISOTimestampString,
   KeyIDStringUnder800Bytes,
-  LabelStringUnder300Bytes,
   ListActionsArgs,
   ListActionsResult,
   ListCertificatesResult,
@@ -26,29 +21,25 @@ import {
   ListOutputsResult,
   OriginatorDomainNameStringUnder250Bytes,
   OutpointString,
-  OutputTagStringUnder300Bytes,
   PositiveInteger,
   PositiveIntegerDefault10Max10000,
-  PositiveIntegerMax10,
   PositiveIntegerOrZero,
   ProtocolString5To400Bytes,
   ProveCertificateArgs,
   ProveCertificateResult,
   PubKeyHex,
-  SatoshiValue,
   SecurityLevel,
   SignActionArgs,
   SignActionResult,
-  TXIDHexString,
   VersionString7To30Bytes,
   WalletInterface,
   AuthenticatedResult
-} from './Wallet.interfaces'
-import WindowCWISubstrate from './substrates/window.CWI'
-import XDMSubstrate from './substrates/XDM'
-import WalletWireTransceiver from './substrates/WalletWireTransceiver'
-import HTTPWalletWire from './substrates/HTTPWalletWire'
-import HTTPWalletJSON from './substrates/HTTPWalletJSON'
+} from './Wallet.interfaces.js'
+import WindowCWISubstrate from './substrates/window.CWI.js'
+import XDMSubstrate from './substrates/XDM.js'
+import WalletWireTransceiver from './substrates/WalletWireTransceiver.js'
+import HTTPWalletWire from './substrates/HTTPWalletWire.js'
+import HTTPWalletJSON from './substrates/HTTPWalletJSON.js'
 
 const MAX_XDM_RESPONSE_WAIT = 200
 
@@ -68,7 +59,9 @@ export default class WalletClient implements WalletInterface {
     | WalletInterface = 'auto',
     originator?: OriginatorDomainNameStringUnder250Bytes
   ) {
-    if (substrate === 'Cicada') { substrate = new WalletWireTransceiver(new HTTPWalletWire(originator)) }
+    if (substrate === 'Cicada') {
+      substrate = new WalletWireTransceiver(new HTTPWalletWire(originator))
+    }
     if (substrate === 'window.CWI') substrate = new WindowCWISubstrate()
     if (substrate === 'XDM') substrate = new XDMSubstrate()
     if (substrate === 'json-api') substrate = new HTTPWalletJSON(originator)
@@ -76,17 +69,17 @@ export default class WalletClient implements WalletInterface {
     this.originator = originator
   }
 
-  async connectToSubstrate () {
+  async connectToSubstrate (): Promise<void> {
     if (typeof this.substrate === 'object') {
       return // substrate is already connected
     }
     let sub: WalletInterface
-    const checkSub = async (timeout?: number) => {
+    const checkSub = async (timeout?: number): Promise<void> => {
       let result
       if (typeof timeout === 'number') {
         result = await Promise.race([
           sub.getVersion({}),
-          new Promise<never>((_, reject) =>
+          new Promise<never>((_resolve, reject) =>
             setTimeout(() => reject(new Error('Timed out.')), timeout)
           )
         ])
@@ -102,21 +95,25 @@ export default class WalletClient implements WalletInterface {
       await checkSub()
       this.substrate = sub
     } catch (e) {
+      console.error('XDMSubstrate initialization failed:', e) // Log the error
       try {
         sub = new XDMSubstrate()
         await checkSub(MAX_XDM_RESPONSE_WAIT)
         this.substrate = sub
       } catch (e) {
+        console.error('WalletWireTransceiver initialization failed:', e)
         try {
           sub = new WalletWireTransceiver(new HTTPWalletWire(this.originator))
           await checkSub()
           this.substrate = sub
         } catch (e) {
+          console.error('HTTPWalletJSON initialization failed:', e)
           try {
             sub = new HTTPWalletJSON(this.originator)
             await checkSub()
             this.substrate = sub
           } catch (e) {
+            console.error('No wallet available:', e)
             throw new Error(
               'No wallet available over any communication substrate. Install a BSV wallet today!'
             )
@@ -413,7 +410,7 @@ export default class WalletClient implements WalletInterface {
     )
   }
 
-  async isAuthenticated (args: {} = {}): Promise<AuthenticatedResult> {
+  async isAuthenticated (args: object = {}): Promise<AuthenticatedResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).isAuthenticated(
       args,
@@ -421,7 +418,7 @@ export default class WalletClient implements WalletInterface {
     )
   }
 
-  async waitForAuthentication (args: {} = {}): Promise<{ authenticated: true }> {
+  async waitForAuthentication (args: object = {}): Promise<{ authenticated: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).waitForAuthentication(
       args,
@@ -429,7 +426,7 @@ export default class WalletClient implements WalletInterface {
     )
   }
 
-  async getHeight (args: {} = {}): Promise<{ height: PositiveInteger }> {
+  async getHeight (args: object = {}): Promise<{ height: PositiveInteger }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getHeight(
       args,
@@ -447,7 +444,7 @@ export default class WalletClient implements WalletInterface {
     )
   }
 
-  async getNetwork (args: {} = {}): Promise<{ network: 'mainnet' | 'testnet' }> {
+  async getNetwork (args: object = {}): Promise<{ network: 'mainnet' | 'testnet' }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getNetwork(
       args,
@@ -456,7 +453,7 @@ export default class WalletClient implements WalletInterface {
   }
 
   async getVersion (
-    args: {} = {}
+    args: object = {}
   ): Promise<{ version: VersionString7To30Bytes }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getVersion(

package/src/wallet/WalletError.ts

@@ -7,9 +7,9 @@ export class WalletError extends Error {
     this.code = code
     this.name = this.constructor.name
 
-    if (stack) {
+    if (stack !== undefined && stack !== null && stack !== '') {
       this.stack = stack
-    } else if (Error.captureStackTrace) {
+    } else {
       Error.captureStackTrace(this, this.constructor)
     }
   }

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

@@ -20,7 +20,8 @@ describe('CachedKeyDeriver', () => {
 
     // Replace the internal keyDeriver instance with the mocked one
     cachedKeyDeriver = new CachedKeyDeriver(rootKey)
-    ;(cachedKeyDeriver as any).keyDeriver = mockKeyDeriver
+    // @ts-expect-error: Accessing private property for testing purposes
+    cachedKeyDeriver.keyDeriver = mockKeyDeriver
   })
 
   describe('derivePublicKey', () => {
@@ -266,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 as any).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])
@@ -289,7 +290,7 @@ describe('CachedKeyDeriver', () => {
       }
 
       // Cache should be full now
-      expect((cachedKeyDeriver as any).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)
@@ -298,11 +299,11 @@ describe('CachedKeyDeriver', () => {
       cachedKeyDeriver.derivePublicKey(protocolID, 'key5', counterparty)
 
       // Cache size should still be maxCacheSize
-      expect((cachedKeyDeriver as any).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 as any).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'),
@@ -313,8 +314,8 @@ describe('CachedKeyDeriver', () => {
 
     it('should update the recentness of cache entries on access', () => {
       const maxCacheSize = 3
-      cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize })
-      ;(cachedKeyDeriver as any).keyDeriver = mockKeyDeriver
+      cachedKeyDeriver = new CachedKeyDeriver(rootKey, { maxCacheSize });
+      (cachedKeyDeriver as unknown as { keyDeriver: KeyDeriver }).keyDeriver = mockKeyDeriver
 
       const protocolID: [0, string] = [0, 'testprotocol']
       const counterparty = 'self'
@@ -327,7 +328,7 @@ describe('CachedKeyDeriver', () => {
         .mockReturnValueOnce(publicKeys[2])
 
       // Fill the cache
-      keys.forEach(keyID => {
+      keys.forEach((keyID) => {
         cachedKeyDeriver.derivePublicKey(protocolID, keyID, counterparty)
       })
 
@@ -341,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 as any).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')
@@ -359,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

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