@bsv/sdk 1.0.0

package/src/script/OP.ts

@@ -0,0 +1,219 @@
+/**
+ * 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

@@ -0,0 +1,426 @@
+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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,36 @@
+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>
+  }
+}