@bsv/sdk 1.0.12 → 1.0.14

package/src/primitives/utils.ts

@@ -167,7 +167,7 @@ export const encode = (arr: number[], enc?: 'hex' | 'utf8'): string | number[] =
  * const bytes = [72, 101, 108, 108, 111]; // Represents the string "Hello"
  * console.log(toBase64(bytes)); // Outputs: SGVsbG8=
  */
-export function toBase64(byteArray: number[]): string {
+export function toBase64 (byteArray: number[]): string {
   const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
   let result = ''
   let i: number
@@ -198,12 +198,12 @@ 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))
+  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)}”`
     )
+  }
   const lz = str.match(/^1+/gmu)
   const psz: number = lz ? lz[0].length : 0
   const size =
@@ -216,17 +216,17 @@ export const fromBase58 = (str: string): number[] => {
       .map((i) => base58chars.indexOf(i))
       .reduce((acc, i) => {
         acc = acc.map((j) => {
-          const x = j * 58 + i;
-          i = x >> 8;
-          return x;
-        });
-        return acc;
+          const x = j * 58 + i
+          i = x >> 8
+          return x
+        })
+        return acc
       }, new Uint8Array(size))
       .reverse()
       .filter(
         (
           (lastValue) => (value) =>
-            // @ts-ignore
+            // @ts-expect-error
             (lastValue = lastValue || value)
         )(false)
       )
@@ -240,16 +240,14 @@ export const fromBase58 = (str: string): number[] => {
  * @returns The base58 string representation
  */
 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;
+  const base58Map = Array(256).fill(-1)
+  for (let i = 0; i < base58chars.length; ++i) { base58Map[base58chars.charCodeAt(i)] = i }
 
   const result = []
 
   for (const byte of bin) {
     let carry = byte
     for (let j = 0; j < result.length; ++j) {
-      // @ts-ignore
       const x = (base58Map[result[j]] << 8) + carry
       result[j] = base58chars.charCodeAt(x % 58)
       carry = (x / 58) | 0
@@ -260,9 +258,10 @@ export const toBase58 = (bin: number[]): string => {
     }
   }
 
-  for (const byte of bin)
+  for (const byte of bin) {
     if (byte) break
-    else result.push("1".charCodeAt(0))
+    else result.push('1'.charCodeAt(0))
+  }
 
   result.reverse()
 
@@ -275,7 +274,7 @@ export const toBase58 = (bin: number[]): string => {
  * @returns The base58check string representation
  */
 export const toBase58Check = (bin: number[], prefix: number[] = [0]) => {
-  let hash = hash256([...prefix, ...bin]) as number[]
+  let hash = hash256([...prefix, ...bin])
   hash = [...prefix, ...bin, ...hash.slice(0, 4)]
   return toBase58(hash)
 }
@@ -292,7 +291,7 @@ export const fromBase58Check = (str: string, enc?: 'hex', prefixLength: number =
   let prefix: string | number[] = bin.slice(0, prefixLength)
   let data: string | number[] = bin.slice(prefixLength, -4)
   let hash = [...prefix, ...data]
-  hash = hash256(hash) as number[]
+  hash = hash256(hash)
   bin.slice(-4).forEach((check, index) => {
     if (check !== hash[index]) {
       throw new Error('Invalid checksum')
@@ -308,11 +307,11 @@ export const fromBase58Check = (str: string, enc?: 'hex', prefixLength: number =
 export class Writer {
   public bufs: number[][]
 
-  constructor(bufs?: number[][]) {
+  constructor (bufs?: number[][]) {
     this.bufs = bufs || []
   }
 
-  getLength(): number {
+  getLength (): number {
     let len = 0
     for (const buf of this.bufs) {
       len = len + buf.length
@@ -320,23 +319,20 @@ export class Writer {
     return len
   }
 
-  toArray(): number[] {
+  toArray (): number[] {
     let ret = []
     for (const x of this.bufs) {
-      if (x.length < 65536)
-        ret.push(...x)
-      else
-        ret = ret.concat(x)
+      if (x.length < 65536) { ret.push(...x) } else { ret = ret.concat(x) }
     }
     return ret
   }
 
-  write(buf: number[]): Writer {
+  write (buf: number[]): Writer {
     this.bufs.push(buf)
     return this
   }
 
-  writeReverse(buf: number[]): Writer {
+  writeReverse (buf: number[]): Writer {
     const buf2: number[] = new Array(buf.length)
     for (let i = 0; i < buf2.length; i++) {
       buf2[i] = buf[buf.length - 1 - i]
@@ -345,21 +341,21 @@ export class Writer {
     return this
   }
 
-  writeUInt8(n: number): Writer {
+  writeUInt8 (n: number): Writer {
     const buf = new Array(1)
     buf[0] = n
     this.write(buf)
     return this
   }
 
-  writeInt8(n: number): Writer {
+  writeInt8 (n: number): Writer {
     const buf = new Array(1)
     buf[0] = n & 0xFF
     this.write(buf)
     return this
   }
 
-  writeUInt16BE(n: number): Writer {
+  writeUInt16BE (n: number): Writer {
     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
@@ -367,11 +363,11 @@ export class Writer {
     return this
   }
 
-  writeInt16BE(n: number): Writer {
+  writeInt16BE (n: number): Writer {
     return this.writeUInt16BE(n & 0xFFFF) // Mask with 0xFFFF to get the lower 16 bits
   }
 
-  writeUInt16LE(n: number): Writer {
+  writeUInt16LE (n: number): Writer {
     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
@@ -379,11 +375,11 @@ export class Writer {
     return this
   }
 
-  writeInt16LE(n: number): Writer {
+  writeInt16LE (n: number): Writer {
     return this.writeUInt16LE(n & 0xFFFF) // Mask with 0xFFFF to get the lower 16 bits
   }
 
-  writeUInt32BE(n: number): Writer {
+  writeUInt32BE (n: number): Writer {
     this.bufs.push([
       (n >> 24) & 0xFF, // highest byte
       (n >> 16) & 0xFF,
@@ -393,11 +389,11 @@ export class Writer {
     return this
   }
 
-  writeInt32BE(n: number): Writer {
+  writeInt32BE (n: number): Writer {
     return this.writeUInt32BE(n >>> 0) // Using unsigned right shift to handle negative numbers
   }
 
-  writeUInt32LE(n: number): Writer {
+  writeUInt32LE (n: number): Writer {
     this.bufs.push([
       n & 0xFF, // lowest byte
       (n >> 8) & 0xFF,
@@ -407,41 +403,41 @@ export class Writer {
     return this
   }
 
-  writeInt32LE(n: number): Writer {
+  writeInt32LE (n: number): Writer {
     return this.writeUInt32LE(n >>> 0) // Using unsigned right shift to handle negative numbers
   }
 
-  writeUInt64BEBn(bn: BigNumber): Writer {
+  writeUInt64BEBn (bn: BigNumber): Writer {
     const buf = bn.toArray('be', 8)
     this.write(buf)
     return this
   }
 
-  writeUInt64LEBn(bn: BigNumber): Writer {
+  writeUInt64LEBn (bn: BigNumber): Writer {
     const buf = bn.toArray('be', 8)
     this.writeReverse(buf)
     return this
   }
 
-  writeUInt64LE(n: number): Writer {
+  writeUInt64LE (n: number): Writer {
     const buf = new BigNumber(n).toArray('be', 8)
     this.writeReverse(buf)
     return this
   }
 
-  writeVarIntNum(n: number): Writer {
+  writeVarIntNum (n: number): Writer {
     const buf = Writer.varIntNum(n)
     this.write(buf)
     return this
   }
 
-  writeVarIntBn(bn: BigNumber): Writer {
+  writeVarIntBn (bn: BigNumber): Writer {
     const buf = Writer.varIntBn(bn)
     this.write(buf)
     return this
   }
 
-  static varIntNum(n: number): number[] {
+  static varIntNum (n: number): number[] {
     let buf: number[]
     if (n < 253) {
       buf = [n] // 1 byte
@@ -481,7 +477,7 @@ export class Writer {
     return buf
   }
 
-  static varIntBn(bn: BigNumber): number[] {
+  static varIntBn (bn: BigNumber): number[] {
     let buf: number[]
     if (bn.ltn(253)) {
       const n = bn.toNumber()
@@ -509,22 +505,22 @@ export class Reader {
   public bin: number[]
   public pos: number
 
-  constructor(bin: number[] = [], pos: number = 0) {
+  constructor (bin: number[] = [], pos: number = 0) {
     this.bin = bin
     this.pos = pos
   }
 
-  public eof(): boolean {
+  public eof (): boolean {
     return this.pos >= this.bin.length
   }
 
-  public read(len = this.bin.length): number[] {
+  public read (len = this.bin.length): number[] {
     const bin = this.bin.slice(this.pos, this.pos + len)
     this.pos = this.pos + len
     return bin
   }
 
-  public readReverse(len = this.bin.length): number[] {
+  public readReverse (len = this.bin.length): number[] {
     const bin = this.bin.slice(this.pos, this.pos + len)
     this.pos = this.pos + len
     const buf2 = new Array(bin.length)
@@ -534,45 +530,45 @@ export class Reader {
     return buf2
   }
 
-  public readUInt8(): number {
+  public readUInt8 (): number {
     const val = this.bin[this.pos]
     this.pos += 1
     return val
   }
 
-  public readInt8(): number {
+  public readInt8 (): number {
     const val = this.bin[this.pos]
     this.pos += 1
     // If the sign bit is set, convert to negative value
     return (val & 0x80) !== 0 ? val - 0x100 : val
   }
 
-  public readUInt16BE(): number {
+  public readUInt16BE (): number {
     const val = (this.bin[this.pos] << 8) | this.bin[this.pos + 1]
     this.pos += 2
     return val
   }
 
-  public readInt16BE(): number {
+  public readInt16BE (): number {
     const val = this.readUInt16BE()
     // If the sign bit is set, convert to negative value
     return (val & 0x8000) !== 0 ? val - 0x10000 : val
   }
 
-  public readUInt16LE(): number {
+  public readUInt16LE (): number {
     const val = this.bin[this.pos] | (this.bin[this.pos + 1] << 8)
     this.pos += 2
     return val
   }
 
-  public readInt16LE(): number {
+  public readInt16LE (): number {
     const val = this.readUInt16LE()
     // If the sign bit is set, convert to negative value
     const x = (val & 0x8000) !== 0 ? val - 0x10000 : val
     return x
   }
 
-  public readUInt32BE(): number {
+  public readUInt32BE (): number {
     const val =
       (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
@@ -582,13 +578,13 @@ export class Reader {
     return val
   }
 
-  public readInt32BE(): number {
+  public readInt32BE (): number {
     const val = this.readUInt32BE()
     // If the sign bit is set, convert to negative value
     return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
   }
 
-  public readUInt32LE(): number {
+  public readUInt32LE (): number {
     const val =
       (this.bin[this.pos] |
         (this.bin[this.pos + 1] << 8) |
@@ -598,26 +594,26 @@ export class Reader {
     return val
   }
 
-  public readInt32LE(): number {
+  public readInt32LE (): number {
     const val = this.readUInt32LE()
     // Explicitly check if the sign bit is set and then convert to a negative value
     return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
   }
 
-  public readUInt64BEBn(): BigNumber {
+  public readUInt64BEBn (): BigNumber {
     const bin = this.bin.slice(this.pos, this.pos + 8)
     const bn = new BigNumber(bin)
     this.pos = this.pos + 8
     return bn
   }
 
-  public readUInt64LEBn(): BigNumber {
+  public readUInt64LEBn (): BigNumber {
     const bin = this.readReverse(8)
     const bn = new BigNumber(bin)
     return bn
   }
 
-  public readVarIntNum(): number {
+  public readVarIntNum (): number {
     const first = this.readUInt8()
     let bn: BigNumber
     let n: number
@@ -638,7 +634,7 @@ export class Reader {
     }
   }
 
-  public readVarInt(): number[] {
+  public readVarInt (): number[] {
     const first = this.bin[this.pos]
     switch (first) {
       case 0xfd:
@@ -652,7 +648,7 @@ export class Reader {
     }
   }
 
-  public readVarIntBn(): BigNumber {
+  public readVarIntBn (): BigNumber {
     const first = this.readUInt8()
     switch (first) {
       case 0xfd:
@@ -665,4 +661,4 @@ export class Reader {
         return new BigNumber(first)
     }
   }
-}
+}

package/src/script/Spend.ts

@@ -89,7 +89,7 @@ export default class Spend {
    *   inputSequence: 0xffffffff // inputSequence
    * });
    */
-  constructor(params: {
+  constructor (params: {
     sourceTXID: string
     sourceOutputIndex: number
     sourceSatoshis: number
@@ -116,7 +116,7 @@ export default class Spend {
     this.reset()
   }
 
-  reset(): void {
+  reset (): void {
     this.context = 'UnlockingScript'
     this.programCounter = 0
     this.lastCodeSeparator = null
@@ -125,7 +125,7 @@ export default class Spend {
     this.ifStack = []
   }
 
-  step(): void {
+  step (): void {
     // If the context is UnlockingScript and we have reached the end,
     // set the context to LockingScript and zero the program counter
     if (
@@ -1011,15 +1011,15 @@ export default class Spend {
           }
           buf = this.stacktop(-1)
           if (currentOpcode === OP.OP_RIPEMD160) {
-            bufHash = Hash.ripemd160(buf) as number[]
+            bufHash = Hash.ripemd160(buf)
           } else if (currentOpcode === OP.OP_SHA1) {
-            bufHash = Hash.sha1(buf) as number[]
+            bufHash = Hash.sha1(buf)
           } else if (currentOpcode === OP.OP_SHA256) {
-            bufHash = Hash.sha256(buf) as number[]
+            bufHash = Hash.sha256(buf)
           } else if (currentOpcode === OP.OP_HASH160) {
-            bufHash = Hash.hash160(buf) as number[]
+            bufHash = Hash.hash160(buf)
           } else if (currentOpcode === OP.OP_HASH256) {
-            bufHash = Hash.hash256(buf) as number[]
+            bufHash = Hash.hash256(buf)
           }
           this.stack.pop()
           this.stack.push(bufHash)
@@ -1330,7 +1330,7 @@ export default class Spend {
    *   console.log("Invalid spend!");
    * }
    */
-  validate(): boolean {
+  validate (): boolean {
     if (requirePushOnlyUnlockingScripts && !this.unlockingScript.isPushOnly()) {
       this.scriptEvaluationError('Unlocking scripts can only contain push operations, and no other opcodes.')
     }
@@ -1354,11 +1354,11 @@ export default class Spend {
     return true
   }
 
-  private stacktop(i: number): number[] {
+  private stacktop (i: number): number[] {
     return this.stack[this.stack.length + i]
   }
 
-  private castToBool(val: number[]): boolean {
+  private castToBool (val: number[]): boolean {
     for (let i = 0; i < val.length; i++) {
       if (val[i] !== 0) {
         // can be negative zero
@@ -1371,7 +1371,7 @@ export default class Spend {
     return false
   }
 
-  private scriptEvaluationError(str: string): void {
+  private scriptEvaluationError (str: string): void {
     throw new Error(`Script evaluation error: ${str}\n\nSource TXID: ${this.sourceTXID}\nSource output index: ${this.sourceOutputIndex}\nContext: ${this.context}\nProgram counter: ${this.programCounter}\nStack size: ${this.stack.length}\nAlt stack size: ${this.altStack.length}`)
   }
 }

package/src/script/index.ts

@@ -4,4 +4,4 @@ export { default as LockingScript } from './LockingScript.js'
 export { default as UnlockingScript } from './UnlockingScript.js'
 export { default as Spend } from './Spend.js'
 export type { default as ScriptTemplate } from './ScriptTemplate.js'
-export * from './templates/index.js'
+export * from './templates/index.js'

package/src/script/templates/P2PKH.ts

@@ -32,7 +32,7 @@ export default class P2PKH implements ScriptTemplate {
     return new LockingScript([
       { op: OP.OP_DUP },
       { op: OP.OP_HASH160 },
-      { op: pubkeyhash.length, data },
+      { op: data.length, data },
       { op: OP.OP_EQUALVERIFY },
       { op: OP.OP_CHECKSIG }
     ])

package/src/transaction/MerklePath.ts

@@ -97,7 +97,7 @@ export default class MerklePath {
     this.path = path
 
     // store all of the legal offsets which we expect given the txid indices.
-    let legalOffsets = Array(this.path.length).fill(0).map(() => new Set())
+    const legalOffsets = Array(this.path.length).fill(0).map(() => new Set())
     this.path.map((leaves, height) => {
       if (leaves.length === 0) {
         throw new Error(`Empty level at height: ${height}`)
@@ -107,7 +107,7 @@ export default class MerklePath {
         if (offsetsAtThisHeight.has(leaf.offset)) throw new Error(`Duplicate offset: ${leaf.offset}, at height: ${height}`)
         offsetsAtThisHeight.add(leaf.offset)
         if (height === 0) {
-          if (leaf.duplicate !== true) {
+          if (!leaf.duplicate) {
             for (let h = 1; h < this.path.length; h++) {
               legalOffsets[h].add(leaf.offset >> h ^ 1)
             }
@@ -188,7 +188,7 @@ export default class MerklePath {
     }
     // Calculate the root using the index as a way to determine which direction to concatenate.
     const hash = (m: string): string => toHex((
-      hash256(toArray(m, 'hex').reverse()) as number[]
+      hash256(toArray(m, 'hex').reverse())
     ).reverse())
     let workingHash = txid
     for (let height = 0; height < this.path.length; height++) {