@bsv/sdk 2.0.16 → 2.1.1

package/src/compat/ECIES.ts

@@ -9,7 +9,7 @@ import { toArray, toHex, encode } from '../primitives/utils.js'
 function AES (key): void {
   if (this._tables[0][0][0] === 0) this._precompute()
 
-  let tmp, encKey, decKey
+  let tmp
   const sbox = this._tables[0][4]
   const decTable = this._tables[1]
   const keyLen = key.length
@@ -19,7 +19,9 @@ function AES (key): void {
     throw new Error('invalid aes key size')
   }
 
-  this._key = [(encKey = key.slice(0)), (decKey = [])]
+  const encKey = key.slice(0)
+  const decKey = []
+  this._key = [encKey, decKey]
 
   // schedule encryption keys
   let i: number
@@ -46,7 +48,7 @@ function AES (key): void {
 
   // schedule decryption keys
   for (let j = 0; i > 0; j++, i--) {
-    tmp = encKey[(j & 3) !== 0 ? i : i - 4]
+    tmp = encKey[(j & 3) === 0 ? i - 4 : i]
     if (i <= 4 || j < 4) {
       decKey[j] = tmp
     } else {
@@ -127,10 +129,11 @@ AES.prototype = {
 
     // Compute double and third tables
     for (i = 0; i < 256; i++) {
-      th[(d[i] = (i << 1) ^ ((i >> 7) * 283)) ^ i] = i
+      d[i] = (i << 1) ^ ((i >> 7) * 283)
+      th[d[i] ^ i] = i
     }
 
-    for (x = xInv = 0; sbox[x] === 0; x ^= (x2 !== 0 ? x2 : 1), xInv = th[xInv] !== 0 ? th[xInv] : 1) {
+    for (x = xInv = 0; sbox[x] === 0; x ^= (x2 === 0 ? 1 : x2), xInv = th[xInv] === 0 ? 1 : th[xInv]) {
       // Compute sbox
       s = xInv ^ (xInv << 1) ^ (xInv << 2) ^ (xInv << 3) ^ (xInv << 4)
       s = (s >> 8) ^ (s & 255) ^ 99
@@ -138,7 +141,9 @@ AES.prototype = {
       sboxInv[s] = x
 
       // Compute MixColumns
-      x8 = d[(x4 = d[(x2 = d[x])])]
+      x2 = d[x]
+      x4 = d[x2]
+      x8 = d[x4]
       tDec = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
       tEnc = (d[s] * 0x101) ^ (s * 0x1010100)
 
@@ -307,7 +312,7 @@ class CBC {
   }
 
   public static blockBufs2Buf (blockBufs: number[][]): number[] {
-    let last = blockBufs[blockBufs.length - 1]
+    let last = blockBufs.at(-1)
     last = CBC.pkcs7Unpad(last)
     blockBufs[blockBufs.length - 1] = last
 
@@ -319,7 +324,7 @@ class CBC {
   public static encrypt (
     messageBuf: number[],
     ivBuf: number[],
-    blockCipher: any /* TODO: type */,
+    blockCipher: any,
     cipherKeyBuf: number[]
   ): number[] {
     const blockSize = ivBuf.length * 8
@@ -337,7 +342,7 @@ class CBC {
   public static decrypt (
     encBuf: number[],
     ivBuf: number[],
-    blockCipher: any /* TODO: type */,
+    blockCipher: any,
     cipherKeyBuf: number[]
   ): number[] {
     const bytesize = ivBuf.length
@@ -358,7 +363,7 @@ class CBC {
   public static encryptBlock (
     blockBuf: number[],
     ivBuf: number[],
-    blockCipher: any /* TODO: type */,
+    blockCipher: any,
     cipherKeyBuf: number[]
   ): number[] {
     const xorbuf = CBC.xorBufs(blockBuf, ivBuf)
@@ -369,7 +374,7 @@ class CBC {
   public static decryptBlock (
     encBuf: number[],
     ivBuf: number[],
-    blockCipher: any /* TODO: type */,
+    blockCipher: any,
     cipherKeyBuf: number[]
   ): number[] {
     const xorbuf = blockCipher.decrypt(encBuf, cipherKeyBuf)
@@ -380,13 +385,12 @@ class CBC {
   public static encryptBlocks (
     blockBufs: number[][],
     ivBuf: number[],
-    blockCipher: any /* TODO: type */,
+    blockCipher: any,
     cipherKeyBuf: number[]
   ): number[][] {
     const encBufs: number[][] = []
 
-    for (let i = 0; i < blockBufs.length; i++) {
-      const blockBuf = blockBufs[i]
+    for (const blockBuf of blockBufs) {
       const encBuf = CBC.encryptBlock(
         blockBuf,
         ivBuf,
@@ -405,13 +409,12 @@ class CBC {
   public static decryptBlocks (
     encBufs: number[][],
     ivBuf: number[],
-    blockCipher: any /* TODO: type */,
+    blockCipher: any,
     cipherKeyBuf: number[]
   ): number[][] {
     const blockBufs: number[][] = []
 
-    for (let i = 0; i < encBufs.length; i++) {
-      const encBuf = encBufs[i]
+    for (const encBuf of encBufs) {
       const blockBuf = CBC.decryptBlock(
         encBuf,
         ivBuf,
@@ -437,7 +440,7 @@ class CBC {
   }
 
   public static pkcs7Unpad (paddedbuf: number[]): number[] {
-    const padlength = paddedbuf[paddedbuf.length - 1]
+    const padlength = paddedbuf.at(-1)
     const padbuf = paddedbuf.slice(
       paddedbuf.length - padlength,
       paddedbuf.length
@@ -548,9 +551,7 @@ export default class ECIES {
     noKey = false
   ): number[] {
     let Rbuf: string | number[] | null = null
-    if (fromPrivateKey == null) {
-      fromPrivateKey = PrivateKey.fromRandom()
-    }
+    fromPrivateKey ??= PrivateKey.fromRandom()
     if (!noKey) {
       Rbuf = fromPrivateKey.toPublicKey().encode(true)
     }
@@ -603,14 +604,12 @@ export default class ECIES {
       }
     }
 
-    if (Rbuf !== null) {
-      if (fromPublicKey == null) {
-        fromPublicKey = PublicKey.fromString(toHex(Rbuf))
-      }
-    } else {
+    if (Rbuf === null) {
       if (fromPublicKey == null) {
         throw new Error('Sender public key is required')
       }
+    } else {
+      fromPublicKey ??= PublicKey.fromString(toHex(Rbuf))
     }
 
     const { iv, kE, kM } = ECIES.ivkEkM(toPrivateKey, fromPublicKey)
@@ -644,12 +643,8 @@ export default class ECIES {
     fromPrivateKey?: PrivateKey,
     ivBuf?: number[]
   ): number[] {
-    if (fromPrivateKey == null) {
-      fromPrivateKey = PrivateKey.fromRandom()
-    }
-    if (ivBuf == null) {
-      ivBuf = Random(16)
-    }
+    fromPrivateKey ??= PrivateKey.fromRandom()
+    ivBuf ??= Random(16)
     const r = fromPrivateKey
     const RPublicKey = fromPrivateKey.toPublicKey()
     const RBuf = RPublicKey.encode(true) as number[]
@@ -689,8 +684,8 @@ export default class ECIES {
     const kEkM = Hash.sha512(Sbuf)
     const kE = kEkM.slice(0, 32)
     const kM = kEkM.slice(32, 64)
-    const c = encBuf.slice(33, encBuf.length - 32)
-    const d = encBuf.slice(encBuf.length - 32, encBuf.length)
+    const c = encBuf.slice(33, -32)
+    const d = encBuf.slice(-32)
     const d2 = Hash.sha256hmac(kM, c)
     if (toHex(d) !== toHex(d2)) {
       throw new Error('Invalid checksum')

package/src/compat/HD.ts

@@ -230,13 +230,18 @@ export default class HD {
         continue
       }
 
-      if (parseInt(c.replace("'", ''), 10).toString() !== c.replace("'", '')) {
+      const childMatch = /^(\d+)('?)$/.exec(c)
+      if (childMatch === null) {
         throw new Error('invalid path')
       }
 
-      const usePrivate = c.length > 1 && c[c.length - 1] === "'"
-      let childIndex =
-        parseInt(usePrivate ? c.slice(0, c.length - 1) : c, 10) & 0x7fffffff
+      const childIndexValue = Number.parseInt(childMatch[1], 10)
+      if (childIndexValue > 0x7fffffff) {
+        throw new Error('invalid path')
+      }
+
+      const usePrivate = childMatch[2] === "'"
+      let childIndex = childIndexValue
 
       if (usePrivate) {
         childIndex += 0x80000000
@@ -256,7 +261,7 @@ export default class HD {
    */
   public deriveChild (i: number): HD {
     if (typeof i !== 'number') {
-      throw new Error('i must be a number')
+      throw new TypeError('i must be a number')
     }
 
     const ibc: number[] = []

package/src/compat/Mnemonic.ts

@@ -35,12 +35,12 @@ export default class Mnemonic {
    */
   public toBinary (): number[] {
     const bw = new Writer()
-    if (this.mnemonic !== '') {
+    if (this.mnemonic === '') {
+      bw.writeVarIntNum(0)
+    } else {
       const buf = toArray(this.mnemonic, 'utf8')
       bw.writeVarIntNum(buf.length)
       bw.write(buf)
-    } else {
-      bw.writeVarIntNum(0)
     }
     if (this.seed.length > 0) {
       bw.writeVarIntNum(this.seed.length)
@@ -76,7 +76,7 @@ export default class Mnemonic {
    * @throws {Error} If the bit length is not a multiple of 32 or is less than 128.
    */
   public fromRandom (bits?: number): this {
-    if (bits === undefined || bits === null || isNaN(bits) || bits === 0) {
+    if (bits === undefined || bits === null || Number.isNaN(bits) || bits === 0) {
       bits = 128
     }
     if (bits % 32 !== 0) {
@@ -179,8 +179,8 @@ export default class Mnemonic {
     const hash = Hash.sha256(buf)
     let bin = ''
     const bits = buf.length * 8
-    for (let i = 0; i < buf.length; i++) {
-      bin = bin + ('00000000' + buf[i].toString(2)).slice(-8)
+    for (const byte of buf) {
+      bin = bin + ('00000000' + byte.toString(2)).slice(-8)
     }
     let hashbits = hash[0].toString(2)
     hashbits = ('00000000' + hashbits).slice(-8).slice(0, bits / 32)
@@ -198,7 +198,7 @@ export default class Mnemonic {
       if (mnemonic !== '') {
         mnemonic = mnemonic + this.Wordlist.space
       }
-      const wi = parseInt(bin.slice(i * 11, (i + 1) * 11), 2)
+      const wi = Number.parseInt(bin.slice(i * 11, (i + 1) * 11), 2)
       mnemonic = mnemonic + this.Wordlist.value[wi]
     }
 
@@ -218,8 +218,8 @@ export default class Mnemonic {
     // confirm no invalid words
     const words = mnemonic.split(this.Wordlist.space)
     let bin = ''
-    for (let i = 0; i < words.length; i++) {
-      const ind = this.Wordlist.value.indexOf(words[i])
+    for (const word of words) {
+      const ind = this.Wordlist.value.indexOf(word)
       if (ind < 0) {
         return false
       }
@@ -240,7 +240,7 @@ export default class Mnemonic {
     const buf: number[] = []
 
     for (let i = 0; i < nonhashBits.length / 8; i++) {
-      buf.push(parseInt(bin.slice(i * 8, (i + 1) * 8), 2))
+      buf.push(Number.parseInt(bin.slice(i * 8, (i + 1) * 8), 2))
     }
     const hash = Hash.sha256(buf.slice(0, nonhashBits.length / 8))
     let expectedHashBits = hash[0].toString(2)
@@ -266,7 +266,7 @@ export default class Mnemonic {
       )
     }
     if (typeof passphrase !== 'string') {
-      throw new Error('passphrase must be a string or undefined')
+      throw new TypeError('passphrase must be a string or undefined')
     }
     mnemonic = mnemonic.normalize('NFKD')
     passphrase = passphrase.normalize('NFKD')

package/src/compat/__tests/HD.test.ts

@@ -394,6 +394,25 @@ describe('HD', () => {
     })
   })
 
+  describe('#derive path validation', () => {
+    it('should derive mixed hardened and non-hardened path segments', () => {
+      const bip32 = HD.fromString(vector1mPrivate)
+      expect(() => bip32.derive("m/0'/0'/2/3/4'/4")).not.toThrow()
+    })
+
+    it('should reject apostrophes that are not trailing hardening markers', () => {
+      const bip32 = HD.fromString(vector1mPrivate)
+      expect(() => bip32.derive("m/1'2")).toThrow('invalid path')
+      expect(() => bip32.derive("m/1''")).toThrow('invalid path')
+    })
+
+    it('should reject child indexes outside the non-hardened range', () => {
+      const bip32 = HD.fromString(vector1mPrivate)
+      expect(() => bip32.derive('m/2147483648')).toThrow('invalid path')
+      expect(() => bip32.derive("m/2147483648'")).toThrow('invalid path')
+    })
+  })
+
   describe('#toString', () => {
     const bip32 = new HD()
     bip32.fromRandom()