@bsv/wallet-toolbox 1.7.16 → 1.7.18

package/mobile/node_modules/@bsv/sdk/src/script/Script.ts

@@ -1,591 +0,0 @@
-import ScriptChunk from './ScriptChunk.js'
-import OP from './OP.js'
-import { encode, toHex, toArray } from '../primitives/utils.js'
-import BigNumber from '../primitives/BigNumber.js'
-
-/**
- * The Script class represents a script in a Bitcoin SV transaction,
- * encapsulating the functionality to construct, parse, and serialize
- * scripts used in both locking (output) and unlocking (input) scripts.
- *
- * @property {ScriptChunk[]} chunks - An array of script chunks that make up the script.
- */
-const BufferCtor =
-  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
-
-export default class Script {
-  private _chunks: ScriptChunk[]
-  private parsed: boolean
-  private rawBytesCache?: Uint8Array
-  private hexCache?: string
-
-  /**
-   * @method fromASM
-   * Static method to construct a Script instance from an ASM (Assembly) formatted string.
-   * @param asm - The script in ASM string format.
-   * @returns A new Script instance.
-   * @example
-   * const script = Script.fromASM("OP_DUP OP_HASH160 abcd... OP_EQUALVERIFY OP_CHECKSIG")
-   */
-  static fromASM (asm: string): Script {
-    const chunks: ScriptChunk[] = []
-    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]
-      }
-
-      // 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
-      }
-    }
-    return new Script(chunks)
-  }
-
-  /**
-   * @method fromHex
-   * Static method to construct a Script instance from a hexadecimal string.
-   * @param hex - The script in hexadecimal format.
-   * @returns A new Script instance.
-   * @example
-   * const script = Script.fromHex("76a9...");
-   */
-  static fromHex (hex: string): Script {
-    if (hex.length === 0) return Script.fromBinary([])
-    if (hex.length % 2 !== 0) {
-      throw new Error(
-        'There is an uneven number of characters in the string which suggests it is not hex encoded.'
-      )
-    }
-    if (!/^[0-9a-fA-F]+$/.test(hex)) {
-      throw new Error('Some elements in this string are not hex encoded.')
-    }
-    const bin = toArray(hex, 'hex')
-    const rawBytes = Uint8Array.from(bin)
-    return new Script([], rawBytes, hex.toLowerCase(), false)
-  }
-
-  /**
-   * @method fromBinary
-   * Static method to construct a Script instance from a binary array.
-   * @param bin - The script in binary array format.
-   * @returns A new Script instance.
-   * @example
-   * const script = Script.fromBinary([0x76, 0xa9, ...])
-   */
-  static fromBinary (bin: number[]): Script {
-    const rawBytes = Uint8Array.from(bin)
-    return new Script([], rawBytes, undefined, false)
-  }
-
-  /**
-   * @constructor
-   * Constructs a new Script object.
-   * @param chunks=[] - An array of script chunks to directly initialize the script.
-   * @param rawBytesCache - Optional serialized bytes that can be reused instead of reserializing `chunks`.
-   * @param hexCache - Optional lowercase hex string that matches the serialized bytes, used to satisfy `toHex` quickly.
-   * @param parsed - When false the script defers parsing `rawBytesCache` until `chunks` is accessed; defaults to true.
-   */
-  constructor (chunks: ScriptChunk[] = [], rawBytesCache?: Uint8Array, hexCache?: string, parsed: boolean = true) {
-    this._chunks = chunks
-    this.parsed = parsed
-    this.rawBytesCache = rawBytesCache
-    this.hexCache = hexCache
-  }
-
-  get chunks (): ScriptChunk[] {
-    this.ensureParsed()
-    return this._chunks
-  }
-
-  set chunks (value: ScriptChunk[]) {
-    this._chunks = value
-    this.parsed = true
-    this.invalidateSerializationCaches()
-  }
-
-  private ensureParsed (): void {
-    if (this.parsed) return
-    if (this.rawBytesCache != null) {
-      this._chunks = Script.parseChunks(this.rawBytesCache)
-    } else {
-      this._chunks = []
-    }
-    this.parsed = true
-  }
-
-  /**
-   * @method toASM
-   * Serializes the script to an ASM formatted string.
-   * @returns The script in ASM string format.
-   */
-  toASM (): string {
-    let str = ''
-    for (let i = 0; i < this.chunks.length; i++) {
-      const chunk = this.chunks[i]
-      str += this._chunkToString(chunk)
-    }
-
-    return str.slice(1)
-  }
-
-  /**
-   * @method toHex
-   * Serializes the script to a hexadecimal string.
-   * @returns The script in hexadecimal format.
-   */
-  toHex (): string {
-    if (this.hexCache != null) {
-      return this.hexCache
-    }
-    if (this.rawBytesCache == null) {
-      this.rawBytesCache = this.serializeChunksToBytes()
-    }
-    const hex =
-      BufferCtor != null
-        ? BufferCtor.from(this.rawBytesCache).toString('hex')
-        : (encode(Array.from(this.rawBytesCache), 'hex') as string)
-    this.hexCache = hex
-    return hex
-  }
-
-  /**
-   * @method toBinary
-   * Serializes the script to a binary array.
-   * @returns The script in binary array format.
-   */
-  toBinary (): number[] {
-    return Array.from(this.toUint8Array())
-  }
-
-  toUint8Array (): Uint8Array {
-    if (this.rawBytesCache == null) {
-      this.rawBytesCache = this.serializeChunksToBytes()
-    }
-    return this.rawBytesCache
-  }
-
-  /**
-   * @method writeScript
-   * Appends another script to this script.
-   * @param script - The script to append.
-   * @returns This script instance for chaining.
-   */
-  writeScript (script: Script): Script {
-    this.invalidateSerializationCaches()
-    this.chunks = this.chunks.concat(script.chunks)
-    return this
-  }
-
-  /**
-   * @method writeOpCode
-   * Appends an opcode to the script.
-   * @param op - The opcode to append.
-   * @returns This script instance for chaining.
-   */
-  writeOpCode (op: number): Script {
-    this.invalidateSerializationCaches()
-    this.chunks.push({ op })
-    return this
-  }
-
-  /**
-   * @method setChunkOpCode
-   * Sets the opcode of a specific chunk in the script.
-   * @param i - The index of the chunk.
-   * @param op - The opcode to set.
-   * @returns This script instance for chaining.
-   */
-  setChunkOpCode (i: number, op: number): Script {
-    this.invalidateSerializationCaches()
-    this.chunks[i] = { op }
-    return this
-  }
-
-  /**
-   * @method writeBn
-   * Appends a BigNumber to the script as an opcode.
-   * @param bn - The BigNumber to append.
-   * @returns This script instance for chaining.
-   */
-  writeBn (bn: BigNumber): Script {
-    this.invalidateSerializationCaches()
-    if (bn.cmpn(0) === OP.OP_0) {
-      this.chunks.push({
-        op: OP.OP_0
-      })
-    } else if (bn.cmpn(-1) === 0) {
-      this.chunks.push({
-        op: OP.OP_1NEGATE
-      })
-    } else if (bn.cmpn(1) >= 0 && bn.cmpn(16) <= 0) {
-      // see OP_1 - OP_16
-      this.chunks.push({
-        op: bn.toNumber() + OP.OP_1 - 1
-      })
-    } else {
-      const buf = bn.toSm('little')
-      this.writeBin(buf)
-    }
-    return this
-  }
-
-  /**
-   * @method writeBin
-   * Appends binary data to the script, determining the appropriate opcode based on length.
-   * @param bin - The binary data to append.
-   * @returns This script instance for chaining.
-   * @throws {Error} Throws an error if the data is too large to be pushed.
-   */
-  writeBin (bin: number[]): Script {
-    this.invalidateSerializationCaches()
-    let op: number
-    const data = bin.length > 0 ? bin : undefined
-    if (bin.length > 0 && bin.length < OP.OP_PUSHDATA1) {
-      op = bin.length
-    } else if (bin.length === 0) {
-      op = OP.OP_0
-    } else if (bin.length < Math.pow(2, 8)) {
-      op = OP.OP_PUSHDATA1
-    } else if (bin.length < Math.pow(2, 16)) {
-      op = OP.OP_PUSHDATA2
-    } else if (bin.length < Math.pow(2, 32)) {
-      op = OP.OP_PUSHDATA4
-    } else {
-      throw new Error("You can't push that much data")
-    }
-    this.chunks.push({
-      data,
-      op
-    })
-    return this
-  }
-
-  /**
-   * @method writeNumber
-   * Appends a number to the script.
-   * @param num - The number to append.
-   * @returns This script instance for chaining.
-   */
-  writeNumber (num: number): Script {
-    this.invalidateSerializationCaches()
-    this.writeBn(new BigNumber(num))
-    return this
-  }
-
-  /**
-   * @method removeCodeseparators
-   * Removes all OP_CODESEPARATOR opcodes from the script.
-   * @returns This script instance for chaining.
-   */
-  removeCodeseparators (): Script {
-    this.invalidateSerializationCaches()
-    const chunks: ScriptChunk[] = []
-    for (let i = 0; i < this.chunks.length; i++) {
-      if (this.chunks[i].op !== OP.OP_CODESEPARATOR) {
-        chunks.push(this.chunks[i])
-      }
-    }
-    this.chunks = chunks
-    return this
-  }
-
-  /**
-   * Deletes the given item wherever it appears in the current script.
-   *
-   * @param script - The script containing the item to delete from the current script.
-   *
-   * @returns This script instance for chaining.
-   */
-  findAndDelete (script: Script): Script {
-    this.invalidateSerializationCaches()
-    const buf = script.toHex()
-    for (let i = 0; i < this.chunks.length; i++) {
-      const script2 = new Script([this.chunks[i]])
-      const buf2 = script2.toHex()
-      if (buf === buf2) {
-        this.chunks.splice(i, 1)
-      }
-    }
-    return this
-  }
-
-  /**
-   * @method isPushOnly
-   * Checks if the script contains only push data operations.
-   * @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]
-      const opCodeNum = chunk.op
-      if (opCodeNum > OP.OP_16) {
-        return false
-      }
-    }
-    return true
-  }
-
-  /**
-   * @method isLockingScript
-   * Determines if the script is a locking script.
-   * @returns True if the script is a locking script, otherwise false.
-   */
-  isLockingScript (): boolean {
-    throw new Error('Not implemented')
-  }
-
-  /**
-   * @method isUnlockingScript
-   * Determines if the script is an unlocking script.
-   * @returns True if the script is an unlocking script, otherwise false.
-   */
-  isUnlockingScript (): boolean {
-    throw new Error('Not implemented')
-  }
-
-  /**
-   * @private
-   * @method _chunkToString
-   * Converts a script chunk to its string representation.
-   * @param chunk - The script chunk.
-   * @returns The string representation of the chunk.
-   */
-  private static computeSerializedLength (chunks: ScriptChunk[]): number {
-    let total = 0
-    for (const chunk of chunks) {
-      total += 1
-      if (chunk.data == null) continue
-      const len = chunk.data.length
-      if (chunk.op === OP.OP_RETURN) {
-        total += len
-        break
-      }
-      if (chunk.op < OP.OP_PUSHDATA1) {
-        total += len
-      } else if (chunk.op === OP.OP_PUSHDATA1) {
-        total += 1 + len
-      } else if (chunk.op === OP.OP_PUSHDATA2) {
-        total += 2 + len
-      } else if (chunk.op === OP.OP_PUSHDATA4) {
-        total += 4 + len
-      }
-    }
-    return total
-  }
-
-  private serializeChunksToBytes (): Uint8Array {
-    const chunks = this.chunks
-    const totalLength = Script.computeSerializedLength(chunks)
-    const bytes = new Uint8Array(totalLength)
-    let offset = 0
-
-    for (let i = 0; i < chunks.length; i++) {
-      const chunk = chunks[i]
-      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)
-    }
-
-    return bytes
-  }
-
-  private invalidateSerializationCaches (): void {
-    this.rawBytesCache = undefined
-    this.hexCache = undefined
-  }
-
-  private static writeChunkData (
-    target: Uint8Array,
-    offset: number,
-    op: number,
-    data: number[]
-  ): number {
-    const len = data.length
-    if (op < OP.OP_PUSHDATA1) {
-      target.set(data, offset)
-      return offset + len
-    } else if (op === OP.OP_PUSHDATA1) {
-      target[offset++] = len & 0xff
-      target.set(data, offset)
-      return offset + len
-    } else if (op === OP.OP_PUSHDATA2) {
-      target[offset++] = len & 0xff
-      target[offset++] = (len >> 8) & 0xff
-      target.set(data, offset)
-      return offset + len
-    } else if (op === OP.OP_PUSHDATA4) {
-      const size = len >>> 0
-      target[offset++] = size & 0xff
-      target[offset++] = (size >> 8) & 0xff
-      target[offset++] = (size >> 16) & 0xff
-      target[offset++] = (size >> 24) & 0xff
-      target.set(data, offset)
-      return offset + len
-    }
-    return offset
-  }
-
-  private static parseChunks (bytes: ArrayLike<number>): ScriptChunk[] {
-    const chunks: ScriptChunk[] = []
-    const length = bytes.length
-    let pos = 0
-    let inConditionalBlock = 0
-
-    while (pos < length) {
-      const op = bytes[pos++] ?? 0
-
-      if (op === OP.OP_RETURN && inConditionalBlock === 0) {
-        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
-      ) {
-        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
-        })
-        pos = end
-      } else if (op === OP.OP_PUSHDATA1) {
-        const len = pos < length ? bytes[pos++] ?? 0 : 0
-        const end = Math.min(pos + len, length)
-        chunks.push({
-          data: Script.copyRange(bytes, pos, end),
-          op
-        })
-        pos = end
-      } else if (op === OP.OP_PUSHDATA2) {
-        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
-        })
-        pos = end
-      } else if (op === OP.OP_PUSHDATA4) {
-        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
-        })
-        pos = end
-      } else {
-        chunks.push({ op })
-      }
-    }
-
-    return chunks
-  }
-
-  private static copyRange (
-    bytes: ArrayLike<number>,
-    start: number,
-    end: number
-  ): number[] {
-    const size = Math.max(end - start, 0)
-    const data = new Array(size)
-    for (let i = 0; i < size; i++) {
-      data[i] = bytes[start + i] ?? 0
-    }
-    return data
-  }
-
-  private _chunkToString (chunk: ScriptChunk): string {
-    const op = chunk.op
-    let str = ''
-    if (typeof chunk.data === 'undefined') {
-      const val = OP[op] as string
-      str = `${str} ${val}`
-    } else {
-      str = `${str} ${toHex(chunk.data)}`
-    }
-    return str
-  }
-}

package/mobile/node_modules/@bsv/sdk/src/script/ScriptChunk.ts

@@ -1,7 +0,0 @@
-/**
- * A representation of a chunk of a script, which includes an opcode. For push operations, the associated data to push onto the stack is also included.
- */
-export default interface ScriptChunk {
-  op: number
-  data?: number[]
-}

package/mobile/node_modules/@bsv/sdk/src/script/ScriptEvaluationError.ts

@@ -1,44 +0,0 @@
-import { toHex } from '../primitives/utils.js'
-export default class ScriptEvaluationError extends Error {
-  txid: string
-  outputIndex: number
-  context: 'UnlockingScript' | 'LockingScript'
-  programCounter: number
-  stackState: number[][]
-  altStackState: number[][]
-  ifStackState: boolean[]
-  stackMem: number
-  altStackMem: number
-
-  constructor (params: {
-    message: string
-    txid: string
-    outputIndex: number
-    context: 'UnlockingScript' | 'LockingScript'
-    programCounter: number
-    stackState: number[][]
-    altStackState: number[][]
-    ifStackState: boolean[]
-    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 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})`
-    const ifStackInfo = `IfStack: [${params.ifStackState.join(', ')}]`
-    const fullMessage = `Script evaluation error: ${params.message}\nTXID: ${params.txid}, OutputIdx: ${params.outputIndex}\n${pcInfo}\n${stackInfo}\n${altStackInfo}\n${ifStackInfo}`
-    super(fullMessage)
-    this.name = this.constructor.name
-    this.txid = params.txid
-    this.outputIndex = params.outputIndex
-    this.context = params.context
-    this.programCounter = params.programCounter
-    this.stackState = params.stackState.map(s => s.slice())
-    this.altStackState = params.altStackState.map(s => s.slice())
-    this.ifStackState = params.ifStackState.slice()
-    this.stackMem = params.stackMem
-    this.altStackMem = params.altStackMem
-  }
-}

package/mobile/node_modules/@bsv/sdk/src/script/ScriptTemplate.ts

@@ -1,30 +0,0 @@
-import LockingScript from './LockingScript.js'
-import ScriptTemplateUnlock from './ScriptTemplateUnlock.js'
-
-/**
- * @interface
- *
- * This interface defines the structure for script templates used in Bitcoin transactions.
- * It provides methods for creating locking scripts, unlocking scripts, and estimating the length of unlocking scripts.
- */
-export default interface ScriptTemplate {
-  /**
-   * Creates a locking script with the given parameters.
-   *
-   * @param {...any[]} params - The parameters required to create the locking script.
-   * @returns {LockingScript} - An instance of LockingScript, or a Promise for one.
-   */
-  lock: (...params: any[]) => LockingScript | Promise<LockingScript>
-
-  /**
-   * Creates a function that generates an unlocking script along with its signature and length estimation.
-   *
-   * This method returns an object containing two functions:
-   * 1. `sign` - A function that, when called with a transaction and an input index, returns an UnlockingScript instance.
-   * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
-   *
-   * @param {...any[]} params - The parameters required to create the unlocking script.
-   * @returns {ScriptTemplateUnlock} - An object containing the `sign` and `estimateLength` functions.
-   */
-  unlock: (...params: any[]) => ScriptTemplateUnlock
-}

package/mobile/node_modules/@bsv/sdk/src/script/ScriptTemplateUnlock.ts

@@ -1,7 +0,0 @@
-import UnlockingScript from './UnlockingScript.js'
-import Transaction from '../transaction/Transaction.js'
-
-export default interface ScriptTemplateUnlock {
-  sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-  estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
-}