@bsv/sdk 2.0.16 → 2.1.1

package/src/script/Script.ts

@@ -11,7 +11,7 @@ import BigNumber from '../primitives/BigNumber.js'
  * @property {ScriptChunk[]} chunks - An array of script chunks that make up the script.
  */
 const BufferCtor =
-  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
+  typeof globalThis === 'undefined' ? undefined : (globalThis as any).Buffer
 
 export default class Script {
   private _chunks: ScriptChunk[]
@@ -32,70 +32,54 @@ export default class Script {
     const tokens = asm.split(' ')
     let i = 0
     while (i < tokens.length) {
-      const token = tokens[i]
-      let opCode
-      let opCodeNum: number = 0
-      if (token.startsWith('OP_') && typeof OP[token] !== 'undefined') {
-        opCode = token
-        opCodeNum = OP[token]
-      }
+      const { chunk, advance } = Script.parseASMToken(tokens, i)
+      chunks.push(chunk)
+      i += advance
+    }
+    return new Script(chunks)
+  }
 
-      // we start with two special cases, 0 and -1, which are handled specially in
-      // toASM. see _chunkToString.
-      if (token === '0') {
-        opCodeNum = 0
-        chunks.push({
-          op: opCodeNum
-        })
-        i = i + 1
-      } else if (token === '-1') {
-        opCodeNum = OP.OP_1NEGATE
-        chunks.push({
-          op: opCodeNum
-        })
-        i = i + 1
-      } else if (opCode === undefined) {
-        let hex = tokens[i]
-        if (hex.length % 2 !== 0) {
-          hex = '0' + hex
-        }
-        const arr = toArray(hex, 'hex')
-        if (encode(arr, 'hex') !== hex) {
-          throw new Error('invalid hex string in script')
-        }
-        const len = arr.length
-        if (len >= 0 && len < OP.OP_PUSHDATA1) {
-          opCodeNum = len
-        } else if (len < Math.pow(2, 8)) {
-          opCodeNum = OP.OP_PUSHDATA1
-        } else if (len < Math.pow(2, 16)) {
-          opCodeNum = OP.OP_PUSHDATA2
-        } else if (len < Math.pow(2, 32)) {
-          opCodeNum = OP.OP_PUSHDATA4
-        }
-        chunks.push({
-          data: arr,
-          op: opCodeNum
-        })
-        i = i + 1
-      } else if (
-        opCodeNum === OP.OP_PUSHDATA1 ||
-        opCodeNum === OP.OP_PUSHDATA2 ||
-        opCodeNum === OP.OP_PUSHDATA4
-      ) {
-        chunks.push({
-          data: toArray(tokens[i + 2], 'hex'),
-          op: opCodeNum
-        })
-        i = i + 3
-      } else {
-        chunks.push({
-          op: opCodeNum
-        })
-        i = i + 1
+  private static pushdataOpCodeNum (len: number): number {
+    if (len >= 0 && len < OP.OP_PUSHDATA1) return len
+    if (len < Math.pow(2, 8)) return OP.OP_PUSHDATA1
+    if (len < Math.pow(2, 16)) return OP.OP_PUSHDATA2
+    return OP.OP_PUSHDATA4
+  }
+
+  private static parseASMToken (
+    tokens: string[],
+    i: number
+  ): { chunk: ScriptChunk, advance: number } {
+    const token = tokens[i]
+
+    // Special literal tokens
+    if (token === '0') return { chunk: { op: 0 }, advance: 1 }
+    if (token === '-1') return { chunk: { op: OP.OP_1NEGATE }, advance: 1 }
+
+    const isKnownOp = token.startsWith('OP_') && OP[token] !== undefined
+    const opCodeNum: number = isKnownOp ? OP[token] : 0
+
+    // Inline PUSHDATA opcodes consume the next two tokens (size, hex data)
+    if (
+      opCodeNum === OP.OP_PUSHDATA1 ||
+      opCodeNum === OP.OP_PUSHDATA2 ||
+      opCodeNum === OP.OP_PUSHDATA4
+    ) {
+      return { chunk: { data: toArray(tokens[i + 2], 'hex'), op: opCodeNum }, advance: 3 }
+    }
+
+    // Unknown opcode token — treat as raw hex push data
+    if (!isKnownOp) {
+      let hex = token
+      if (hex.length % 2 !== 0) hex = '0' + hex
+      const arr = toArray(hex, 'hex')
+      if (encode(arr, 'hex') !== hex) {
+        throw new Error('invalid hex string in script')
       }
+      return { chunk: { data: arr, op: Script.pushdataOpCodeNum(arr.length) }, advance: 1 }
     }
-    return new Script(chunks)
+
+    return { chunk: { op: opCodeNum }, advance: 1 }
   }
 
   /**
@@ -177,8 +161,7 @@ export default class Script {
    */
   toASM (): string {
     let str = ''
-    for (let i = 0; i < this.chunks.length; i++) {
-      const chunk = this.chunks[i]
+    for (const chunk of this.chunks) {
       str += this._chunkToString(chunk)
     }
 
@@ -194,13 +177,11 @@ export default class Script {
     if (this.hexCache != null) {
       return this.hexCache
     }
-    if (this.rawBytesCache == null) {
-      this.rawBytesCache = this.serializeChunksToBytes()
-    }
+    this.rawBytesCache ??= this.serializeChunksToBytes()
     const hex =
-      BufferCtor != null
-        ? BufferCtor.from(this.rawBytesCache).toString('hex')
-        : (encode(Array.from(this.rawBytesCache), 'hex') as string)
+      BufferCtor == null
+        ? (encode(Array.from(this.rawBytesCache), 'hex') as string)
+        : BufferCtor.from(this.rawBytesCache).toString('hex')
     this.hexCache = hex
     return hex
   }
@@ -215,9 +196,7 @@ export default class Script {
   }
 
   toUint8Array (): Uint8Array {
-    if (this.rawBytesCache == null) {
-      this.rawBytesCache = this.serializeChunksToBytes()
-    }
+    this.rawBytesCache ??= this.serializeChunksToBytes()
     return this.rawBytesCache
   }
 
@@ -227,7 +206,7 @@ export default class Script {
    * @param script - The script to append.
    * @returns This script instance for chaining.
    */
-  writeScript (script: Script): Script {
+  writeScript (script: Script): this {
     this.invalidateSerializationCaches()
     this.chunks = this.chunks.concat(script.chunks)
     return this
@@ -239,7 +218,7 @@ export default class Script {
    * @param op - The opcode to append.
    * @returns This script instance for chaining.
    */
-  writeOpCode (op: number): Script {
+  writeOpCode (op: number): this {
     this.invalidateSerializationCaches()
     this.chunks.push({ op })
     return this
@@ -252,7 +231,7 @@ export default class Script {
    * @param op - The opcode to set.
    * @returns This script instance for chaining.
    */
-  setChunkOpCode (i: number, op: number): Script {
+  setChunkOpCode (i: number, op: number): this {
     this.invalidateSerializationCaches()
     this.chunks[i] = { op }
     return this
@@ -264,7 +243,7 @@ export default class Script {
    * @param bn - The BigNumber to append.
    * @returns This script instance for chaining.
    */
-  writeBn (bn: BigNumber): Script {
+  writeBn (bn: BigNumber): this {
     this.invalidateSerializationCaches()
     if (bn.cmpn(0) === OP.OP_0) {
       this.chunks.push({
@@ -293,7 +272,7 @@ export default class Script {
    * @returns This script instance for chaining.
    * @throws {Error} Throws an error if the data is too large to be pushed.
    */
-  writeBin (bin: number[]): Script {
+  writeBin (bin: number[]): this {
     this.invalidateSerializationCaches()
     let op: number
     const data = bin.length > 0 ? bin : undefined
@@ -323,7 +302,7 @@ export default class Script {
    * @param num - The number to append.
    * @returns This script instance for chaining.
    */
-  writeNumber (num: number): Script {
+  writeNumber (num: number): this {
     this.invalidateSerializationCaches()
     this.writeBn(new BigNumber(num))
     return this
@@ -334,7 +313,7 @@ export default class Script {
    * Removes all OP_CODESEPARATOR opcodes from the script.
    * @returns This script instance for chaining.
    */
-  removeCodeseparators (): Script {
+  removeCodeseparators (): this {
     const bytes = this.toUint8Array()
     this.rawBytesCache = Uint8Array.from(Script.removeOpcodeBytes(bytes, OP.OP_CODESEPARATOR))
     this.hexCache = undefined
@@ -350,7 +329,7 @@ export default class Script {
    *
    * @returns This script instance for chaining.
    */
-  findAndDelete (script: Script): Script {
+  findAndDelete (script: Script): this {
     this.invalidateSerializationCaches()
     const targetBytes = script.toUint8Array()
     const targetLen = targetBytes.length
@@ -434,8 +413,7 @@ export default class Script {
    * @returns True if the script is push-only, otherwise false.
    */
   isPushOnly (): boolean {
-    for (let i = 0; i < this.chunks.length; i++) {
-      const chunk = this.chunks[i]
+    for (const chunk of this.chunks) {
       const opCodeNum = chunk.op
       if (opCodeNum > OP.OP_16) {
         return false
@@ -498,13 +476,11 @@ export default class Script {
     const bytes = new Uint8Array(totalLength)
     let offset = 0
 
-    for (let i = 0; i < chunks.length; i++) {
-      const chunk = chunks[i]
+    for (const chunk of chunks) {
       bytes[offset++] = chunk.op
       if (chunk.data == null) continue
       if (chunk.op === OP.OP_RETURN) {
         bytes.set(chunk.data, offset)
-        offset += chunk.data.length
         break
       }
       offset = Script.writeChunkData(bytes, offset, chunk.op, chunk.data)
@@ -549,6 +525,40 @@ export default class Script {
     return offset
   }
 
+  /**
+   * Reads pushdata length bytes from `bytes` at `pos` and returns the resulting
+   * `{ len, newPos, hasLength }` for a given opcode. Does not read the actual data.
+   */
+  private static readPushdataLength (
+    op: number,
+    bytes: ArrayLike<number>,
+    pos: number,
+    length: number
+  ): { len: number, newPos: number, hasLength: boolean } {
+    if (op > 0 && op < OP.OP_PUSHDATA1) {
+      return { len: op, newPos: pos, hasLength: true }
+    }
+    if (op === OP.OP_PUSHDATA1) {
+      const hasLength = pos < length
+      const len = hasLength ? bytes[pos++] ?? 0 : 0
+      return { len, newPos: pos, hasLength }
+    }
+    if (op === OP.OP_PUSHDATA2) {
+      const hasLength = pos + 1 < length
+      const len = (bytes[pos] ?? 0) | ((bytes[pos + 1] ?? 0) << 8)
+      return { len, newPos: Math.min(pos + 2, length), hasLength }
+    }
+    // OP_PUSHDATA4
+    const hasLength = pos + 3 < length
+    const len = (
+      (bytes[pos] ?? 0) |
+      ((bytes[pos + 1] ?? 0) << 8) |
+      ((bytes[pos + 2] ?? 0) << 16) |
+      ((bytes[pos + 3] ?? 0) << 24)
+    ) >>> 0
+    return { len, newPos: Math.min(pos + 4, length), hasLength }
+  }
+
   private static parseChunks (bytes: ArrayLike<number>): ScriptChunk[] {
     const chunks: ScriptChunk[] = []
     const length = bytes.length
@@ -559,71 +569,22 @@ export default class Script {
       const op = bytes[pos++] ?? 0
 
       if (op === OP.OP_RETURN && inConditionalBlock === 0) {
-        chunks.push({
-          op,
-          data: Script.copyRange(bytes, pos, length)
-        })
+        chunks.push({ op, data: Script.copyRange(bytes, pos, length) })
         break
       }
 
-      if (
-        op === OP.OP_IF ||
-        op === OP.OP_NOTIF ||
-        op === OP.OP_VERIF ||
-        op === OP.OP_VERNOTIF
-      ) {
+      if (op === OP.OP_IF || op === OP.OP_NOTIF || op === OP.OP_VERIF || op === OP.OP_VERNOTIF) {
         inConditionalBlock++
       } else if (op === OP.OP_ENDIF) {
         inConditionalBlock--
       }
 
-      if (op > 0 && op < OP.OP_PUSHDATA1) {
-        const len = op
-        const end = Math.min(pos + len, length)
-        chunks.push({
-          data: Script.copyRange(bytes, pos, end),
-          op,
-          invalidLength: end - pos !== len
-        })
-        pos = end
-      } else if (op === OP.OP_PUSHDATA1) {
-        const hasLength = pos < length
-        const len = hasLength ? bytes[pos++] ?? 0 : 0
+      if (op > 0 && op <= OP.OP_PUSHDATA4) {
+        const { len, newPos, hasLength } = Script.readPushdataLength(op, bytes, pos, length)
+        pos = newPos
         const end = Math.min(pos + len, length)
-        chunks.push({
-          data: Script.copyRange(bytes, pos, end),
-          op,
-          invalidLength: !hasLength || end - pos !== len
-        })
-        pos = end
-      } else if (op === OP.OP_PUSHDATA2) {
-        const hasLength = pos + 1 < length
-        const b0 = bytes[pos] ?? 0
-        const b1 = bytes[pos + 1] ?? 0
-        const len = b0 | (b1 << 8)
-        pos = Math.min(pos + 2, length)
-        const end = Math.min(pos + len, length)
-        chunks.push({
-          data: Script.copyRange(bytes, pos, end),
-          op,
-          invalidLength: !hasLength || end - pos !== len
-        })
-        pos = end
-      } else if (op === OP.OP_PUSHDATA4) {
-        const hasLength = pos + 3 < length
-        const len =
-          ((bytes[pos] ?? 0) |
-            ((bytes[pos + 1] ?? 0) << 8) |
-            ((bytes[pos + 2] ?? 0) << 16) |
-            ((bytes[pos + 3] ?? 0) << 24)) >>>
-          0
-        pos = Math.min(pos + 4, length)
-        const end = Math.min(pos + len, length)
-        chunks.push({
-          data: Script.copyRange(bytes, pos, end),
-          op,
-          invalidLength: !hasLength || end - pos !== len
-        })
+        const invalidLength = !hasLength || end - pos !== len
+        chunks.push({ data: Script.copyRange(bytes, pos, end), op, invalidLength })
         pos = end
       } else {
         chunks.push({ op })
@@ -641,35 +602,18 @@ export default class Script {
     while (pos < length) {
       const start = pos
       const op = bytes[pos++] ?? 0
-      let dataStart = pos
-      let dataLength = 0
-
-      if (op > 0 && op < OP.OP_PUSHDATA1) {
-        dataLength = op
-      } else if (op === OP.OP_PUSHDATA1) {
-        if (pos < length) dataLength = bytes[pos++] ?? 0
-        dataStart = pos
-      } else if (op === OP.OP_PUSHDATA2) {
-        if (pos + 1 < length) dataLength = (bytes[pos] ?? 0) | ((bytes[pos + 1] ?? 0) << 8)
-        pos = Math.min(pos + 2, length)
-        dataStart = pos
-      } else if (op === OP.OP_PUSHDATA4) {
-        if (pos + 3 < length) {
-          dataLength =
-            ((bytes[pos] ?? 0) |
-              ((bytes[pos + 1] ?? 0) << 8) |
-              ((bytes[pos + 2] ?? 0) << 16) |
-              ((bytes[pos + 3] ?? 0) << 24)) >>> 0
-        }
-        pos = Math.min(pos + 4, length)
-        dataStart = pos
-      }
 
-      const end = Math.min(dataStart + dataLength, length)
-      if (op !== opcode) {
-        for (let i = start; i < end; i++) out.push(bytes[i] ?? 0)
+      if (op > 0 && op <= OP.OP_PUSHDATA4) {
+        const { len, newPos } = Script.readPushdataLength(op, bytes, pos, length)
+        pos = newPos
+        const end = Math.min(pos + len, length)
+        if (op !== opcode) {
+          for (let i = start; i < end; i++) out.push(bytes[i] ?? 0)
+        }
+        pos = end
+      } else if (op !== opcode) {
+        out.push(op)
       }
-      pos = end
     }
 
     return out
@@ -691,7 +635,7 @@ export default class Script {
   private _chunkToString (chunk: ScriptChunk): string {
     const op = chunk.op
     let str = ''
-    if (typeof chunk.data === 'undefined') {
+    if (chunk.data === undefined) {
       const val = OP[op] as string
       str = `${str} ${val}`
     } else {

package/src/script/ScriptEvaluationError.ts

@@ -22,8 +22,8 @@ export default class ScriptEvaluationError extends Error {
     stackMem: number
     altStackMem: number
   }) {
-    const stackHex = params.stackState.map(s => s != null && typeof s.length !== 'undefined' ? toHex(s) : (s === null || s === undefined ? 'null/undef' : 'INVALID_STACK_ITEM')).join(', ')
-    const altStackHex = params.altStackState.map(s => s != null && typeof s.length !== 'undefined' ? toHex(s) : (s === null || s === undefined ? 'null/undef' : 'INVALID_STACK_ITEM')).join(', ')
+    const stackHex = params.stackState.map(s => s != null && s.length !== undefined ? toHex(s) : (s === null || s === undefined ? 'null/undef' : 'INVALID_STACK_ITEM')).join(', ')
+    const altStackHex = params.altStackState.map(s => s != null && s.length !== undefined ? toHex(s) : (s === null || s === undefined ? 'null/undef' : 'INVALID_STACK_ITEM')).join(', ')
     const pcInfo = `Context: ${params.context}, PC: ${params.programCounter}`
     const stackInfo = `Stack: [${stackHex}] (len: ${params.stackState.length}, mem: ${params.stackMem})`
     const altStackInfo = `AltStack: [${altStackHex}] (len: ${params.altStackState.length}, mem: ${params.altStackMem})`

package/src/script/Spend.ts

@@ -48,8 +48,8 @@ function isMinimallyEncodedHelper (
     return false
   }
   if (buf.length > 0) {
-    if ((buf[buf.length - 1] & 0x7f) === 0) {
-      if (buf.length <= 1 || (buf[buf.length - 2] & 0x80) === 0) {
+    if ((buf.at(-1) & 0x7f) === 0) {
+      if (buf.length <= 1 || (buf.at(-2) & 0x80) === 0) {
         return false
       }
     }
@@ -218,15 +218,14 @@ export default class Spend {
     this.lockTime = params.lockTime
     this.memoryLimit = params.memoryLimit ?? 32000000
     this.isRelaxedOverride = params.isRelaxed === true
-    this.verifyFlags = params.verifyFlags === undefined
-      ? undefined
-      : new Set(
-        (Array.isArray(params.verifyFlags)
-          ? params.verifyFlags
-          : params.verifyFlags.split(','))
-          .map(flag => flag.trim())
-          .filter(flag => flag.length > 0)
-      )
+    if (params.verifyFlags === undefined) {
+      this.verifyFlags = undefined
+    } else {
+      const flagArr = Array.isArray(params.verifyFlags)
+        ? params.verifyFlags
+        : params.verifyFlags.split(',')
+      this.verifyFlags = new Set(flagArr.map(flag => flag.trim()).filter(flag => flag.length > 0))
+    }
     this.stack = []
     this.altStack = []
     this.ifStack = []
@@ -524,7 +523,7 @@ export default class Spend {
   private parseLaxChecksigSignature (buf: number[]): TransactionSignature {
     if (buf.length === 0) return TransactionSignature.fromChecksigFormat(buf)
 
-    const scope = buf[buf.length - 1]
+    const scope = buf.at(-1)
     const der = buf.slice(0, -1)
     const position = { value: 0 }
     if (der[position.value++] !== 0x30) throw new Error('Signature DER must start with 0x30')
@@ -881,11 +880,11 @@ export default class Spend {
           break
         case OP.OP_ELSE:
           if (this.ifStack.length === 0) this.scriptEvaluationError('OP_ELSE requires a preceeding OP_IF.')
-          if (this.hasExplicitFlags() && this.isAfterGenesis() && this.elseStack[this.elseStack.length - 1]) {
+          if (this.hasExplicitFlags() && this.isAfterGenesis() && this.elseStack.at(-1)) {
             this.scriptEvaluationError('OP_ELSE may only be used once for each OP_IF or OP_NOTIF after Genesis.')
           }
           this.elseStack[this.elseStack.length - 1] = true
-          this.ifStack[this.ifStack.length - 1] = !(this.ifStack[this.ifStack.length - 1])
+          this.ifStack[this.ifStack.length - 1] = !this.ifStack.at(-1)
           break
         case OP.OP_ENDIF:
           if (this.ifStack.length === 0) this.scriptEvaluationError('OP_ENDIF requires a preceeding OP_IF.')
@@ -1400,7 +1399,7 @@ export default class Spend {
           let signbit = 0x00
 
           if (rawnum.length > 0) {
-            signbit = rawnum[rawnum.length - 1] & 0x80 // Store sign bit
+            signbit = rawnum.at(-1) & 0x80 // Store sign bit
             rawnum[rawnum.length - 1] &= 0x7f // Remove sign bit for padding
           }
 

package/src/script/templates/PushDrop.ts

@@ -1,4 +1,7 @@
-import { ScriptTemplate, LockingScript, UnlockingScript, OP } from '../index.js'
+import type ScriptTemplate from '../ScriptTemplate.js'
+import LockingScript from '../LockingScript.js'
+import UnlockingScript from '../UnlockingScript.js'
+import OP from '../OP.js'
 import {
   Utils,
   Hash,
@@ -15,7 +18,6 @@ import { computeSignatureScope, resolveSourceDetails, formatPreimage } from './S
  * For a given piece of data to push onto the stack in script, creates the correct minimally-encoded script chunk,
  * including the correct push operation.
  *
- * TODO: This should be made into a TS-SDK util (distinct from the `minimallyEncode` util)
  */
 const createMinimallyEncodedScriptChunk = (
   data: number[]
@@ -160,7 +162,7 @@ export default class PushDrop implements ScriptTemplate {
     })
     lockChunks.push({ op: OP.OP_CHECKSIG })
     if (includeSignature) {
-      const dataToSign = fields.reduce((a, e) => [...a, ...e], [])
+      const dataToSign = fields.flat()
       const { signature } = await this.wallet.createSignature({
         data: dataToSign,
         protocolID,

package/src/script/templates/RPuzzle.ts

@@ -90,9 +90,7 @@ export default class RPuzzle implements ScriptTemplate {
   } {
     return {
       sign: async (tx: Transaction, inputIndex: number) => {
-        if (typeof privateKey === 'undefined') {
-          privateKey = PrivateKey.fromRandom()
-        }
+        privateKey ??= PrivateKey.fromRandom()
         let signatureScope = TransactionSignature.SIGHASH_FORKID
         if (signOutputs === 'all') {
           signatureScope |= TransactionSignature.SIGHASH_ALL
@@ -109,7 +107,7 @@ export default class RPuzzle implements ScriptTemplate {
         const otherInputs = [...tx.inputs]
         const [input] = otherInputs.splice(inputIndex, 1)
         if (typeof input.sourceTransaction !== 'object') {
-          throw new Error(
+          throw new TypeError(
             'The source transaction is needed for transaction signing.'
           )
         }

package/src/storage/StorageDownloader.ts

@@ -1,5 +1,5 @@
 import { LookupResolver } from '../overlay-tools/index.js'
-import { StorageUtils } from './index.js'
+import * as StorageUtils from './StorageUtils.js'
 import PushDrop from '../script/templates/PushDrop.js'
 import Transaction from '../transaction/Transaction.js'
 import { Hash, Utils } from '../primitives/index.js'

package/src/totp/totp.ts

@@ -119,7 +119,7 @@ function generateHOTP (
   const signature = hmac.digest()
 
   // RFC 4226 https://datatracker.ietf.org/doc/html/rfc4226#section-5.4
-  const offset = signature[signature.length - 1] & 0x0f // offset is the last byte in the hmac
+  const offset = (signature.at(-1) ?? 0) & 0x0f // offset is the last byte in the hmac
   const fourBytesRange = signature.slice(offset, offset + 4) // starting from offset, get 4 bytes
   const mask = 0x7fffffff // 32-bit number with a leading 0 followed by 31 ones [0111 (...) 1111]
   const masked = new BigNumber(fourBytesRange).toNumber() & mask