@bsv/sdk 1.3.12 → 1.3.14

package/src/primitives/__tests/Writer.test.ts

@@ -1,5 +1,5 @@
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-import { Reader, Writer, encode } from '../../../dist/cjs/src/primitives/utils'
+import BigNumber from '../../primitives/BigNumber'
+import { Reader, Writer, encode } from '../../primitives/utils'
 
 describe('Writer', () => {
   it('should create a new buffer writer', () => {
@@ -8,10 +8,10 @@ describe('Writer', () => {
   })
 
   describe('#getLength', () => {
-    it('should compute length correctly of two 2 byte buffers', () => {
+    it('should compute length correctly of two 2-byte buffers', () => {
       const buf1 = Buffer.from('0000', 'hex')
       const buf2 = Buffer.from('0000', 'hex')
-      const bw = new Writer().write(buf1).write(buf2)
+      const bw = new Writer().write([...buf1]).write([...buf2])
       expect(bw.getLength()).toEqual(4)
     })
   })
@@ -54,9 +54,7 @@ describe('Writer', () => {
     it('should write 1', () => {
       const bw = new Writer()
       expect(encode(bw.writeInt8(1).toArray(), 'hex')).toEqual('01')
-      expect(
-        encode(new Writer().writeInt8(-1).toArray(), 'hex')
-      ).toEqual('ff')
+      expect(encode(new Writer().writeInt8(-1).toArray(), 'hex')).toEqual('ff')
     })
   })
 
@@ -71,7 +69,9 @@ describe('Writer', () => {
     it('should write 1', () => {
       const bw = new Writer()
       expect(encode(bw.writeInt16BE(1).toArray(), 'hex')).toEqual('0001')
-      expect(encode(new Writer().writeInt16BE(-1).toArray(), 'hex')).toEqual('ffff')
+      expect(encode(new Writer().writeInt16BE(-1).toArray(), 'hex')).toEqual(
+        'ffff'
+      )
     })
   })
 
@@ -86,7 +86,9 @@ describe('Writer', () => {
     it('should write 1', () => {
       const bw = new Writer()
       expect(encode(bw.writeInt16LE(1).toArray(), 'hex')).toEqual('0100')
-      expect(encode(new Writer().writeInt16LE(-1).toArray(), 'hex')).toEqual('ffff')
+      expect(encode(new Writer().writeInt16LE(-1).toArray(), 'hex')).toEqual(
+        'ffff'
+      )
     })
   })
 
@@ -101,7 +103,9 @@ describe('Writer', () => {
     it('should write 1', () => {
       const bw = new Writer()
       expect(encode(bw.writeInt32BE(1).toArray(), 'hex')).toEqual('00000001')
-      expect(encode(new Writer().writeInt32BE(-1).toArray(), 'hex')).toEqual('ffffffff')
+      expect(encode(new Writer().writeInt32BE(-1).toArray(), 'hex')).toEqual(
+        'ffffffff'
+      )
     })
   })
 
@@ -116,21 +120,27 @@ describe('Writer', () => {
     it('should write 1', () => {
       const bw = new Writer()
       expect(encode(bw.writeInt32LE(1).toArray(), 'hex')).toEqual('01000000')
-      expect(encode(new Writer().writeInt32LE(-1).toArray(), 'hex')).toEqual('ffffffff')
+      expect(encode(new Writer().writeInt32LE(-1).toArray(), 'hex')).toEqual(
+        'ffffffff'
+      )
     })
   })
 
   describe('#writeUInt64BEBn', () => {
     it('should write 1', () => {
       const bw = new Writer()
-      expect(encode(bw.writeUInt64BEBn(new BigNumber(1)).toArray(), 'hex')).toEqual('0000000000000001')
+      expect(
+        encode(bw.writeUInt64BEBn(new BigNumber(1)).toArray(), 'hex')
+      ).toEqual('0000000000000001')
     })
   })
 
   describe('#writeUInt64LEBn', () => {
     it('should write 1', () => {
       const bw = new Writer()
-      expect(encode(bw.writeUInt64LEBn(new BigNumber(1)).toArray(), 'hex')).toEqual('0100000000000000')
+      expect(
+        encode(bw.writeUInt64LEBn(new BigNumber(1)).toArray(), 'hex')
+      ).toEqual('0100000000000000')
     })
   })
 

package/src/primitives/__tests/bug-31.test.ts

@@ -1,20 +1,16 @@
-// import { PrivateKey, PublicKey, Curve, Hash, BigNumber } from '..';
-import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
-// import { PrivateKey } from '..';
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
-import Curve from '../../../dist/cjs/src/primitives/Curve'
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import PrivateKey from '../../primitives/PrivateKey'
+import Curve from '../../primitives/Curve'
+import BigNumber from '../../primitives/BigNumber'
 
 describe('bug-31 tests', () => {
   test('0', () => {
     const c = new Curve()
-    const G = c.g
     // const bn = new BigNumber(c.n + 12)
     const bn = c.n.addn(12)
     const sn = new BigNumber(12)
-    {
-      expect(() => new PrivateKey(bn.toHex(), 'hex', 'be', 'error')).toThrow('Input is out of field')
-    }
+    expect(() => new PrivateKey(bn.toHex(), 'hex', 'be', 'error')).toThrow(
+      'Input is out of field'
+    )
     const o = PrivateKey.fromString(bn.toHex(), 'hex')
     const os = PrivateKey.fromString(sn.toHex(), 'hex')
     expect(o.cmp(os)).toBe(0)

package/src/primitives/__tests/utils.test.ts

@@ -1,5 +1,14 @@
 /* eslint-env jest */
-import { toArray, zero2, toHex, encode, fromBase58, toBase58, fromBase58Check, toBase58Check } from '../../../dist/cjs/src/primitives/utils'
+import {
+  toArray,
+  zero2,
+  toHex,
+  encode,
+  fromBase58,
+  toBase58,
+  fromBase58Check,
+  toBase58Check
+} from '../../primitives/utils'
 
 describe('utils', () => {
   it('should convert to array', () => {
@@ -26,26 +35,40 @@ describe('utils', () => {
 
   describe('base58 to binary', () => {
     it('Converts as expected', () => {
-      const actual = fromBase58('6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV')
-      expect(toHex(actual)).toEqual('02c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cfeb05f9d2')
+      const actual = fromBase58(
+        '6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV'
+      )
+      expect(toHex(actual)).toEqual(
+        '02c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cfeb05f9d2'
+      )
     })
     it('Converts as expected with leading 1s', () => {
       const actual = fromBase58('111z')
       expect(toHex(actual)).toEqual('00000039')
     })
     it('Throws when called with undefined base58 string', () => {
-      expect(() => fromBase58()).toThrow(new Error('Expected base58 string but got “undefined”'))
+      expect(() => fromBase58(undefined as unknown as string)).toThrow(
+        new Error('Expected base58 string but got “undefined”')
+      )
     })
+
     it('Throws when called with invalid characters in base58 string', () => {
-      expect(() => fromBase58('0L')).toThrow(new Error('Invalid base58 character “0”'))
+      expect(() => fromBase58('0L')).toThrow(
+        new Error('Invalid base58 character “0”')
+      )
     })
   })
   describe('binary to base58 string', () => {
     it('Converts to base58 as expected', () => {
       const actual = toBase58(
-        toArray('02c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cfeb05f9d2', 'hex')
+        toArray(
+          '02c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cfeb05f9d2',
+          'hex'
+        )
+      )
+      expect(actual).toEqual(
+        '6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV'
       )
-      expect(actual).toEqual('6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV')
     })
     it('Converts to base58 as expected with 1s', () => {
       const actual = toBase58([0, 0, 0, 4])
@@ -67,31 +90,53 @@ describe('utils', () => {
 
     it('should correctly encode and decode data with custom prefix', () => {
       const prefix = [0x80]
-      let data = toArray('1E99423A4ED27608A15A2616A2B0E9E52CED330AC530EDCC32C8FFC6A526AEDD', 'hex')
+      let data = toArray(
+        '1E99423A4ED27608A15A2616A2B0E9E52CED330AC530EDCC32C8FFC6A526AEDD',
+        'hex'
+      )
       let encoded = toBase58Check(data, prefix)
-      expect(encoded).toBe('5J3mBbAH58CpQ3Y5RNJpUKPE62SQ5tfcvU2JpbnkeyhfsYB1Jcn')
+      expect(encoded).toBe(
+        '5J3mBbAH58CpQ3Y5RNJpUKPE62SQ5tfcvU2JpbnkeyhfsYB1Jcn'
+      )
       expect(fromBase58Check(encoded)).toEqual({ prefix, data })
 
-      data = toArray('3aba4162c7251c891207b747840551a71939b0de081f85c4e44cf7c13e41daa6', 'hex')
+      data = toArray(
+        '3aba4162c7251c891207b747840551a71939b0de081f85c4e44cf7c13e41daa6',
+        'hex'
+      )
       encoded = toBase58Check(data, prefix)
-      expect(encoded).toBe('5JG9hT3beGTJuUAmCQEmNaxAuMacCTfXuw1R3FCXig23RQHMr4K')
+      expect(encoded).toBe(
+        '5JG9hT3beGTJuUAmCQEmNaxAuMacCTfXuw1R3FCXig23RQHMr4K'
+      )
       expect(fromBase58Check(encoded)).toEqual({ prefix, data })
     })
 
     it('should correctly handle encoding and decoding with different encoding formats', () => {
       const prefix = [0x80]
-      let dataHex = '1E99423A4ED27608A15A2616A2B0E9E52CED330AC530EDCC32C8FFC6A526AEDD01'
+      let dataHex =
+        '1E99423A4ED27608A15A2616A2B0E9E52CED330AC530EDCC32C8FFC6A526AEDD01'
       dataHex = dataHex.toLowerCase()
       let data = toArray(dataHex, 'hex')
       let encoded = toBase58Check(data, prefix)
-      expect(encoded).toBe('KxFC1jmwwCoACiCAWZ3eXa96mBM6tb3TYzGmf6YwgdGWZgawvrtJ')
-      expect(fromBase58Check(encoded, 'hex')).toEqual({ prefix: '80', data: dataHex })
+      expect(encoded).toBe(
+        'KxFC1jmwwCoACiCAWZ3eXa96mBM6tb3TYzGmf6YwgdGWZgawvrtJ'
+      )
+      expect(fromBase58Check(encoded, 'hex')).toEqual({
+        prefix: '80',
+        data: dataHex
+      })
 
-      dataHex = '3aba4162c7251c891207b747840551a71939b0de081f85c4e44cf7c13e41daa601'
+      dataHex =
+        '3aba4162c7251c891207b747840551a71939b0de081f85c4e44cf7c13e41daa601'
       data = toArray(dataHex, 'hex')
       encoded = toBase58Check(data, prefix)
-      expect(encoded).toBe('KyBsPXxTuVD82av65KZkrGrWi5qLMah5SdNq6uftawDbgKa2wv6S')
-      expect(fromBase58Check(encoded, 'hex')).toEqual({ prefix: '80', data: dataHex })
+      expect(encoded).toBe(
+        'KyBsPXxTuVD82av65KZkrGrWi5qLMah5SdNq6uftawDbgKa2wv6S'
+      )
+      expect(fromBase58Check(encoded, 'hex')).toEqual({
+        prefix: '80',
+        data: dataHex
+      })
     })
 
     it('should correctly encode and decode Bitcoin addresses', () => {
@@ -99,10 +144,16 @@ describe('utils', () => {
       const data = toArray(dataHex, 'hex')
       const encoded = toBase58Check(data)
       expect(encoded).toBe('1mayif3H2JDC62S4N3rLNtBNRAiUUP99k')
-      expect(fromBase58Check(encoded, 'hex')).toEqual({ prefix: '00', data: dataHex })
+      expect(fromBase58Check(encoded, 'hex')).toEqual({
+        prefix: '00',
+        data: dataHex
+      })
 
       const address = '1mayif3H2JDC62S4N3rLNtBNRAiUUP99k'
-      expect(fromBase58Check(address, 'hex')).toEqual({ prefix: '00', data: dataHex })
+      expect(fromBase58Check(address, 'hex')).toEqual({
+        prefix: '00',
+        data: dataHex
+      })
     })
   })
 })

package/src/primitives/utils.ts

@@ -37,7 +37,7 @@ export const toHex = (msg: number[]): string => {
  */
 export const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
   if (Array.isArray(msg)) return msg.slice()
-  if (!msg) return []
+  if (msg === undefined) return []
 
   if (typeof msg !== 'string') {
     return Array.from(msg, (item: any) => item | 0)
@@ -54,7 +54,7 @@ export const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
 }
 
 const hexToArray = (msg: string): number[] => {
-  msg = msg.replace(/[^a-z0-9]+/ig, '')
+  msg = msg.replace(/[^a-z0-9]+/gi, '')
   if (msg.length % 2 !== 0) msg = '0' + msg
   const res: number[] = []
   for (let i = 0; i < msg.length; i += 2) {
@@ -64,7 +64,8 @@ const hexToArray = (msg: string): number[] => {
 }
 
 const base64ToArray = (msg: string): number[] => {
-  const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+  const base64Chars =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
   const result: number[] = []
   let currentBit = 0
   let currentByte = 0
@@ -75,7 +76,7 @@ const base64ToArray = (msg: string): number[] => {
 
     if (currentByte >= 8) {
       currentByte -= 8
-      result.push((currentBit >> currentByte) & 0xFF)
+      result.push((currentBit >> currentByte) & 0xff)
       currentBit &= (1 << currentByte) - 1
     }
   }
@@ -89,7 +90,7 @@ const utf8ToArray = (msg: string): number[] => {
     const c = msg.charCodeAt(i)
     const hi = c >> 8
     const lo = c & 0xff
-    if (hi) {
+    if (hi !== 0) {
       res.push(hi, lo)
     } else {
       res.push(lo)
@@ -118,35 +119,37 @@ export const toUTF8 = (arr: number[]): string => {
     }
 
     // 1-byte sequence (0xxxxxxx)
-    if (byte <= 0x7F) {
+    if (byte <= 0x7f) {
       result += String.fromCharCode(byte)
-    }
-    // 2-byte sequence (110xxxxx 10xxxxxx)
-    else if (byte >= 0xC0 && byte <= 0xDF) {
+    } else if (byte >= 0xc0 && byte <= 0xdf) {
+      // 2-byte sequence (110xxxxx 10xxxxxx)
       const byte2 = arr[i + 1]
       skip = 1
-      const codePoint = ((byte & 0x1F) << 6) | (byte2 & 0x3F)
+      const codePoint = ((byte & 0x1f) << 6) | (byte2 & 0x3f)
       result += String.fromCharCode(codePoint)
-    }
-    // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
-    else if (byte >= 0xE0 && byte <= 0xEF) {
+    } else if (byte >= 0xe0 && byte <= 0xef) {
+      // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
       const byte2 = arr[i + 1]
       const byte3 = arr[i + 2]
       skip = 2
-      const codePoint = ((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F)
+      const codePoint =
+        ((byte & 0x0f) << 12) | ((byte2 & 0x3f) << 6) | (byte3 & 0x3f)
       result += String.fromCharCode(codePoint)
-    }
-    // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
-    else if (byte >= 0xF0 && byte <= 0xF7) {
+    } else if (byte >= 0xf0 && byte <= 0xf7) {
+      // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
       const byte2 = arr[i + 1]
       const byte3 = arr[i + 2]
       const byte4 = arr[i + 3]
       skip = 3
-      const codePoint = ((byte & 0x07) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F)
+      const codePoint =
+        ((byte & 0x07) << 18) |
+        ((byte2 & 0x3f) << 12) |
+        ((byte3 & 0x3f) << 6) |
+        (byte4 & 0x3f)
 
       // Convert to UTF-16 surrogate pair
-      const surrogate1 = 0xD800 + ((codePoint - 0x10000) >> 10)
-      const surrogate2 = 0xDC00 + ((codePoint - 0x10000) & 0x3FF)
+      const surrogate1 = 0xd800 + ((codePoint - 0x10000) >> 10)
+      const surrogate2 = 0xdc00 + ((codePoint - 0x10000) & 0x3ff)
       result += String.fromCharCode(surrogate1, surrogate2)
     }
   }
@@ -160,7 +163,10 @@ export const toUTF8 = (arr: number[]): string => {
  * @param {('hex' | 'utf8')} enc - The desired encoding.
  * @returns {string | number[]} - The encoded message as a string (for 'hex' and 'utf8') or the original array.
  */
-export const encode = (arr: number[], enc?: 'hex' | 'utf8'): string | number[] => {
+export const encode = (
+  arr: number[],
+  enc?: 'hex' | 'utf8'
+): string | number[] => {
   switch (enc) {
     case 'hex':
       return toHex(arr)
@@ -183,7 +189,8 @@ export const encode = (arr: number[], enc?: 'hex' | 'utf8'): string | number[] =
  * console.log(toBase64(bytes)); // Outputs: SGVsbG8=
  */
 export function toBase64 (byteArray: number[]): string {
-  const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+  const base64Chars =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
   let result = ''
   let i: number
 
@@ -194,8 +201,8 @@ export function toBase64 (byteArray: number[]): string {
 
     const encoded1 = byte1 >> 2
     const encoded2 = ((byte1 & 0x03) << 4) | (byte2 >> 4)
-    const encoded3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6)
-    const encoded4 = byte3 & 0x3F
+    const encoded3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6)
+    const encoded4 = byte3 & 0x3f
 
     result += base64Chars.charAt(encoded1) + base64Chars.charAt(encoded2)
     result += i + 1 < byteArray.length ? base64Chars.charAt(encoded3) : '='
@@ -205,7 +212,8 @@ export function toBase64 (byteArray: number[]): string {
   return result
 }
 
-const base58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+const base58chars =
+  '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
 /**
  * Converts a string from base58 to a binary array
@@ -213,21 +221,23 @@ const base58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
  * @returns The binary representation
  */
 export const fromBase58 = (str: string): number[] => {
-  if (!str || typeof str !== 'string') { throw new Error(`Expected base58 string but got “${str}”`) }
-  if (str.match(/[IOl0]/gmu)) {
-    throw new Error(
-      `Invalid base58 character “${str.match(/[IOl0]/gmu)}”`
-    )
+  if (str === '' || typeof str !== 'string') {
+    throw new Error(`Expected base58 string but got “${str}”`)
+  }
+  const match: string[] | null = str.match(/[IOl0]/gmu)
+
+  if (match !== null) {
+    throw new Error(`Invalid base58 character “${match.join('')}”`)
   }
   const lz = str.match(/^1+/gmu)
-  const psz: number = lz ? lz[0].length : 0
-  const size =
-    ((str.length - psz) * (Math.log(58) / Math.log(256)) + 1) >>> 0
+  const psz: number = (lz !== null) ? lz[0].length : 0
+  const size = ((str.length - psz) * (Math.log(58) / Math.log(256)) + 1) >>> 0
 
   const uint8 = new Uint8Array([
     ...new Uint8Array(psz),
-    ...str
-      .match(/./gmu)
+    ...(
+      str.match(/./gmu) ?? [] // ✅ Safe Fix: If null, use []
+    )
       .map((i) => base58chars.indexOf(i))
       .reduce((acc, i) => {
         acc = acc.map((j) => {
@@ -256,9 +266,11 @@ export const fromBase58 = (str: string): number[] => {
  */
 export const toBase58 = (bin: number[]): string => {
   const base58Map = Array(256).fill(-1)
-  for (let i = 0; i < base58chars.length; ++i) { base58Map[base58chars.charCodeAt(i)] = i }
+  for (let i = 0; i < base58chars.length; ++i) {
+    base58Map[base58chars.charCodeAt(i)] = i
+  }
 
-  const result = []
+  const result: number[] = []
 
   for (const byte of bin) {
     let carry = byte
@@ -267,14 +279,14 @@ export const toBase58 = (bin: number[]): string => {
       result[j] = base58chars.charCodeAt(x % 58)
       carry = (x / 58) | 0
     }
-    while (carry) {
+    while (carry !== 0) {
       result.push(base58chars.charCodeAt(carry % 58))
       carry = (carry / 58) | 0
     }
   }
 
   for (const byte of bin) {
-    if (byte) break
+    if (byte !== 0) break
     else result.push('1'.charCodeAt(0))
   }
 
@@ -288,7 +300,7 @@ export const toBase58 = (bin: number[]): string => {
  * @param bin - The binary array to convert to base58check
  * @returns The base58check string representation
  */
-export const toBase58Check = (bin: number[], prefix: number[] = [0]) => {
+export const toBase58Check = (bin: number[], prefix: number[] = [0]): string => {
   let hash = hash256([...prefix, ...bin])
   hash = [...prefix, ...bin, ...hash.slice(0, 4)]
   return toBase58(hash)
@@ -301,7 +313,11 @@ export const toBase58Check = (bin: number[], prefix: number[] = [0]) => {
  * @param prefixLength - The length of the prefix. Optional, defaults to 1.
  * @returns The binary array representation
  */
-export const fromBase58Check = (str: string, enc?: 'hex', prefixLength: number = 1) => {
+export const fromBase58Check = (
+  str: string,
+  enc?: 'hex',
+  prefixLength: number = 1
+): any => {
   const bin = fromBase58(str)
   let prefix: string | number[] = bin.slice(0, prefixLength)
   let data: string | number[] = bin.slice(prefixLength, -4)
@@ -323,7 +339,7 @@ export class Writer {
   public bufs: number[][]
 
   constructor (bufs?: number[][]) {
-    this.bufs = bufs || []
+    this.bufs = bufs !== undefined ? bufs : []
   }
 
   getLength (): number {
@@ -369,41 +385,41 @@ export class Writer {
 
   writeInt8 (n: number): this {
     const buf = new Array(1)
-    buf[0] = n & 0xFF
+    buf[0] = n & 0xff
     this.write(buf)
     return this
   }
 
   writeUInt16BE (n: number): this {
     this.bufs.push([
-      (n >> 8) & 0xFF, // shift right 8 bits to get the high byte
-      n & 0xFF // low byte is just the last 8 bits
+      (n >> 8) & 0xff, // shift right 8 bits to get the high byte
+      n & 0xff // low byte is just the last 8 bits
     ])
     return this
   }
 
   writeInt16BE (n: number): this {
-    return this.writeUInt16BE(n & 0xFFFF) // Mask with 0xFFFF to get the lower 16 bits
+    return this.writeUInt16BE(n & 0xffff) // Mask with 0xFFFF to get the lower 16 bits
   }
 
   writeUInt16LE (n: number): this {
     this.bufs.push([
-      n & 0xFF, // low byte is just the last 8 bits
-      (n >> 8) & 0xFF // shift right 8 bits to get the high byte
+      n & 0xff, // low byte is just the last 8 bits
+      (n >> 8) & 0xff // shift right 8 bits to get the high byte
     ])
     return this
   }
 
   writeInt16LE (n: number): this {
-    return this.writeUInt16LE(n & 0xFFFF) // Mask with 0xFFFF to get the lower 16 bits
+    return this.writeUInt16LE(n & 0xffff) // Mask with 0xFFFF to get the lower 16 bits
   }
 
   writeUInt32BE (n: number): this {
     this.bufs.push([
-      (n >> 24) & 0xFF, // highest byte
-      (n >> 16) & 0xFF,
-      (n >> 8) & 0xFF,
-      n & 0xFF // lowest byte
+      (n >> 24) & 0xff, // highest byte
+      (n >> 16) & 0xff,
+      (n >> 8) & 0xff,
+      n & 0xff // lowest byte
     ])
     return this
   }
@@ -414,10 +430,10 @@ export class Writer {
 
   writeUInt32LE (n: number): this {
     this.bufs.push([
-      n & 0xFF, // lowest byte
-      (n >> 8) & 0xFF,
-      (n >> 16) & 0xFF,
-      (n >> 24) & 0xFF // highest byte
+      n & 0xff, // lowest byte
+      (n >> 8) & 0xff,
+      (n >> 16) & 0xff,
+      (n >> 24) & 0xff // highest byte
     ])
     return this
   }
@@ -464,33 +480,33 @@ export class Writer {
       // 253 followed by the number in little-endian format
       buf = [
         253, // 0xfd
-        n & 0xFF, // low byte
-        (n >> 8) & 0xFF // high byte
+        n & 0xff, // low byte
+        (n >> 8) & 0xff // high byte
       ]
     } else if (n < 0x100000000) {
       // 254 followed by the number in little-endian format
       buf = [
         254, // 0xfe
-        n & 0xFF,
-        (n >> 8) & 0xFF,
-        (n >> 16) & 0xFF,
-        (n >> 24) & 0xFF
+        n & 0xff,
+        (n >> 8) & 0xff,
+        (n >> 16) & 0xff,
+        (n >> 24) & 0xff
       ]
     } else {
       // 255 followed by the number in little-endian format
       // Since JavaScript bitwise operations work on 32 bits, we need to handle 64-bit numbers in two parts
-      const low = n & 0xFFFFFFFF
-      const high = Math.floor(n / 0x100000000) & 0xFFFFFFFF
+      const low = n & 0xffffffff
+      const high = Math.floor(n / 0x100000000) & 0xffffffff
       buf = [
         255, // 0xff
-        low & 0xFF,
-        (low >> 8) & 0xFF,
-        (low >> 16) & 0xFF,
-        (low >> 24) & 0xFF,
-        high & 0xFF,
-        (high >> 8) & 0xFF,
-        (high >> 16) & 0xFF,
-        (high >> 24) & 0xFF
+        low & 0xff,
+        (low >> 8) & 0xff,
+        (low >> 16) & 0xff,
+        (low >> 24) & 0xff,
+        high & 0xff,
+        (high >> 8) & 0xff,
+        (high >> 16) & 0xff,
+        (high >> 24) & 0xff
       ]
     }
     return buf
@@ -505,11 +521,17 @@ export class Writer {
     } else if (bn.ltn(0x10000)) {
       const n = bn.toNumber()
       // Value fits in a uint16
-      buf = [253, n & 0xFF, (n >> 8) & 0xFF]
+      buf = [253, n & 0xff, (n >> 8) & 0xff]
     } else if (bn.lt(new BigNumber(0x100000000))) {
       const n = bn.toNumber()
       // Value fits in a uint32
-      buf = [254, n & 0xFF, (n >> 8) & 0xFF, (n >> 16) & 0xFF, (n >> 24) & 0xFF]
+      buf = [
+        254,
+        n & 0xff,
+        (n >> 8) & 0xff,
+        (n >> 16) & 0xff,
+        (n >> 24) & 0xff
+      ]
     } else {
       const bw = new Writer()
       bw.writeUInt8(255)
@@ -589,7 +611,7 @@ export class Reader {
 
   public readUInt32BE (): number {
     const val =
-      (this.bin[this.pos] * 0x1000000) + // Shift the first byte by 24 bits
+      this.bin[this.pos] * 0x1000000 + // Shift the first byte by 24 bits
       ((this.bin[this.pos + 1] << 16) | // Shift the second byte by 16 bits
         (this.bin[this.pos + 2] << 8) | // Shift the third byte by 8 bits
         this.bin[this.pos + 3]) // The fourth byte
@@ -608,7 +630,8 @@ export class Reader {
       (this.bin[this.pos] |
         (this.bin[this.pos + 1] << 8) |
         (this.bin[this.pos + 2] << 16) |
-        (this.bin[this.pos + 3] << 24)) >>> 0
+        (this.bin[this.pos + 3] << 24)) >>>
+      0
     this.pos += 4
     return val
   }
@@ -635,7 +658,6 @@ export class Reader {
   public readVarIntNum (): number {
     const first = this.readUInt8()
     let bn: BigNumber
-    let n: number
     switch (first) {
       case 0xfd:
         return this.readUInt16LE()
@@ -646,7 +668,9 @@ export class Reader {
         if (bn.lte(new BigNumber(2).pow(new BigNumber(53)))) {
           return bn.toNumber()
         } else {
-          throw new Error('number too large to retain precision - use readVarIntBn')
+          throw new Error(
+            'number too large to retain precision - use readVarIntBn'
+          )
         }
       default:
         return first