@bsv/sdk 1.3.12 → 1.3.13

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

@@ -1,176 +1,176 @@
-import Mnemonic from '../../../dist/cjs/src/compat/Mnemonic'
-import { wordList as enWordList } from '../../../dist/cjs/src/compat/bip-39-wordlist-en'
-import Random from '../../../dist/cjs/src/primitives/Random'
-import vectors from './Mnemonic.vectors'
-import HD from '../../../dist/cjs/src/compat/HD'
-import { toBase58Check, toHex, toArray } from '../../../dist/cjs/src/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.
     //
     // 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()
-    const addr = toBase58Check(pkh)
-    expect(addr).toEqual('17rxURoF96VhmkcEGCj5LNQkmN9HVhWb7F')
-  })
-
-  it('should generate a mnemonic phrase that passes the check', () => {
-    let mnemonic
+    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;
 
     // 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', () => {
+        "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
     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, () => {
+        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);
+      });
+    });
+  });
+});

package/src/compat/index.ts

@@ -1,5 +1,5 @@
-export * as BSM from './BSM.js'
-export { default as HD } from './HD.js'
-export { default as Mnemonic } from './Mnemonic.js'
-export { default as ECIES } from './ECIES.js'
-export { default as fromUtxo } from './Utxo.js'
+export * as BSM from './BSM'
+export { default as HD } from './HD'
+export { default as Mnemonic } from './Mnemonic'
+export { default as ECIES } from './ECIES'
+export { default as fromUtxo } from './Utxo'

package/src/messages/EncryptedMessage.ts

@@ -1,8 +1,8 @@
-import PublicKey from '../primitives/PublicKey.js'
-import PrivateKey from '../primitives/PrivateKey.js'
-import SymmetricKey from '../primitives/SymmetricKey.js'
-import Random from '../primitives/Random.js'
-import { toBase64, toArray, Reader, toHex } from '../primitives/utils.js'
+import PublicKey from '../primitives/PublicKey'
+import PrivateKey from '../primitives/PrivateKey'
+import SymmetricKey from '../primitives/SymmetricKey'
+import Random from '../primitives/Random'
+import { toBase64, toArray, Reader, toHex } from '../primitives/utils'
 
 const VERSION = '42421033'
 
@@ -55,9 +55,13 @@ export const decrypt = (message: number[], recipient: PrivateKey): number[] => {
   }
   const sender = PublicKey.fromString(toHex(reader.read(33)))
   const expectedRecipientDER = toHex(reader.read(33))
-  const actualRecipientDER = recipient.toPublicKey().encode(true, 'hex') as string
+  const actualRecipientDER = recipient
+    .toPublicKey()
+    .encode(true, 'hex') as string
   if (expectedRecipientDER !== actualRecipientDER) {
-    throw new Error(`The encrypted message expects a recipient public key of ${expectedRecipientDER}, but the provided key is ${actualRecipientDER}`)
+    throw new Error(
+      `The encrypted message expects a recipient public key of ${expectedRecipientDER}, but the provided key is ${actualRecipientDER}`
+    )
   }
   const keyID = toBase64(reader.read(32))
   const encrypted = reader.read(reader.bin.length - reader.pos)

package/src/messages/SignedMessage.ts

@@ -1,9 +1,9 @@
-import PublicKey from '../primitives/PublicKey.js'
-import PrivateKey from '../primitives/PrivateKey.js'
-import Signature from '../primitives/Signature.js'
-import Curve from '../primitives/Curve.js'
-import Random from '../primitives/Random.js'
-import { toBase64, toArray, Reader, toHex } from '../primitives/utils.js'
+import PublicKey from '../primitives/PublicKey'
+import PrivateKey from '../primitives/PrivateKey'
+import Signature from '../primitives/Signature'
+import Curve from '../primitives/Curve'
+import Random from '../primitives/Random'
+import { toBase64, toArray, Reader, toHex } from '../primitives/utils'
 
 const VERSION = '42423301'
 
@@ -25,10 +25,7 @@ export const sign = (
     const curve = new Curve()
     const anyone = new PrivateKey(1)
     const anyonePoint = curve.g.mul(anyone)
-    verifier = new PublicKey(
-      anyonePoint.x,
-      anyonePoint.y
-    )
+    verifier = new PublicKey(anyonePoint.x, anyonePoint.y)
   }
   const keyID = Random(32)
   const keyIDBase64 = toBase64(keyID)
@@ -54,12 +51,16 @@ export const sign = (
  *
  * @returns True if the message is verified.
  */
-export const verify = (message: number[], sig: number[], recipient?: PrivateKey): boolean => {
+export const verify = (
+  message: number[],
+  sig: number[],
+  recipient?: PrivateKey
+): boolean => {
   const reader = new Reader(sig)
   const messageVersion = toHex(reader.read(4))
   if (messageVersion !== VERSION) {
     throw new Error(
-        `Message version mismatch: Expected ${VERSION}, received ${messageVersion}`
+      `Message version mismatch: Expected ${VERSION}, received ${messageVersion}`
     )
   }
   const signer = PublicKey.fromString(toHex(reader.read(33)))
@@ -70,11 +71,15 @@ export const verify = (message: number[], sig: number[], recipient?: PrivateKey)
     const verifierRest = reader.read(32)
     const verifierDER = toHex([verifierFirst, ...verifierRest])
     if (typeof recipient !== 'object') {
-      throw new Error(`This signature can only be verified with knowledge of a specific private key. The associated public key is: ${verifierDER}`)
+      throw new Error(
+        `This signature can only be verified with knowledge of a specific private key. The associated public key is: ${verifierDER}`
+      )
     }
     const recipientDER = recipient.toPublicKey().encode(true, 'hex') as string
     if (verifierDER !== recipientDER) {
-      throw new Error(`The recipient public key is ${recipientDER} but the signature requres the recipient to have public key ${verifierDER}`)
+      throw new Error(
+        `The recipient public key is ${recipientDER} but the signature requres the recipient to have public key ${verifierDER}`
+      )
     }
   }
   const keyID = toBase64(reader.read(32))

package/src/messages/__tests/EncryptedMessage.test.ts

@@ -1,62 +1,61 @@
-import { encrypt, decrypt } from '../../../dist/cjs/src/messages/EncryptedMessage'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import { encrypt, decrypt } from "../../messages/EncryptedMessage";
+import PrivateKey from "../../primitives/PrivateKey";
 
-describe('EncryptedMessage', () => {
-  it('Encrypts a message for a recipient', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const encrypted = encrypt(message, sender, recipientPub)
-    const decrypted = decrypt(encrypted, recipient)
-    expect(decrypted).toEqual(message)
-  })
-  it('Encrypts a message for a recipient with rare key length', () => {
-    const recipient = new PrivateKey(21)
+describe("EncryptedMessage", () => {
+  it("Encrypts a message for a recipient", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const encrypted = encrypt(message, sender, recipientPub);
+    const decrypted = decrypt(encrypted, recipient);
+    expect(decrypted).toEqual(message);
+  });
+  it("Encrypts a message for a recipient with rare key length", () => {
+    const recipient = new PrivateKey(21);
     {
       // Rare length case... Leading zeros in key BigNumber array.
       const encrypted = [
-        66, 66, 16, 51, 2, 215, 146, 77, 79, 125,
-        67, 234, 150, 90, 70, 90, 227, 9, 95, 244,
-        17, 49, 229, 148, 111, 60, 133, 247, 158, 68,
-        173, 188, 248, 226, 126, 8, 14, 2, 53, 43,
-        191, 74, 76, 221, 18, 86, 79, 147, 250, 51,
-        44, 227, 51, 48, 29, 154, 212, 2, 113, 248,
-        16, 113, 129, 52, 10, 239, 37, 190, 89, 213,
+        66, 66, 16, 51, 2, 215, 146, 77, 79, 125, 67, 234, 150, 90, 70, 90, 227,
+        9, 95, 244, 17, 49, 229, 148, 111, 60, 133, 247, 158, 68, 173, 188, 248,
+        226, 126, 8, 14, 2, 53, 43, 191, 74, 76, 221, 18, 86, 79, 147, 250, 51,
+        44, 227, 51, 48, 29, 154, 212, 2, 113, 248, 16, 113, 129, 52, 10, 239,
+        37, 190, 89, 213,
 
-        75, 148, 8, 235, 104, 137, 80, 129, 55, 68,
-        182, 141, 118, 212, 215, 121, 161, 107, 62, 247,
-        12, 172, 244, 170, 208, 37, 213, 198, 103, 118,
-        75, 166, 166, 131, 191, 105, 48, 232, 101, 223,
-        255, 169, 176, 204, 126, 249, 78, 178, 10, 51,
-        13, 163, 58, 232, 122, 111, 210, 218, 187, 247,
-        164, 101, 207, 15, 37, 227, 108, 82, 70, 35,
-        5, 148, 18, 162, 120, 64, 46, 40, 227, 197,
-        6, 112, 207, 200, 238, 81
-      ]
-      expect(() => decrypt(encrypted, recipient)).not.toThrow()
+        75, 148, 8, 235, 104, 137, 80, 129, 55, 68, 182, 141, 118, 212, 215,
+        121, 161, 107, 62, 247, 12, 172, 244, 170, 208, 37, 213, 198, 103, 118,
+        75, 166, 166, 131, 191, 105, 48, 232, 101, 223, 255, 169, 176, 204, 126,
+        249, 78, 178, 10, 51, 13, 163, 58, 232, 122, 111, 210, 218, 187, 247,
+        164, 101, 207, 15, 37, 227, 108, 82, 70, 35, 5, 148, 18, 162, 120, 64,
+        46, 40, 227, 197, 6, 112, 207, 200, 238, 81,
+      ];
+      expect(() => decrypt(encrypted, recipient)).not.toThrow();
     }
-  })
-  it('Fails to decrypt a message with wrong version', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const encrypted = encrypt(message, sender, recipientPub)
-    encrypted[0] = 1
-    expect(() => decrypt(encrypted, recipient)).toThrow(new Error(
-      'Message version mismatch: Expected 42421033, received 01421033'
-    ))
-  })
-  it('Fails to decrypt a message with wrong recipient', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const wrongRecipient = new PrivateKey(22)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const encrypted = encrypt(message, sender, recipientPub)
-    expect(() => decrypt(encrypted, wrongRecipient)).toThrow(new Error(
-      'The encrypted message expects a recipient public key of 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5, but the provided key is 03421f5fc9a21065445c96fdb91c0c1e2f2431741c72713b4b99ddcb316f31e9fc'
-    ))
-  })
-})
+  });
+  it("Fails to decrypt a message with wrong version", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const encrypted = encrypt(message, sender, recipientPub);
+    encrypted[0] = 1;
+    expect(() => decrypt(encrypted, recipient)).toThrow(
+      new Error(
+        "Message version mismatch: Expected 42421033, received 01421033"
+      )
+    );
+  });
+  it("Fails to decrypt a message with wrong recipient", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const wrongRecipient = new PrivateKey(22);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const encrypted = encrypt(message, sender, recipientPub);
+    expect(() => decrypt(encrypted, wrongRecipient)).toThrow(
+      new Error(
+        "The encrypted message expects a recipient public key of 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5, but the provided key is 03421f5fc9a21065445c96fdb91c0c1e2f2431741c72713b4b99ddcb316f31e9fc"
+      )
+    );
+  });
+});