@bsv/sdk 1.3.13 → 1.3.14

package/src/auth/utils/__tests/validateCertificates.test.ts

@@ -1,154 +1,164 @@
-import { validateCertificates } from "../../../auth/utils/validateCertificates";
-import { VerifiableCertificate } from "../../../auth/certificates/VerifiableCertificate";
-import { ProtoWallet } from "../../../wallet/index";
-import { PrivateKey } from "../../../primitives/index";
-
-let mockVerify = jest.fn(() => Promise.resolve(true));
-let mockDecryptFields = jest.fn(() =>
-  Promise.resolve({ field1: "decryptedValue1" })
-);
-const mockInstances = [];
-
-jest.mock("../../../auth/certificates/VerifiableCertificate", () => {
+import { validateCertificates } from '../../../auth/utils/validateCertificates'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
+import { ProtoWallet } from '../../../wallet/index'
+import { PrivateKey } from '../../../primitives/index'
+
+let mockVerify = jest.fn(async () => await Promise.resolve(true))
+let mockDecryptFields = jest.fn(
+  async () => await Promise.resolve({ field1: 'decryptedValue1' })
+)
+const mockInstances: Array<{
+  type: string
+  serialNumber: string
+  subject: string
+  certifier: string
+  revocationOutpoint: string
+  fields: Record<string, string>
+  decryptedFields: Record<string, unknown>
+  verify: jest.Mock<Promise<boolean>>
+  decryptFields: jest.Mock<Promise<Record<string, string>>> // ✅ Explicit return type
+}> = []
+
+jest.mock('../../../auth/certificates/VerifiableCertificate', () => {
   return {
     VerifiableCertificate: jest.fn().mockImplementation(() => {
       const instance = {
-        type: "requested_type",
-        serialNumber: "valid_serial",
-        subject: "valid_subject",
-        certifier: "valid_certifier",
-        revocationOutpoint: "outpoint",
-        fields: { field1: "encryptedData1" },
+        type: 'requested_type',
+        serialNumber: 'valid_serial',
+        subject: 'valid_subject',
+        certifier: 'valid_certifier',
+        revocationOutpoint: 'outpoint',
+        fields: { field1: 'encryptedData1' },
         decryptedFields: {},
         verify: mockVerify,
-        decryptFields: mockDecryptFields,
-      };
-      mockInstances.push(instance);
-      return instance;
-    }),
-  };
-});
-
-describe("validateCertificates", () => {
-  let verifierWallet;
-  let message;
+        decryptFields: mockDecryptFields
+      }
+      mockInstances.push(instance)
+      return instance
+    })
+  }
+})
+
+describe('validateCertificates', () => {
+  let verifierWallet
+  let message
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    mockInstances.length = 0; // Clear tracked instances
+    jest.clearAllMocks()
+    mockInstances.length = 0 // Clear tracked instances
 
     // Reset state
-    mockVerify = jest.fn(() => Promise.resolve(true));
-    mockDecryptFields = jest.fn(() =>
-      Promise.resolve({ field1: "decryptedValue1" })
-    );
+    mockVerify = jest.fn(async () => await Promise.resolve(true))
+    mockDecryptFields = jest.fn(
+      async () => await Promise.resolve({ field1: 'decryptedValue1' })
+    )
 
-    verifierWallet = new ProtoWallet(new PrivateKey(1));
+    verifierWallet = new ProtoWallet(new PrivateKey(1))
     message = {
-      identityKey: "valid_subject",
+      identityKey: 'valid_subject',
       certificates: [
         {
-          type: "requested_type",
-          serialNumber: "valid_serial",
-          subject: "valid_subject",
-          certifier: "valid_certifier",
-          revocationOutpoint: "outpoint",
-          fields: { field1: "encryptedData1" },
-          decryptedFields: {},
-        },
-      ],
-    };
-  });
-
-  it("completes without errors for valid input", async () => {
+          type: 'requested_type',
+          serialNumber: 'valid_serial',
+          subject: 'valid_subject',
+          certifier: 'valid_certifier',
+          revocationOutpoint: 'outpoint',
+          fields: { field1: 'encryptedData1' },
+          decryptedFields: {}
+        }
+      ]
+    }
+  })
+
+  it('completes without errors for valid input', async () => {
     await expect(
       validateCertificates(verifierWallet, message)
-    ).resolves.not.toThrow();
+    ).resolves.not.toThrow()
 
     expect(VerifiableCertificate).toHaveBeenCalledTimes(
       message.certificates.length
-    );
-    expect(mockVerify).toHaveBeenCalledTimes(message.certificates.length);
-    expect(mockDecryptFields).toHaveBeenCalledWith(verifierWallet);
-  });
+    )
+    expect(mockVerify).toHaveBeenCalledTimes(message.certificates.length)
+    expect(mockDecryptFields).toHaveBeenCalledWith(verifierWallet)
+  })
 
-  it("throws an error for mismatched identity key", async () => {
-    message.identityKey = "different_subject";
+  it('throws an error for mismatched identity key', async () => {
+    message.identityKey = 'different_subject'
 
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
-      `The subject of one of your certificates ("valid_subject") is not the same as the request sender ("different_subject").`
-    );
-  });
+      'The subject of one of your certificates ("valid_subject") is not the same as the request sender ("different_subject").'
+    )
+  })
 
-  it("throws an error if certificate signature is invalid", async () => {
-    mockVerify.mockResolvedValueOnce(false);
+  it('throws an error if certificate signature is invalid', async () => {
+    mockVerify.mockResolvedValueOnce(false)
 
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
-      `The signature for the certificate with serial number valid_serial is invalid!`
-    );
-  });
+      'The signature for the certificate with serial number valid_serial is invalid!'
+    )
+  })
 
-  it("throws an error for unrequested certifier", async () => {
+  it('throws an error for unrequested certifier', async () => {
     const certificatesRequested = {
-      certifiers: ["another_certifier"],
-      types: { requested_type: ["field1"] },
-    };
+      certifiers: ['another_certifier'],
+      types: { requested_type: ['field1'] }
+    }
 
     await expect(
       validateCertificates(verifierWallet, message, certificatesRequested)
     ).rejects.toThrow(
-      `Certificate with serial number valid_serial has an unrequested certifier: valid_certifier`
-    );
-  });
+      'Certificate with serial number valid_serial has an unrequested certifier: valid_certifier'
+    )
+  })
 
-  it("throws an error for unrequested certificate type", async () => {
+  it('throws an error for unrequested certificate type', async () => {
     const certificatesRequested = {
-      certifiers: ["valid_certifier"],
-      types: { another_type: ["field1"] },
-    };
+      certifiers: ['valid_certifier'],
+      types: { another_type: ['field1'] }
+    }
 
     await expect(
       validateCertificates(verifierWallet, message, certificatesRequested)
-    ).rejects.toThrow(`Certificate with type requested_type was not requested`);
-  });
+    ).rejects.toThrow('Certificate with type requested_type was not requested')
+  })
 
-  it("decrypts fields without throwing errors", async () => {
+  it('decrypts fields without throwing errors', async () => {
     await expect(
       validateCertificates(verifierWallet, message)
-    ).resolves.not.toThrow();
+    ).resolves.not.toThrow()
     for (const instance of mockInstances) {
-      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet);
+      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet)
     }
-  });
+  })
 
-  it("throws an error if a field decryption fails", async () => {
-    mockDecryptFields.mockRejectedValue(new Error("Decryption failed"));
+  it('throws an error if a field decryption fails', async () => {
+    mockDecryptFields.mockRejectedValue(new Error('Decryption failed'))
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
-      "Decryption failed"
-    );
-  });
+      'Decryption failed'
+    )
+  })
 
-  it("handles multiple certificates properly", async () => {
+  it('handles multiple certificates properly', async () => {
     const anotherCertificate = {
-      type: "requested_type",
-      serialNumber: "another_serial",
-      subject: "valid_subject",
-      certifier: "valid_certifier",
-      revocationOutpoint: "outpoint",
-      fields: { field1: "encryptedData1" },
-      decryptedFields: {},
-    };
+      type: 'requested_type',
+      serialNumber: 'another_serial',
+      subject: 'valid_subject',
+      certifier: 'valid_certifier',
+      revocationOutpoint: 'outpoint',
+      fields: { field1: 'encryptedData1' },
+      decryptedFields: {}
+    }
 
-    message.certificates.push(anotherCertificate);
+    message.certificates.push(anotherCertificate)
 
     await expect(
       validateCertificates(verifierWallet, message)
-    ).resolves.not.toThrow();
+    ).resolves.not.toThrow()
 
-    expect(VerifiableCertificate).toHaveBeenCalledTimes(2);
-    expect(mockVerify).toHaveBeenCalledTimes(2);
+    expect(VerifiableCertificate).toHaveBeenCalledTimes(2)
+    expect(mockVerify).toHaveBeenCalledTimes(2)
     for (const instance of mockInstances) {
-      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet);
+      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet)
     }
-  });
-});
+  })
+})

package/src/auth/utils/createNonce.ts

@@ -3,7 +3,7 @@ import {
   Random,
   WalletInterface,
   WalletCounterparty
-} from '../../../mod'
+} from '../../../mod.js'
 
 /**
  * Creates a nonce derived from a wallet

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,6 +1,6 @@
-import { VerifiableCertificate } from '../certificates/VerifiableCertificate'
-import { WalletInterface } from '../../../mod'
-import { RequestedCertificateSet } from '../types'
+import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
+import { WalletInterface } from '../../../mod.js'
+import { RequestedCertificateSet } from '../types.js'
 
 /**
  * Retrieves an array of verifiable certificates based on the request.
@@ -24,7 +24,7 @@ export const getVerifiableCertificates = async (
 
   // For each certificate requested, create a verifiable cert with selectively revealed fields
   return await Promise.all(
-    matchingCertificates.certificates.map(async certificate => {
+    matchingCertificates.certificates.map(async (certificate) => {
       const { keyringForVerifier } = await wallet.proveCertificate({
         certificate,
         fieldsToReveal: requestedCertificates.types[certificate.type],

package/src/auth/utils/index.ts

@@ -1,4 +1,4 @@
-export * from "./verifyNonce";
-export * from "./createNonce";
-export * from "./getVerifiableCertificates";
-export * from "./validateCertificates";
+export * from './verifyNonce.js'
+export * from './createNonce.js'
+export * from './getVerifiableCertificates.js'
+export * from './validateCertificates.js'

package/src/auth/utils/validateCertificates.ts

@@ -1,6 +1,6 @@
-import { WalletInterface } from '../../wallet/index'
-import { AuthMessage, RequestedCertificateSet } from '../types'
-import { VerifiableCertificate } from '../certificates/VerifiableCertificate'
+import { WalletInterface } from '../../wallet/index.js'
+import { AuthMessage, RequestedCertificateSet } from '../types.js'
+import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
 
 /**
  * Validates and processes the certificates received from a peer.
@@ -15,6 +15,10 @@ export const validateCertificates = async (
   message: AuthMessage,
   certificatesRequested?: RequestedCertificateSet
 ): Promise<void> => {
+  if ((message.certificates == null) || message.certificates.length === 0) {
+    throw new Error('No certificates were provided in the AuthMessage.')
+  }
+
   await Promise.all(
     message.certificates.map(async (incomingCert: VerifiableCertificate) => {
       if (incomingCert.subject !== message.identityKey) {
@@ -42,7 +46,7 @@ export const validateCertificates = async (
       }
 
       // Check if the certificate matches requested certifiers, types, and fields
-      if (certificatesRequested) {
+      if (certificatesRequested != null) {
         const { certifiers, types } = certificatesRequested
 
         // Check certifier matches
@@ -54,7 +58,7 @@ export const validateCertificates = async (
 
         // Check type and fields match requested
         const requestedFields = types[certToVerify.type]
-        if (!requestedFields) {
+        if (requestedFields == null) { // ✅ Explicitly check for null or undefined
           throw new Error(
             `Certificate with type ${certToVerify.type} was not requested`
           )

package/src/auth/utils/verifyNonce.ts

@@ -1,4 +1,4 @@
-import { Utils, WalletInterface, WalletCounterparty } from '../../../mod'
+import { Utils, WalletInterface, WalletCounterparty } from '../../../mod.js'
 
 /**
  * Verifies a nonce derived from a wallet

package/src/compat/BSM.ts

@@ -1,10 +1,10 @@
-import BigNumber from '../primitives/BigNumber'
-import { Writer, toArray } from '../primitives/utils'
-import * as ECDSA from '../primitives/ECDSA'
-import * as Hash from '../primitives/Hash'
-import PrivateKey from '../primitives/PrivateKey'
-import PublicKey from '../primitives/PublicKey'
-import Signature from '../primitives/Signature'
+import BigNumber from '../primitives/BigNumber.js'
+import { Writer, toArray } from '../primitives/utils.js'
+import * as ECDSA from '../primitives/ECDSA.js'
+import * as Hash from '../primitives/Hash.js'
+import PrivateKey from '../primitives/PrivateKey.js'
+import PublicKey from '../primitives/PublicKey.js'
+import Signature from '../primitives/Signature.js'
 
 const prefix = 'Bitcoin Signed Message:\n'
 

package/src/compat/ECIES.ts

@@ -1,13 +1,13 @@
 // import { AESWrappercbc } from './aescbc'
-import Random from '../primitives/Random'
-import PrivateKey from '../primitives/PrivateKey'
-import PublicKey from '../primitives/PublicKey'
-import Point from '../primitives/Point'
-import * as Hash from '../primitives/Hash'
-import { toArray, toHex, encode } from '../primitives/utils'
+import Random from '../primitives/Random.js'
+import PrivateKey from '../primitives/PrivateKey.js'
+import PublicKey from '../primitives/PublicKey.js'
+import Point from '../primitives/Point.js'
+import * as Hash from '../primitives/Hash.js'
+import { toArray, toHex, encode } from '../primitives/utils.js'
 
-function AES (key) {
-  if (!this._tables[0][0][0]) this._precompute()
+function AES (key): void {
+  if (this._tables[0][0][0] === 0) this._precompute()
 
   let tmp, encKey, decKey
   const sbox = this._tables[0][4]
@@ -22,7 +22,8 @@ function AES (key) {
   this._key = [(encKey = key.slice(0)), (decKey = [])]
 
   // schedule encryption keys
-  for (var i = keyLen; i < 4 * keyLen + 28; i++) {
+  let i: number
+  for (i = keyLen; i < 4 * keyLen + 28; i++) {
     tmp = encKey[i - 1]
 
     // apply sbox
@@ -44,8 +45,8 @@ function AES (key) {
   }
 
   // schedule decryption keys
-  for (let j = 0; i; j++, i--) {
-    tmp = encKey[j & 3 ? i : i - 4]
+  for (let j = 0; i > 0; j++, i--) {
+    tmp = encKey[(j & 3) !== 0 ? i : i - 4]
     if (i <= 4 || j < 4) {
       decKey[j] = tmp
     } else {
@@ -129,7 +130,7 @@ AES.prototype = {
       th[(d[i] = (i << 1) ^ ((i >> 7) * 283)) ^ i] = i
     }
 
-    for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
+    for (x = xInv = 0; sbox[x] === 0; x ^= (x2 !== 0 ? x2 : 1), xInv = th[xInv] !== 0 ? th[xInv] : 1) {
       // Compute sbox
       s = xInv ^ (xInv << 1) ^ (xInv << 2) ^ (xInv << 3) ^ (xInv << 4)
       s = (s >> 8) ^ (s & 255) ^ 99
@@ -163,9 +164,9 @@ AES.prototype = {
     const key = this._key[dir]
     // state variables a,b,c,d are loaded with pre-whitened data
     let a = input[0] ^ key[0]
-    let b = input[dir ? 3 : 1] ^ key[1]
+    let b = input[dir === 1 ? 3 : 1] ^ key[1]
     let c = input[2] ^ key[2]
-    let d = input[dir ? 1 : 3] ^ key[3]
+    let d = input[dir === 1 ? 1 : 3] ^ key[3]
     let a2
     let b2
     let c2
@@ -218,7 +219,7 @@ AES.prototype = {
 
     // Last round.
     for (i = 0; i < 4; i++) {
-      out[dir ? 3 & -i : i] =
+      out[dir === 1 ? 3 & -i : i] =
         (sbox[a >>> 24] << 24) ^
         (sbox[(b >> 16) & 255] << 16) ^
         (sbox[(c >> 8) & 255] << 8) ^
@@ -235,6 +236,7 @@ AES.prototype = {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class AESWrapper {
   public static encrypt (messageBuf: number[], keyBuf: number[]): number[] {
     const key = AESWrapper.buf2Words(keyBuf)
@@ -255,10 +257,10 @@ class AESWrapper {
   }
 
   public static buf2Words (buf: number[]): number[] {
-    if (buf.length % 4) {
+    if (buf.length % 4 !== 0) {
       throw new Error('buf length must be a multiple of 4')
     }
-    const words = []
+    const words: number[] = []
     for (let i = 0; i < buf.length / 4; i++) {
       const val =
         buf[i * 4] * 0x1000000 + // Shift the first byte by 24 bits
@@ -285,10 +287,11 @@ class AESWrapper {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class CBC {
   public static buf2BlocksBuf (buf: number[], blockSize: number): number[][] {
     const bytesize = blockSize / 8
-    const blockBufs = []
+    const blockBufs: number[][] = []
 
     for (let i = 0; i <= buf.length / bytesize; i++) {
       let blockBuf = buf.slice(i * bytesize, i * bytesize + bytesize)
@@ -338,7 +341,7 @@ class CBC {
     cipherKeyBuf: number[]
   ): number[] {
     const bytesize = ivBuf.length
-    const encBufs = []
+    const encBufs: number[][] = []
     for (let i = 0; i < encBuf.length / bytesize; i++) {
       encBufs.push(encBuf.slice(i * bytesize, i * bytesize + bytesize))
     }
@@ -380,7 +383,7 @@ class CBC {
     blockCipher: any /* TODO: type */,
     cipherKeyBuf: number[]
   ): number[][] {
-    const encBufs = []
+    const encBufs: number[][] = []
 
     for (let i = 0; i < blockBufs.length; i++) {
       const blockBuf = blockBufs[i]
@@ -405,7 +408,7 @@ class CBC {
     blockCipher: any /* TODO: type */,
     cipherKeyBuf: number[]
   ): number[][] {
-    const blockBufs = []
+    const blockBufs: number[][] = []
 
     for (let i = 0; i < encBufs.length; i++) {
       const encBuf = encBufs[i]
@@ -462,6 +465,7 @@ class CBC {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class AESCBC {
   public static encrypt (
     messageBuf: number[],
@@ -469,7 +473,7 @@ class AESCBC {
     ivBuf: number[],
     concatIvBuf = true
   ): number[] {
-    ivBuf = ivBuf || new Array(128 / 8).fill(0) || Random(128 / 8)
+    ivBuf = ivBuf ?? Random(128 / 8)
     const ctBuf = CBC.encrypt(messageBuf, ivBuf, AESWrapper, cipherKeyBuf)
     if (concatIvBuf) {
       return [...ivBuf, ...ctBuf]
@@ -483,7 +487,7 @@ class AESCBC {
     cipherKeyBuf: number[],
     ivBuf?: number[]
   ): number[] {
-    if (!ivBuf) {
+    if (ivBuf == null) {
       ivBuf = encBuf.slice(0, 128 / 8)
       const ctBuf = encBuf.slice(128 / 8)
       return CBC.decrypt(ctBuf, ivBuf, AESWrapper, cipherKeyBuf)
@@ -501,6 +505,7 @@ class AESCBC {
  * @prprecated This class is deprecated in favor of the BRC-78 standard for portable encrypted messages,
  * which provides a more comprehensive and secure solution by integrating with BRC-42 and BRC-43 standards.
  */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export default class ECIES {
   /**
    * Generates the initialization vector (iv), encryption key (kE), and MAC key (kM)
@@ -542,8 +547,8 @@ export default class ECIES {
     fromPrivateKey?: PrivateKey,
     noKey = false
   ): number[] {
-    let Rbuf
-    if (!fromPrivateKey) {
+    let Rbuf: string | number[] | null = null
+    if (fromPrivateKey == null) {
       fromPrivateKey = PrivateKey.fromRandom()
     }
     if (!noKey) {
@@ -553,7 +558,7 @@ export default class ECIES {
     const ciphertext = AESCBC.encrypt(messageBuf, kE, iv, false)
     const BIE1 = toArray('BIE1', 'utf8')
     let encBuf: number[]
-    if (Rbuf) {
+    if (Rbuf !== undefined && Rbuf !== null && Rbuf.length > 0) {
       encBuf = [...BIE1, ...Rbuf, ...ciphertext]
     } else {
       encBuf = [...BIE1, ...ciphertext]
@@ -598,12 +603,12 @@ export default class ECIES {
       }
     }
 
-    if (Rbuf) {
-      if (!fromPublicKey) {
+    if (Rbuf !== null) {
+      if (fromPublicKey == null) {
         fromPublicKey = PublicKey.fromString(toHex(Rbuf))
       }
     } else {
-      if (!fromPublicKey) {
+      if (fromPublicKey == null) {
         throw new Error('Sender public key is required')
       }
     }
@@ -639,9 +644,12 @@ export default class ECIES {
     fromPrivateKey?: PrivateKey,
     ivBuf?: number[]
   ): number[] {
-    if (!fromPrivateKey) {
+    if (fromPrivateKey == null) {
       fromPrivateKey = PrivateKey.fromRandom()
     }
+    if (ivBuf == null) {
+      ivBuf = Random(16)
+    }
     const r = fromPrivateKey
     const RPublicKey = fromPrivateKey.toPublicKey()
     const RBuf = RPublicKey.encode(true) as number[]

package/src/compat/HD.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import {
   fromBase58Check,
   toBase58Check,
@@ -5,13 +6,13 @@ import {
   Reader,
   toArray,
   toHex
-} from '../primitives/utils'
-import * as Hash from '../primitives/Hash'
-import Curve from '../primitives/Curve'
-import PrivateKey from '../primitives/PrivateKey'
-import PublicKey from '../primitives/PublicKey'
-import Random from '../primitives/Random'
-import BigNumber from '../primitives/BigNumber'
+} from '../primitives/utils.js'
+import * as Hash from '../primitives/Hash.js'
+import Curve from '../primitives/Curve.js'
+import PrivateKey from '../primitives/PrivateKey.js'
+import PublicKey from '../primitives/PublicKey.js'
+import Random from '../primitives/Random.js'
+import BigNumber from '../primitives/BigNumber.js'
 
 /**
  * @deprecated
@@ -221,10 +222,8 @@ export default class HD {
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     let bip32: HD = this
-    for (const i in e) {
-      const c = e[i]
-
-      if (i === '0') {
+    for (const [i, c] of e.entries()) {
+      if (i === 0) { // Since `i` is now a number, compare it to 0
         if (c !== 'm') {
           throw new Error('invalid path')
         }
@@ -271,12 +270,12 @@ export default class HD {
 
     const isPrivate = this.versionBytesNum === this.constants.privKey
 
-    if (usePrivate && (!this.privKey || !isPrivate)) {
+    if (usePrivate && (this.privKey === null || this.privKey === undefined || !isPrivate)) {
       throw new Error('Cannot do private key derivation without private key')
     }
 
     let ret = null
-    if (this.privKey) {
+    if (this.privKey !== null && this.privKey !== undefined) {
       let data = null
 
       if (usePrivate) {