@bsv/sdk 1.3.13 → 1.3.15

package/src/compat/Mnemonic.ts

@@ -1,7 +1,7 @@
-import { wordList } from './bip-39-wordlist-en'
-import { encode, toArray, Reader, Writer } from '../primitives/utils'
-import * as Hash from '../primitives/Hash'
-import Random from '../primitives/Random'
+import { wordList } from './bip-39-wordlist-en.js'
+import { encode, toArray, Reader, Writer } from '../primitives/utils.js'
+import * as Hash from '../primitives/Hash.js'
+import Random from '../primitives/Random.js'
 
 /**
  * @class Mnemonic
@@ -24,8 +24,8 @@ export default class Mnemonic {
    * @param {object} [wordlist=wordList] - An object containing a list of words and space character used in the mnemonic.
    */
   constructor (mnemonic?: string, seed?: number[], wordlist = wordList) {
-    this.mnemonic = mnemonic
-    this.seed = seed
+    this.mnemonic = mnemonic ?? '' // Default to empty string if undefined
+    this.seed = seed ?? [] // Default to empty array if undefined
     this.Wordlist = wordlist
   }
 
@@ -35,14 +35,14 @@ export default class Mnemonic {
    */
   public toBinary (): number[] {
     const bw = new Writer()
-    if (this.mnemonic) {
+    if (this.mnemonic !== '') {
       const buf = toArray(this.mnemonic, 'utf8')
       bw.writeVarIntNum(buf.length)
       bw.write(buf)
     } else {
       bw.writeVarIntNum(0)
     }
-    if (this.seed) {
+    if (this.seed.length > 0) {
       bw.writeVarIntNum(this.seed.length)
       bw.write(this.seed)
     } else {
@@ -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) {
+    if (bits === undefined || bits === null || isNaN(bits) || bits === 0) {
       bits = 128
     }
     if (bits % 32 !== 0) {
@@ -189,7 +189,7 @@ export default class Mnemonic {
     if (bin.length % 11 !== 0) {
       throw new Error(
         'internal error - entropy not an even multiple of 11 bits - ' +
-          bin.length
+        bin.length.toString()
       )
     }
 
@@ -229,7 +229,7 @@ export default class Mnemonic {
     if (bin.length % 11 !== 0) {
       throw new Error(
         'internal error - entropy not an even multiple of 11 bits - ' +
-          bin.length
+        bin.length.toString()
       )
     }
 
@@ -237,7 +237,8 @@ export default class Mnemonic {
     const cs = bin.length / 33
     const hashBits = bin.slice(-cs)
     const nonhashBits = bin.slice(0, bin.length - cs)
-    const buf = []
+    const buf: number[] = []
+
     for (let i = 0; i < nonhashBits.length / 8; i++) {
       buf.push(parseInt(bin.slice(i * 8, (i + 1) * 8), 2))
     }
@@ -287,8 +288,9 @@ export default class Mnemonic {
   public isValid (passphrase = ''): boolean {
     let isValid
     try {
-      isValid = !!this.mnemonic2Seed(passphrase)
-    } catch (err) {
+      this.mnemonic2Seed(passphrase)
+      isValid = true
+    } catch {
       isValid = false
     }
     return isValid

package/src/compat/Utxo.ts

@@ -1,7 +1,7 @@
-import Transaction from '../transaction/Transaction'
-import TransactionInput from '../transaction/TransactionInput'
-import LockingScript from '../script/LockingScript'
-import UnlockingScript from '../script/UnlockingScript'
+import Transaction from '../transaction/Transaction.js'
+import TransactionInput from '../transaction/TransactionInput.js'
+import LockingScript from '../script/LockingScript.js'
+import UnlockingScript from '../script/UnlockingScript.js'
 
 interface jsonUtxo {
   txid: string

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

@@ -16,16 +16,18 @@ describe('BSM', () => {
   describe('sign', () => {
     const messageBuf = toArray('this is my message', 'utf8')
     const privateKey = new PrivateKey(42)
+
     it('should return a signature', () => {
       const sig = sign(messageBuf, privateKey, 'raw')
 
-      if (typeof sig !== 'string' && sig.toDER) {
+      if (sig instanceof Signature) { // ✅ Explicitly check if `sig` is a Signature instance
         const derSignature = sig.toDER()
         expect(derSignature.length).toEqual(70)
       } else {
-        throw new Error('Expected a Signature object, but got a string')
+        throw new Error('Expected a Signature object, but got a different type')
       }
     })
+
     it('Creates the correct base64 signature', () => {
       const privateKey = PrivateKey.fromWif(
         'L211enC224G1kV8pyyq7bjVd9SxZebnRYEzzM3i7ZHCc1c5E7dQu'
@@ -71,10 +73,7 @@ describe('BSM', () => {
       const msgHash = new BigNumber(magicHash(message))
       const recovery = signature.CalculateRecoveryFactor(publicKey, msgHash)
       expect(recovery).toBe(1)
-      const recoveredPubkey = signature.RecoverPublicKey(
-        recovery,
-        msgHash
-      ) as PublicKey
+      const recoveredPubkey = signature.RecoverPublicKey(recovery, msgHash)
       expect(recoveredPubkey.toDER()).toEqual(publicKey.toDER())
     })
   })

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

@@ -60,9 +60,9 @@ describe('HD', () => {
   const vector2m02147483647h12147483646h2Private =
     'xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j'
 
-  it('should make a new a bip32', () => {
-    let bip32
-    bip32 = new HD()
+  it('should make a new bip32', () => {
+    const bip32 = new HD() // ✅ Use `const` instead of `let`
+
     expect(bip32).toBeDefined()
     expect(HD.fromString(vector1mPrivate).toString()).toEqual(vector1mPrivate)
     expect(
@@ -179,7 +179,9 @@ describe('HD', () => {
     const childPub = HD.fromString(child.toPublic().toString())
     const child2 = childPub.derive('m/1000000000')
     expect(child2).toBeDefined()
-    expect(child2.toPublic().toString()).toEqual(vector1m0h12h21000000000Public)
+    expect(child2.toPublic().toString()).toEqual(
+      vector1m0h12h21000000000Public
+    )
   })
 
   it('should initialize test vector 2 from the extended public key', () => {

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

@@ -1,21 +1,21 @@
-import Mnemonic from "../Mnemonic";
-import { wordList as enWordList } from "../bip-39-wordlist-en";
-import Random from "../../primitives/Random";
-import vectors from "./Mnemonic.vectors";
-import HD from "../HD";
-import { toBase58Check, toHex, toArray } from "../../primitives/utils";
-
-describe("Mnemonic", function () {
-  it("should initialize the class", () => {
-    expect(Mnemonic).toBeDefined();
-    expect(new Mnemonic()).toBeDefined();
-  });
-
-  it("should have a wordlist of length 2048", () => {
-    expect(enWordList.value.length).toEqual(2048);
-  });
-
-  it("should handle this community-derived test vector", () => {
+import Mnemonic from '../Mnemonic'
+import { wordList as enWordList } from '../bip-39-wordlist-en'
+import Random from '../../primitives/Random'
+import vectors from './Mnemonic.vectors'
+import HD from '../HD'
+import { toBase58Check, toHex, toArray } from '../../primitives/utils'
+
+describe('Mnemonic', function () {
+  it('should initialize the class', () => {
+    expect(Mnemonic).toBeDefined()
+    expect(new Mnemonic()).toBeDefined()
+  })
+
+  it('should have a wordlist of length 2048', () => {
+    expect(enWordList.value.length).toEqual(2048)
+  })
+
+  it('should handle this community-derived test vector', () => {
     // There was a bug in Copay and bip32jp about deriving addresses with Mnemonic
     // and bip44. This confirms we are handling the situation correctly and
     // derive the correct value.
@@ -23,154 +23,153 @@ describe("Mnemonic", function () {
     // More information here:
     // https://github.com/iancoleman/bip39/issues/58
     const seed = Mnemonic.fromString(
-      "fruit wave dwarf banana earth journey tattoo true farm silk olive fence"
-    ).toSeed("banana");
-    let bip32 = HD.fromSeed(seed);
-    bip32 = bip32.derive("m/44'/0'/0'/0/0");
-    const pkh = bip32.pubKey.toHash() as number[];
-    const addr = toBase58Check(pkh);
-    expect(addr).toEqual("17rxURoF96VhmkcEGCj5LNQkmN9HVhWb7F");
-  });
-
-  it("should generate a mnemonic phrase that passes the check", () => {
-    let mnemonic;
+      'fruit wave dwarf banana earth journey tattoo true farm silk olive fence'
+    ).toSeed('banana')
+    let bip32 = HD.fromSeed(seed)
+    bip32 = bip32.derive("m/44'/0'/0'/0/0")
+    const pkh = bip32.pubKey.toHash() as number[]
+    const addr = toBase58Check(pkh)
+    expect(addr).toEqual('17rxURoF96VhmkcEGCj5LNQkmN9HVhWb7F')
+  })
+
+  it('should generate a mnemonic phrase that passes the check', () => {
+    let mnemonic: string
 
     // should be able to make a mnemonic with or without the default wordlist
-    let m = new Mnemonic().fromRandom(128);
-    expect(m.check()).toEqual(true);
-    m = new Mnemonic().fromRandom(128);
-    expect(m.check()).toEqual(true);
+    let m = new Mnemonic().fromRandom(128)
+    expect(m.check()).toEqual(true)
+    m = new Mnemonic().fromRandom(128)
+    expect(m.check()).toEqual(true)
 
-    const entropy = Array(32);
-    entropy.fill(0);
-    m = new Mnemonic().fromEntropy(entropy);
-    expect(m.check()).toEqual(true);
+    const entropy = Array(32)
+    entropy.fill(0)
+    m = new Mnemonic().fromEntropy(entropy)
+    expect(m.check()).toEqual(true)
 
-    mnemonic = m.mnemonic;
+    mnemonic = m.mnemonic
 
     // mnemonics with extra whitespace do not pass the check
-    m = new Mnemonic().fromString(mnemonic + " ");
-    expect(m.check()).toEqual(false);
+    m = new Mnemonic().fromString(mnemonic + ' ')
+    expect(m.check()).toEqual(false)
 
     // mnemonics with a word replaced do not pass the check
-    const words = mnemonic.split(" ");
-    expect(words[words.length - 1]).not.toEqual("zoo");
-    words[words.length - 1] = "zoo";
-    mnemonic = words.join(" ");
-    expect(new Mnemonic().fromString(mnemonic).check()).toEqual(false);
-  });
-
-  describe("#toBinary", () => {
-    it("should convert to a binary array", () => {
-      const m = new Mnemonic().fromRandom();
-      expect(m.seed).toBeDefined();
-      expect(m.mnemonic).toBeDefined();
-      const buf = m.toBinary();
-      expect(buf.length).toBeGreaterThan(512 / 8 + 1 + 1);
-    });
-  });
-
-  describe("#fromBinary", () => {
-    it("should convert from a binary array", () => {
-      const mA = new Mnemonic().fromRandom();
-      const mB = new Mnemonic().fromBinary(mA.toBinary());
-      expect(mA.mnemonic).toEqual(mB.mnemonic);
-      expect(toHex(mA.seed)).toEqual(toHex(mB.seed));
-    });
-  });
-
-  describe("#fromRandom", () => {
-    it("should throw an error if bits is too low", () => {
+    const words = mnemonic.split(' ')
+    expect(words[words.length - 1]).not.toEqual('zoo')
+    words[words.length - 1] = 'zoo'
+    mnemonic = words.join(' ')
+    expect(new Mnemonic().fromString(mnemonic).check()).toEqual(false)
+  })
+
+  describe('#toBinary', () => {
+    it('should convert to a binary array', () => {
+      const m = new Mnemonic().fromRandom()
+      expect(m.seed).toBeDefined()
+      expect(m.mnemonic).toBeDefined()
+      const buf = m.toBinary()
+      expect(buf.length).toBeGreaterThan(512 / 8 + 1 + 1)
+    })
+  })
+
+  describe('#fromBinary', () => {
+    it('should convert from a binary array', () => {
+      const mA = new Mnemonic().fromRandom()
+      const mB = new Mnemonic().fromBinary(mA.toBinary())
+      expect(mA.mnemonic).toEqual(mB.mnemonic)
+      expect(toHex(mA.seed)).toEqual(toHex(mB.seed))
+    })
+  })
+
+  describe('#fromRandom', () => {
+    it('should throw an error if bits is too low', () => {
       expect(() => {
-        new Mnemonic().fromRandom(127);
-      }).toThrow("bits must be multiple of 32");
-    });
+        new Mnemonic().fromRandom(127)
+      }).toThrow('bits must be multiple of 32')
+    })
 
-    it("should throw an error if bits is not a multiple of 32", () => {
+    it('should throw an error if bits is not a multiple of 32', () => {
       expect(() => {
-        new Mnemonic().fromRandom(256 - 1);
-      }).toThrow("bits must be multiple of 32");
-    });
-  });
+        new Mnemonic().fromRandom(256 - 1)
+      }).toThrow('bits must be multiple of 32')
+    })
+  })
 
-  describe("@fromRandom", () => {
-    it("should throw an error if bits is too low", () => {
+  describe('@fromRandom', () => {
+    it('should throw an error if bits is too low', () => {
       expect(() => {
-        Mnemonic.fromRandom(127);
-      }).toThrow("bits must be multiple of 32");
-    });
+        Mnemonic.fromRandom(127)
+      }).toThrow('bits must be multiple of 32')
+    })
 
-    it("should throw an error if bits is not a multiple of 32", () => {
+    it('should throw an error if bits is not a multiple of 32', () => {
       expect(() => {
-        Mnemonic.fromRandom(256 - 1);
-      }).toThrow("bits must be multiple of 32");
-    });
-  });
-
-  describe("#fromEntropy", () => {
-    it("should build from entropy", () => {
-      const m = new Mnemonic().fromEntropy(Random(32));
-      expect(m).toBeDefined();
-    });
-  });
-
-  describe("@fromEntropy", () => {
-    it("should build from entropy", () => {
-      const m = Mnemonic.fromEntropy(Random(32));
-      expect(m).toBeDefined();
-    });
-  });
-
-  describe("#entropy2Mnemonic", () => {
-    it("should throw an error if you do not use enough entropy", () => {
-      const buf = Buffer.alloc(128 / 8 - 1);
-      buf.fill(0);
+        Mnemonic.fromRandom(256 - 1)
+      }).toThrow('bits must be multiple of 32')
+    })
+  })
+
+  describe('#fromEntropy', () => {
+    it('should build from entropy', () => {
+      const m = new Mnemonic().fromEntropy(Random(32))
+      expect(m).toBeDefined()
+    })
+  })
+
+  describe('@fromEntropy', () => {
+    it('should build from entropy', () => {
+      const m = Mnemonic.fromEntropy(Random(32))
+      expect(m).toBeDefined()
+    })
+  })
+
+  describe('#entropy2Mnemonic', () => {
+    it('should throw an error if you do not use enough entropy', () => {
+      const buf = Buffer.alloc(128 / 8 - 1)
+      buf.fill(0)
       expect(() => {
-        new Mnemonic().entropy2Mnemonic([...buf]);
-      }).toThrow("Entropy is less than 128 bits. It must be 128 bits or more.");
-    });
-  });
+        new Mnemonic().entropy2Mnemonic([...buf])
+      }).toThrow('Entropy is less than 128 bits. It must be 128 bits or more.')
+    })
+  })
 
-  describe("#fromString", () => {
-    it("should throw an error in invalid mnemonic", () => {
+  describe('#fromString', () => {
+    it('should throw an error in invalid mnemonic', () => {
       expect(() => {
-        new Mnemonic().fromString("invalid mnemonic").toSeed();
+        new Mnemonic().fromString('invalid mnemonic').toSeed()
       }).toThrow(
-        "Mnemonic does not pass the check - was the mnemonic typed incorrectly? Are there extra spaces?"
-      );
-    });
-  });
+        'Mnemonic does not pass the check - was the mnemonic typed incorrectly? Are there extra spaces?'
+      )
+    })
+  })
 
-  describe("@isValid", () => {
-    it("should know this is valid", () => {
+  describe('@isValid', () => {
+    it('should know this is valid', () => {
       const isValid = Mnemonic.isValid(
-        "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-        "TREZOR"
-      );
-      expect(isValid).toBe(true);
-    });
+        'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+        'TREZOR'
+      )
+      expect(isValid).toBe(true)
+    })
 
-    it("should know this is invalid", () => {
+    it('should know this is invalid', () => {
       const isValid = Mnemonic.isValid(
-        "abandonnnnnnn abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-        "TREZOR"
-      );
-      expect(isValid).toEqual(false);
-    });
-  });
-
-  describe("vectors", () => {
-    // eslint-disable-next-line ban/ban
+        'abandonnnnnnn abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+        'TREZOR'
+      )
+      expect(isValid).toEqual(false)
+    })
+  })
+
+  describe('vectors', () => {
     vectors.english.forEach((vector, v) => {
-      it("should pass english test vector " + v, () => {
-        const entropy = toArray(vector.entropy, "hex");
-        const m = new Mnemonic().fromEntropy(entropy);
-        expect(m.toString()).toEqual(vector.mnemonic);
-        expect(m.check()).toEqual(true);
-        const seed = m.toSeed(vector.passphrase);
-        expect(toHex(seed)).toEqual(vector.seed);
-        expect(HD.fromSeed(seed).toString()).toEqual(vector.bip32_xprv);
-      });
-    });
-  });
-});
+      it('should pass english test vector ' + v.toString(), () => {
+        const entropy = toArray(vector.entropy, 'hex')
+        const m = new Mnemonic().fromEntropy(entropy)
+        expect(m.toString()).toEqual(vector.mnemonic)
+        expect(m.check()).toEqual(true)
+        const seed = m.toSeed(vector.passphrase)
+        expect(toHex(seed)).toEqual(vector.seed)
+        expect(HD.fromSeed(seed).toString()).toEqual(vector.bip32_xprv)
+      })
+    })
+  })
+})