@bsv/sdk 1.3.11 → 1.3.13

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,31 +1,33 @@
 // import { PrivateKey, PublicKey, Curve, Hash, BigNumber } from '..';
-import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
+import PublicKey from "../../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
+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)
+    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)
-    const os2 = new PrivateKey(bn.toHex(), 'hex', 'be', 'nocheck')
-    expect(o.cmp(os2)).not.toBe(0)
+    const o = PrivateKey.fromString(bn.toHex(), "hex");
+    const os = PrivateKey.fromString(sn.toHex(), "hex");
+    expect(o.cmp(os)).toBe(0);
+    const os2 = new PrivateKey(bn.toHex(), "hex", "be", "nocheck");
+    expect(o.cmp(os2)).not.toBe(0);
 
-    const oWif = o.toWif()
-    expect(oWif).toBe('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU79MFFcB1G')
-    const osWif = os.toWif()
-    expect(osWif).toBe('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU79MFFcB1G')
+    const oWif = o.toWif();
+    expect(oWif).toBe("KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU79MFFcB1G");
+    const osWif = os.toWif();
+    expect(osWif).toBe("KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU79MFFcB1G");
 
-    expect(() => os2.toWif()).toThrow('Value is out of field')
-  })
-})
+    expect(() => os2.toWif()).toThrow("Value is out of field");
+  });
+});

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 as any)()).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/index.ts

@@ -1,14 +1,14 @@
-export { default as BigNumber } from './BigNumber.js'
-export { default as Curve } from './Curve.js'
-export { default as Point } from './Point.js'
-export { default as PublicKey } from './PublicKey.js'
-export { default as Signature } from './Signature.js'
-export { default as PrivateKey, KeyShares } from './PrivateKey.js'
-export { default as SymmetricKey } from './SymmetricKey.js'
-export * as ECDSA from './ECDSA.js'
-export * as Utils from './utils.js'
-export * as Hash from './Hash.js'
-export { default as Random } from './Random.js'
-export { default as TransactionSignature } from './TransactionSignature.js'
-export { default as Polynomial, PointInFiniteField } from './Polynomial.js'
-export { default as Schnorr } from './Schnorr.js'
+export { default as BigNumber } from './BigNumber'
+export { default as Curve } from './Curve'
+export { default as Point } from './Point'
+export { default as PublicKey } from './PublicKey'
+export { default as Signature } from './Signature'
+export { default as PrivateKey, KeyShares } from './PrivateKey'
+export { default as SymmetricKey } from './SymmetricKey'
+export * as ECDSA from './ECDSA'
+export * as Utils from './utils'
+export * as Hash from './Hash'
+export { default as Random } from './Random'
+export { default as TransactionSignature } from './TransactionSignature'
+export { default as Polynomial, PointInFiniteField } from './Polynomial'
+export { default as Schnorr } from './Schnorr'

package/src/primitives/utils.ts

@@ -1,5 +1,5 @@
-import BigNumber from './BigNumber.js'
-import { hash256 } from './Hash.js'
+import BigNumber from './BigNumber'
+import { hash256 } from './Hash'
 
 /**
  * Prepends a '0' to an odd character length word to ensure it has an even number of characters.
@@ -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
     }
   }
@@ -118,35 +119,40 @@ 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) {
       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) {
       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) {
       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 +166,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 +192,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 +204,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 +215,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,16 +224,15 @@ 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 || 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)}”`
-    )
+    throw new Error(`Invalid base58 character “${str.match(/[IOl0]/gmu)}”`)
   }
   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 size = ((str.length - psz) * (Math.log(58) / Math.log(256)) + 1) >>> 0
 
   const uint8 = new Uint8Array([
     ...new Uint8Array(psz),
@@ -256,7 +266,9 @@ 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 = []
 
@@ -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
+) => {
   const bin = fromBase58(str)
   let prefix: string | number[] = bin.slice(0, prefixLength)
   let data: string | number[] = bin.slice(prefixLength, -4)
@@ -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
   }
@@ -646,7 +669,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

package/src/script/LockingScript.ts

@@ -1,4 +1,4 @@
-import Script from './Script.js'
+import Script from './Script'
 
 /**
  * The LockingScript class represents a locking script in a Bitcoin SV transaction.