@bsv/sdk 1.0.0 → 1.0.1

package/src/script/OP.ts

@@ -1,219 +0,0 @@
-/**
- * An object mapping opcode names (such as OP_DUP) to their corresponding numbers (such as 0x76), and vice versa.
- */
-const OP = {
-  // push value
-  OP_FALSE: 0x00,
-  OP_0: 0x00,
-  OP_PUSHDATA1: 0x4c,
-  OP_PUSHDATA2: 0x4d,
-  OP_PUSHDATA4: 0x4e,
-  OP_1NEGATE: 0x4f,
-  OP_RESERVED: 0x50,
-  OP_TRUE: 0x51,
-  OP_1: 0x51,
-  OP_2: 0x52,
-  OP_3: 0x53,
-  OP_4: 0x54,
-  OP_5: 0x55,
-  OP_6: 0x56,
-  OP_7: 0x57,
-  OP_8: 0x58,
-  OP_9: 0x59,
-  OP_10: 0x5a,
-  OP_11: 0x5b,
-  OP_12: 0x5c,
-  OP_13: 0x5d,
-  OP_14: 0x5e,
-  OP_15: 0x5f,
-  OP_16: 0x60,
-
-  // control
-  OP_NOP: 0x61,
-  OP_VER: 0x62,
-  OP_IF: 0x63,
-  OP_NOTIF: 0x64,
-  OP_VERIF: 0x65,
-  OP_VERNOTIF: 0x66,
-  OP_ELSE: 0x67,
-  OP_ENDIF: 0x68,
-  OP_VERIFY: 0x69,
-  OP_RETURN: 0x6a,
-
-  // stack ops
-  OP_TOALTSTACK: 0x6b,
-  OP_FROMALTSTACK: 0x6c,
-  OP_2DROP: 0x6d,
-  OP_2DUP: 0x6e,
-  OP_3DUP: 0x6f,
-  OP_2OVER: 0x70,
-  OP_2ROT: 0x71,
-  OP_2SWAP: 0x72,
-  OP_IFDUP: 0x73,
-  OP_DEPTH: 0x74,
-  OP_DROP: 0x75,
-  OP_DUP: 0x76,
-  OP_NIP: 0x77,
-  OP_OVER: 0x78,
-  OP_PICK: 0x79,
-  OP_ROLL: 0x7a,
-  OP_ROT: 0x7b,
-  OP_SWAP: 0x7c,
-  OP_TUCK: 0x7d,
-
-  // data manipulation ops
-  OP_CAT: 0x7e,
-  OP_SUBSTR: 0x7f, // Replaced in BSV
-  OP_SPLIT: 0x7f,
-  OP_LEFT: 0x80, // Replaced in BSV
-  OP_NUM2BIN: 0x80,
-  OP_RIGHT: 0x81, // Replaced in BSV
-  OP_BIN2NUM: 0x81,
-  OP_SIZE: 0x82,
-
-  // bit logic
-  OP_INVERT: 0x83,
-  OP_AND: 0x84,
-  OP_OR: 0x85,
-  OP_XOR: 0x86,
-  OP_EQUAL: 0x87,
-  OP_EQUALVERIFY: 0x88,
-  OP_RESERVED1: 0x89,
-  OP_RESERVED2: 0x8a,
-
-  // numeric
-  OP_1ADD: 0x8b,
-  OP_1SUB: 0x8c,
-  OP_2MUL: 0x8d,
-  OP_2DIV: 0x8e,
-  OP_NEGATE: 0x8f,
-  OP_ABS: 0x90,
-  OP_NOT: 0x91,
-  OP_0NOTEQUAL: 0x92,
-
-  OP_ADD: 0x93,
-  OP_SUB: 0x94,
-  OP_MUL: 0x95,
-  OP_DIV: 0x96,
-  OP_MOD: 0x97,
-  OP_LSHIFT: 0x98,
-  OP_RSHIFT: 0x99,
-
-  OP_BOOLAND: 0x9a,
-  OP_BOOLOR: 0x9b,
-  OP_NUMEQUAL: 0x9c,
-  OP_NUMEQUALVERIFY: 0x9d,
-  OP_NUMNOTEQUAL: 0x9e,
-  OP_LESSTHAN: 0x9f,
-  OP_GREATERTHAN: 0xa0,
-  OP_LESSTHANOREQUAL: 0xa1,
-  OP_GREATERTHANOREQUAL: 0xa2,
-  OP_MIN: 0xa3,
-  OP_MAX: 0xa4,
-
-  OP_WITHIN: 0xa5,
-
-  // crypto
-  OP_RIPEMD160: 0xa6,
-  OP_SHA1: 0xa7,
-  OP_SHA256: 0xa8,
-  OP_HASH160: 0xa9,
-  OP_HASH256: 0xaa,
-  OP_CODESEPARATOR: 0xab,
-  OP_CHECKSIG: 0xac,
-  OP_CHECKSIGVERIFY: 0xad,
-  OP_CHECKMULTISIG: 0xae,
-  OP_CHECKMULTISIGVERIFY: 0xaf,
-
-  // expansion
-  OP_NOP1: 0xb0,
-  OP_NOP2: 0xb1,
-  OP_NOP3: 0xb2,
-  OP_NOP4: 0xb3,
-  OP_NOP5: 0xb4,
-  OP_NOP6: 0xb5,
-  OP_NOP7: 0xb6,
-  OP_NOP8: 0xb7,
-  OP_NOP9: 0xb8,
-  OP_NOP10: 0xb9,
-  OP_NOP11: 0xba,
-  OP_NOP12: 0xbb,
-  OP_NOP13: 0xbc,
-  OP_NOP14: 0xbd,
-  OP_NOP15: 0xbe,
-  OP_NOP16: 0xbf,
-  OP_NOP17: 0xc0,
-  OP_NOP18: 0xc1,
-  OP_NOP19: 0xc2,
-  OP_NOP20: 0xc3,
-  OP_NOP21: 0xc4,
-  OP_NOP22: 0xc5,
-  OP_NOP23: 0xc6,
-  OP_NOP24: 0xc7,
-  OP_NOP25: 0xc8,
-  OP_NOP26: 0xc9,
-  OP_NOP27: 0xca,
-  OP_NOP28: 0xcb,
-  OP_NOP29: 0xcc,
-  OP_NOP30: 0xcd,
-  OP_NOP31: 0xce,
-  OP_NOP32: 0xcf,
-  OP_NOP33: 0xd0,
-  OP_NOP34: 0xd1,
-  OP_NOP35: 0xd2,
-  OP_NOP36: 0xd3,
-  OP_NOP37: 0xd4,
-  OP_NOP38: 0xd5,
-  OP_NOP39: 0xd6,
-  OP_NOP40: 0xd7,
-  OP_NOP41: 0xd8,
-  OP_NOP42: 0xd9,
-  OP_NOP43: 0xda,
-  OP_NOP44: 0xdb,
-  OP_NOP45: 0xdc,
-  OP_NOP46: 0xdd,
-  OP_NOP47: 0xde,
-  OP_NOP48: 0xdf,
-  OP_NOP49: 0xe0,
-  OP_NOP50: 0xe1,
-  OP_NOP51: 0xe2,
-  OP_NOP52: 0xe3,
-  OP_NOP53: 0xe4,
-  OP_NOP54: 0xe5,
-  OP_NOP55: 0xe6,
-  OP_NOP56: 0xe7,
-  OP_NOP57: 0xe8,
-  OP_NOP58: 0xe9,
-  OP_NOP59: 0xea,
-  OP_NOP60: 0xeb,
-  OP_NOP61: 0xec,
-  OP_NOP62: 0xed,
-  OP_NOP63: 0xee,
-  OP_NOP64: 0xef,
-  OP_NOP65: 0xf0,
-  OP_NOP66: 0xf1,
-  OP_NOP67: 0xf2,
-  OP_NOP68: 0xf3,
-  OP_NOP69: 0xf4,
-  OP_NOP70: 0xf5,
-  OP_NOP71: 0xf6,
-  OP_NOP72: 0xf7,
-  OP_NOP73: 0xf8,
-  OP_NOP77: 0xfc,
-
-  // template matching params
-  OP_SMALLDATA: 0xf9,
-  OP_SMALLINTEGER: 0xfa,
-  OP_PUBKEYS: 0xfb,
-  OP_PUBKEYHASH: 0xfd,
-  OP_PUBKEY: 0xfe,
-
-  OP_INVALIDOPCODE: 0xff
-}
-
-for (const name in OP) {
-  OP[OP[name]] = name
-  OP[String(OP[name])] = name
-}
-
-export default OP

package/src/script/Script.ts

@@ -1,426 +0,0 @@
-import ScriptChunk from './ScriptChunk.js'
-import OP from './OP.js'
-import { encode, toHex, Reader, Writer, 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.
- */
-export default class Script {
-  chunks: ScriptChunk[]
-
-  /**
-   * @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
-      if (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 {
-    return Script.fromBinary(toArray(hex, 'hex'))
-  }
-
-  /**
-   * @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 {
-    bin = [...bin]
-    const chunks: ScriptChunk[] = []
-
-    const br = new Reader(bin)
-    while (!br.eof()) {
-      const op = br.readUInt8()
-
-      let len = 0
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      let data: number[] = []
-      if (op > 0 && op < OP.OP_PUSHDATA1) {
-        len = op
-        chunks.push({
-          data: br.read(len),
-          op
-        })
-      } else if (op === OP.OP_PUSHDATA1) {
-        try {
-          len = br.readUInt8()
-          data = br.read(len)
-        } catch (err) {
-          br.read()
-        }
-        chunks.push({
-          data,
-          op
-        })
-      } else if (op === OP.OP_PUSHDATA2) {
-        try {
-          len = br.readUInt16LE()
-          data = br.read(len)
-        } catch (err) {
-          br.read()
-        }
-        chunks.push({
-          data,
-          op
-        })
-      } else if (op === OP.OP_PUSHDATA4) {
-        try {
-          len = br.readUInt32LE()
-          data = br.read(len)
-        } catch (err) {
-          br.read()
-        }
-        chunks.push({
-          data,
-          op
-        })
-      } else {
-        chunks.push({
-          op
-        })
-      }
-    }
-    return new Script(chunks)
-  }
-
-  /**
-   * @constructor
-   * Constructs a new Script object.
-   * @param chunks=[] - An array of script chunks to directly initialize the script.
-   */
-  constructor (chunks: ScriptChunk[] = []) {
-    this.chunks = chunks
-  }
-
-  /**
-   * @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 {
-    return encode(this.toBinary(), 'hex') as string
-  }
-
-  /**
-   * @method toBinary
-   * Serializes the script to a binary array.
-   * @returns The script in binary array format.
-   */
-  toBinary (): number[] {
-    const writer = new Writer()
-
-    for (let i = 0; i < this.chunks.length; i++) {
-      const chunk = this.chunks[i]
-      const op = chunk.op
-      writer.writeUInt8(op)
-      if (chunk.data) {
-        if (op < OP.OP_PUSHDATA1) {
-          writer.write(chunk.data)
-        } else if (op === OP.OP_PUSHDATA1) {
-          writer.writeUInt8(chunk.data.length)
-          writer.write(chunk.data)
-        } else if (op === OP.OP_PUSHDATA2) {
-          writer.writeUInt16LE(chunk.data.length)
-          writer.write(chunk.data)
-        } else if (op === OP.OP_PUSHDATA4) {
-          writer.writeUInt32LE(chunk.data.length)
-          writer.write(chunk.data)
-        }
-      }
-    }
-
-    return writer.toArray()
-  }
-
-  /**
-   * @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.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.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.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 {
-    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 {
-    let op
-    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: bin,
-      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.writeBn(new BigNumber(num))
-    return this
-  }
-
-  /**
-   * @method removeCodeseparators
-   * Removes all OP_CODESEPARATOR opcodes from the script.
-   * @returns This script instance for chaining.
-   */
-  removeCodeseparators (): Script {
-    const chunks = []
-    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 {
-    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 _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/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/src/script/ScriptTemplate.ts

@@ -1,36 +0,0 @@
-import LockingScript from './LockingScript.js'
-import UnlockingScript from './UnlockingScript.js'
-import Transaction from '../transaction/Transaction.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.
-   */
-  lock: (...params: any) => 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 {Object} - An object containing the `sign` and `estimateLength` functions.
-   */
-  unlock: (...params: any) =>
-  {
-    sign: (tx: Transaction, inputIndex: number) =>
-    Promise<UnlockingScript>
-    estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
-  }
-}