@bsv/sdk 1.3.12 → 1.3.14

package/src/compat/ECIES.ts

@@ -6,8 +6,8 @@ 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]
@@ -19,20 +19,25 @@ function AES (key) {
     throw new Error('invalid aes key size')
   }
 
-  this._key = [encKey = key.slice(0), decKey = []]
+  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
     if (i % keyLen === 0 || (keyLen === 8 && i % keyLen === 4)) {
-      tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255]
+      tmp =
+        (sbox[tmp >>> 24] << 24) ^
+        (sbox[(tmp >> 16) & 255] << 16) ^
+        (sbox[(tmp >> 8) & 255] << 8) ^
+        sbox[tmp & 255]
 
       // shift rows and add rcon
       if (i % keyLen === 0) {
-        tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24
-        rcon = rcon << 1 ^ (rcon >> 7) * 283
+        tmp = (tmp << 8) ^ (tmp >>> 24) ^ (rcon << 24)
+        rcon = (rcon << 1) ^ ((rcon >> 7) * 283)
       }
     }
 
@@ -40,89 +45,117 @@ 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 {
-      decKey[j] = decTable[0][sbox[tmp >>> 24]] ^
-        decTable[1][sbox[tmp >> 16 & 255]] ^
-        decTable[2][sbox[tmp >> 8 & 255]] ^
+      decKey[j] =
+        decTable[0][sbox[tmp >>> 24]] ^
+        decTable[1][sbox[(tmp >> 16) & 255]] ^
+        decTable[2][sbox[(tmp >> 8) & 255]] ^
         decTable[3][sbox[tmp & 255]]
     }
   }
 }
 
 AES.prototype = {
-
   /**
-     * Encrypt an array of 4 big-endian words.
-     * @param {Array} data The plaintext.
-     * @return {Array} The ciphertext.
-     */
-  encrypt: function (data) { return this._crypt(data, 0) },
+   * Encrypt an array of 4 big-endian words.
+   * @param {Array} data The plaintext.
+   * @return {Array} The ciphertext.
+   */
+  encrypt: function (data) {
+    return this._crypt(data, 0)
+  },
 
   /**
-     * Decrypt an array of 4 big-endian words.
-     * @param {Array} data The ciphertext.
-     * @return {Array} The plaintext.
-     */
-  decrypt: function (data) { return this._crypt(data, 1) },
+   * Decrypt an array of 4 big-endian words.
+   * @param {Array} data The ciphertext.
+   * @return {Array} The plaintext.
+   */
+  decrypt: function (data) {
+    return this._crypt(data, 1)
+  },
 
   /**
-     * The expanded S-box and inverse S-box tables.  These will be computed
-     * on the client so that we don't have to send them down the wire.
-     *
-     * There are two tables, _tables[0] is for encryption and
-     * _tables[1] is for decryption.
-     *
-     * The first 4 sub-tables are the expanded S-box with MixColumns.  The
-     * last (_tables[01][4]) is the S-box itself.
-     *
-     * @private
-     */
+   * The expanded S-box and inverse S-box tables.  These will be computed
+   * on the client so that we don't have to send them down the wire.
+   *
+   * There are two tables, _tables[0] is for encryption and
+   * _tables[1] is for decryption.
+   *
+   * The first 4 sub-tables are the expanded S-box with MixColumns.  The
+   * last (_tables[01][4]) is the S-box itself.
+   *
+   * @private
+   */
   _tables: [
-    [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)],
-    [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)]
+    [
+      new Uint32Array(256),
+      new Uint32Array(256),
+      new Uint32Array(256),
+      new Uint32Array(256),
+      new Uint32Array(256)
+    ],
+    [
+      new Uint32Array(256),
+      new Uint32Array(256),
+      new Uint32Array(256),
+      new Uint32Array(256),
+      new Uint32Array(256)
+    ]
   ],
 
   // Expand the S-box tables.
   _precompute: function () {
-    const encTable = this._tables[0]; const decTable = this._tables[1]
-    const sbox = encTable[4]; const sboxInv = decTable[4]
-    let i; let x; let xInv; const d = new Uint8Array(256); const th = new Uint8Array(256); let x2; let x4; let x8; let s; let tEnc; let tDec
+    const encTable = this._tables[0]
+    const decTable = this._tables[1]
+    const sbox = encTable[4]
+    const sboxInv = decTable[4]
+    let i
+    let x
+    let xInv
+    const d = new Uint8Array(256)
+    const th = new Uint8Array(256)
+    let x2
+    let x4
+    let x8
+    let s
+    let tEnc
+    let tDec
 
     // Compute double and third tables
     for (i = 0; i < 256; i++) {
-      th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i
+      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
+      s = xInv ^ (xInv << 1) ^ (xInv << 2) ^ (xInv << 3) ^ (xInv << 4)
+      s = (s >> 8) ^ (s & 255) ^ 99
       sbox[x] = s
       sboxInv[s] = x
 
       // Compute MixColumns
-      x8 = d[x4 = d[x2 = d[x]]]
-      tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100
-      tEnc = d[s] * 0x101 ^ s * 0x1010100
+      x8 = d[(x4 = d[(x2 = d[x])])]
+      tDec = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
+      tEnc = (d[s] * 0x101) ^ (s * 0x1010100)
 
       for (i = 0; i < 4; i++) {
-        encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8
-        decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8
+        encTable[i][x] = tEnc = (tEnc << 24) ^ (tEnc >>> 8)
+        decTable[i][s] = tDec = (tDec << 24) ^ (tDec >>> 8)
       }
     }
   },
 
   /**
-     * Encryption and decryption core.
-     * @param {Array} input Four words to be encrypted or decrypted.
-     * @param dir The direction, 0 for encrypt and 1 for decrypt.
-     * @return {Array} The four encrypted or decrypted words.
-     * @private
-     */
+   * Encryption and decryption core.
+   * @param {Array} input Four words to be encrypted or decrypted.
+   * @param dir The direction, 0 for encrypt and 1 for decrypt.
+   * @return {Array} The four encrypted or decrypted words.
+   * @private
+   */
   _crypt: function (input, dir) {
     if (input.length !== 4) {
       throw new Error('invalid aes block size')
@@ -131,15 +164,18 @@ 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 a2; let b2; let c2
+    let d = input[dir === 1 ? 1 : 3] ^ key[3]
+    let a2
+    let b2
+    let c2
 
     const nInnerRounds = key.length / 4 - 2
     let i
     let kIndex = 4
-    const out = new Uint32Array(4); const // <--- this is slower in Node.js, about the same in Chrome */
+    const out = new Uint32Array(4)
+    const // <--- this is slower in Node, about the same in Chrome */
       table = this._tables[dir]
 
     // load up the tables
@@ -151,33 +187,60 @@ AES.prototype = {
 
     // Inner rounds.  Cribbed from OpenSSL.
     for (i = 0; i < nInnerRounds; i++) {
-      a2 = t0[a >>> 24] ^ t1[b >> 16 & 255] ^ t2[c >> 8 & 255] ^ t3[d & 255] ^ key[kIndex]
-      b2 = t0[b >>> 24] ^ t1[c >> 16 & 255] ^ t2[d >> 8 & 255] ^ t3[a & 255] ^ key[kIndex + 1]
-      c2 = t0[c >>> 24] ^ t1[d >> 16 & 255] ^ t2[a >> 8 & 255] ^ t3[b & 255] ^ key[kIndex + 2]
-      d = t0[d >>> 24] ^ t1[a >> 16 & 255] ^ t2[b >> 8 & 255] ^ t3[c & 255] ^ key[kIndex + 3]
+      a2 =
+        t0[a >>> 24] ^
+        t1[(b >> 16) & 255] ^
+        t2[(c >> 8) & 255] ^
+        t3[d & 255] ^
+        key[kIndex]
+      b2 =
+        t0[b >>> 24] ^
+        t1[(c >> 16) & 255] ^
+        t2[(d >> 8) & 255] ^
+        t3[a & 255] ^
+        key[kIndex + 1]
+      c2 =
+        t0[c >>> 24] ^
+        t1[(d >> 16) & 255] ^
+        t2[(a >> 8) & 255] ^
+        t3[b & 255] ^
+        key[kIndex + 2]
+      d =
+        t0[d >>> 24] ^
+        t1[(a >> 16) & 255] ^
+        t2[(b >> 8) & 255] ^
+        t3[c & 255] ^
+        key[kIndex + 3]
       kIndex += 4
-      a = a2; b = b2; c = c2
+      a = a2
+      b = b2
+      c = c2
     }
 
     // Last round.
     for (i = 0; i < 4; i++) {
-      out[dir ? 3 & -i : i] =
-        sbox[a >>> 24] << 24 ^
-        sbox[b >> 16 & 255] << 16 ^
-        sbox[c >> 8 & 255] << 8 ^
+      out[dir === 1 ? 3 & -i : i] =
+        (sbox[a >>> 24] << 24) ^
+        (sbox[(b >> 16) & 255] << 16) ^
+        (sbox[(c >> 8) & 255] << 8) ^
         sbox[d & 255] ^
         key[kIndex++]
-      a2 = a; a = b; b = c; c = d; d = a2
+      a2 = a
+      a = b
+      b = c
+      c = d
+      d = a2
     }
 
     return out
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class AESWrapper {
   public static encrypt (messageBuf: number[], keyBuf: number[]): number[] {
-    const key = AESWrapper.buf2Words((keyBuf))
-    const message = AESWrapper.buf2Words((messageBuf))
+    const key = AESWrapper.buf2Words(keyBuf)
+    const message = AESWrapper.buf2Words(messageBuf)
     const a = new AES(key)
     const enc = a.encrypt(message)
     const encBuf = AESWrapper.words2Buf(enc)
@@ -185,8 +248,8 @@ class AESWrapper {
   }
 
   public static decrypt (encBuf: number[], keyBuf: number[]): number[] {
-    const enc = AESWrapper.buf2Words((encBuf))
-    const key = AESWrapper.buf2Words((keyBuf))
+    const enc = AESWrapper.buf2Words(encBuf)
+    const key = AESWrapper.buf2Words(keyBuf)
     const a = new AES(key)
     const message = a.decrypt(enc)
     const messageBuf = AESWrapper.words2Buf(message)
@@ -194,13 +257,13 @@ 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
+        buf[i * 4] * 0x1000000 + // Shift the first byte by 24 bits
         ((buf[i * 4 + 1] << 16) | // Shift the second byte by 16 bits
           (buf[i * 4 + 2] << 8) | // Shift the third byte by 8 bits
           buf[i * 4 + 3]) // The fourth byte
@@ -214,20 +277,21 @@ class AESWrapper {
 
     for (let i = 0; i < words.length; i++) {
       const word = words[i]
-      buf[i * 4] = (word >>> 24) & 0xFF
-      buf[i * 4 + 1] = (word >>> 16) & 0xFF
-      buf[i * 4 + 2] = (word >>> 8) & 0xFF
-      buf[i * 4 + 3] = word & 0xFF
+      buf[i * 4] = (word >>> 24) & 0xff
+      buf[i * 4 + 1] = (word >>> 16) & 0xff
+      buf[i * 4 + 2] = (word >>> 8) & 0xff
+      buf[i * 4 + 3] = word & 0xff
     }
 
     return buf
   }
 }
 
+// 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)
@@ -260,7 +324,12 @@ class CBC {
   ): number[] {
     const blockSize = ivBuf.length * 8
     const blockBufs = CBC.buf2BlocksBuf(messageBuf, blockSize)
-    const encBufs = CBC.encryptBlocks(blockBufs, ivBuf, blockCipher, cipherKeyBuf)
+    const encBufs = CBC.encryptBlocks(
+      blockBufs,
+      ivBuf,
+      blockCipher,
+      cipherKeyBuf
+    )
     const encBuf = encBufs.flat()
     return encBuf
   }
@@ -272,11 +341,16 @@ 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))
     }
-    const blockBufs = CBC.decryptBlocks(encBufs, ivBuf, blockCipher, cipherKeyBuf)
+    const blockBufs = CBC.decryptBlocks(
+      encBufs,
+      ivBuf,
+      blockCipher,
+      cipherKeyBuf
+    )
     const buf = CBC.blockBufs2Buf(blockBufs)
     return buf
   }
@@ -309,11 +383,16 @@ 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]
-      const encBuf = CBC.encryptBlock(blockBuf, ivBuf, blockCipher, cipherKeyBuf)
+      const encBuf = CBC.encryptBlock(
+        blockBuf,
+        ivBuf,
+        blockCipher,
+        cipherKeyBuf
+      )
 
       encBufs.push(encBuf)
 
@@ -329,11 +408,16 @@ 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]
-      const blockBuf = CBC.decryptBlock(encBuf, ivBuf, blockCipher, cipherKeyBuf)
+      const blockBuf = CBC.decryptBlock(
+        encBuf,
+        ivBuf,
+        blockCipher,
+        cipherKeyBuf
+      )
 
       blockBufs.push(blockBuf)
 
@@ -354,7 +438,10 @@ class CBC {
 
   public static pkcs7Unpad (paddedbuf: number[]): number[] {
     const padlength = paddedbuf[paddedbuf.length - 1]
-    const padbuf = paddedbuf.slice(paddedbuf.length - padlength, paddedbuf.length)
+    const padbuf = paddedbuf.slice(
+      paddedbuf.length - padlength,
+      paddedbuf.length
+    )
     const padbuf2 = new Array(padlength)
     padbuf2.fill(padlength)
     if (toHex(padbuf) !== toHex(padbuf2)) {
@@ -378,9 +465,15 @@ class CBC {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class AESCBC {
-  public static encrypt (messageBuf: number[], cipherKeyBuf: number[], ivBuf: number[], concatIvBuf = true): number[] {
-    ivBuf = ivBuf || new Array(128 / 8).fill(0) || Random(128 / 8)
+  public static encrypt (
+    messageBuf: number[],
+    cipherKeyBuf: number[],
+    ivBuf: number[],
+    concatIvBuf = true
+  ): number[] {
+    ivBuf = ivBuf ?? Random(128 / 8)
     const ctBuf = CBC.encrypt(messageBuf, ivBuf, AESWrapper, cipherKeyBuf)
     if (concatIvBuf) {
       return [...ivBuf, ...ctBuf]
@@ -389,8 +482,12 @@ class AESCBC {
     }
   }
 
-  public static decrypt (encBuf: number[], cipherKeyBuf: number[], ivBuf?: number[]): number[] {
-    if (!ivBuf) {
+  public static decrypt (
+    encBuf: number[],
+    cipherKeyBuf: number[],
+    ivBuf?: number[]
+  ): number[] {
+    if (ivBuf == null) {
       ivBuf = encBuf.slice(0, 128 / 8)
       const ctBuf = encBuf.slice(128 / 8)
       return CBC.decrypt(ctBuf, ivBuf, AESWrapper, cipherKeyBuf)
@@ -408,16 +505,20 @@ 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)
-     * using the sender's private key and receiver's public key.
-     *
-     * @param {PrivateKey} privKey - The sender's private key.
-     * @param {PublicKey} pubKey - The receiver's public key.
-     * @returns {Object} An object containing the iv, kE, and kM as number arrays.
-     */
-  public static ivkEkM (privKey: PrivateKey, pubKey: PublicKey): { iv: number[], kE: number[], kM: number[] } {
+   * Generates the initialization vector (iv), encryption key (kE), and MAC key (kM)
+   * using the sender's private key and receiver's public key.
+   *
+   * @param {PrivateKey} privKey - The sender's private key.
+   * @param {PublicKey} pubKey - The receiver's public key.
+   * @returns {Object} An object containing the iv, kE, and kM as number arrays.
+   */
+  public static ivkEkM (
+    privKey: PrivateKey,
+    pubKey: PublicKey
+  ): { iv: number[], kE: number[], kM: number[] } {
     const r = privKey
     const KB = pubKey
     const P = KB.mul(r)
@@ -432,17 +533,22 @@ export default class ECIES {
   }
 
   /**
-     * Encrypts a given message using the Electrum ECIES method.
-     *
-     * @param {number[]} messageBuf - The message to be encrypted, in number array format.
-     * @param {PublicKey} toPublicKey - The public key of the recipient.
-     * @param {PrivateKey} [fromPrivateKey] - The private key of the sender. If not provided, a random private key is used.
-     * @param {boolean} [noKey=false] - If true, does not include the sender's public key in the encrypted message.
-     * @returns {number[]} The encrypted message as a number array.
-     */
-  public static electrumEncrypt (messageBuf: number[], toPublicKey: PublicKey, fromPrivateKey?: PrivateKey, noKey = false): number[] {
-    let Rbuf
-    if (!fromPrivateKey) {
+   * Encrypts a given message using the Electrum ECIES method.
+   *
+   * @param {number[]} messageBuf - The message to be encrypted, in number array format.
+   * @param {PublicKey} toPublicKey - The public key of the recipient.
+   * @param {PrivateKey} [fromPrivateKey] - The private key of the sender. If not provided, a random private key is used.
+   * @param {boolean} [noKey=false] - If true, does not include the sender's public key in the encrypted message.
+   * @returns {number[]} The encrypted message as a number array.
+   */
+  public static electrumEncrypt (
+    messageBuf: number[],
+    toPublicKey: PublicKey,
+    fromPrivateKey?: PrivateKey,
+    noKey = false
+  ): number[] {
+    let Rbuf: string | number[] | null = null
+    if (fromPrivateKey == null) {
       fromPrivateKey = PrivateKey.fromRandom()
     }
     if (!noKey) {
@@ -452,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]
@@ -462,14 +568,18 @@ export default class ECIES {
   }
 
   /**
-     * Decrypts a message encrypted using the Electrum ECIES method.
-     *
-     * @param {number[]} encBuf - The encrypted message buffer.
-     * @param {PrivateKey} toPrivateKey - The private key of the recipient.
-     * @param {PublicKey} [fromPublicKey=null] - The public key of the sender. If not provided, it is extracted from the message.
-     * @returns {number[]} The decrypted message as a number array.
-     */
-  public static electrumDecrypt (encBuf: number[], toPrivateKey: PrivateKey, fromPublicKey?: PublicKey): number[] {
+   * Decrypts a message encrypted using the Electrum ECIES method.
+   *
+   * @param {number[]} encBuf - The encrypted message buffer.
+   * @param {PrivateKey} toPrivateKey - The private key of the recipient.
+   * @param {PublicKey} [fromPublicKey=null] - The public key of the sender. If not provided, it is extracted from the message.
+   * @returns {number[]} The decrypted message as a number array.
+   */
+  public static electrumDecrypt (
+    encBuf: number[],
+    toPrivateKey: PrivateKey,
+    fromPublicKey?: PublicKey
+  ): number[] {
     const tagLength = 32
 
     const magic = encBuf.slice(0, 4)
@@ -493,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')
       }
     }
@@ -507,7 +617,10 @@ export default class ECIES {
     const ciphertext = encBuf.slice(offset, encBuf.length - tagLength)
     const hmac = encBuf.slice(encBuf.length - tagLength, encBuf.length)
 
-    const hmac2 = Hash.sha256hmac(kM, encBuf.slice(0, encBuf.length - tagLength))
+    const hmac2 = Hash.sha256hmac(
+      kM,
+      encBuf.slice(0, encBuf.length - tagLength)
+    )
 
     if (toHex(hmac) !== toHex(hmac2)) {
       throw new Error('Invalid checksum')
@@ -517,18 +630,26 @@ export default class ECIES {
   }
 
   /**
-     * Encrypts a given message using the Bitcore variant of ECIES.
-     *
-     * @param {number[]} messageBuf - The message to be encrypted, in number array format.
-     * @param {PublicKey} toPublicKey - The public key of the recipient.
-     * @param {PrivateKey} [fromPrivateKey] - The private key of the sender. If not provided, a random private key is used.
-     * @param {number[]} [ivBuf] - The initialization vector for encryption. If not provided, a random IV is used.
-     * @returns {number[]} The encrypted message as a number array.
-     */
-  public static bitcoreEncrypt (messageBuf: number[], toPublicKey: PublicKey, fromPrivateKey?: PrivateKey, ivBuf?: number[]): number[] {
-    if (!fromPrivateKey) {
+   * Encrypts a given message using the Bitcore variant of ECIES.
+   *
+   * @param {number[]} messageBuf - The message to be encrypted, in number array format.
+   * @param {PublicKey} toPublicKey - The public key of the recipient.
+   * @param {PrivateKey} [fromPrivateKey] - The private key of the sender. If not provided, a random private key is used.
+   * @param {number[]} [ivBuf] - The initialization vector for encryption. If not provided, a random IV is used.
+   * @returns {number[]} The encrypted message as a number array.
+   */
+  public static bitcoreEncrypt (
+    messageBuf: number[],
+    toPublicKey: PublicKey,
+    fromPrivateKey?: PrivateKey,
+    ivBuf?: number[]
+  ): number[] {
+    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[]
@@ -546,13 +667,16 @@ export default class ECIES {
   }
 
   /**
-     * Decrypts a message encrypted using the Bitcore variant of ECIES.
-     *
-     * @param {number[]} encBuf - The encrypted message buffer.
-     * @param {PrivateKey} toPrivateKey - The private key of the recipient.
-     * @returns {number[]} The decrypted message as a number array.
-     */
-  public static bitcoreDecrypt (encBuf: number[], toPrivateKey: PrivateKey): number[] {
+   * Decrypts a message encrypted using the Bitcore variant of ECIES.
+   *
+   * @param {number[]} encBuf - The encrypted message buffer.
+   * @param {PrivateKey} toPrivateKey - The private key of the recipient.
+   * @returns {number[]} The decrypted message as a number array.
+   */
+  public static bitcoreDecrypt (
+    encBuf: number[],
+    toPrivateKey: PrivateKey
+  ): number[] {
     const kB = toPrivateKey
     const fromPublicKey = PublicKey.fromString(toHex(encBuf.slice(0, 33)))
     const R = fromPublicKey