@bsv/sdk 1.8.13 → 1.9.1

package/src/script/Script.ts

@@ -1,6 +1,6 @@
 import ScriptChunk from './ScriptChunk.js'
 import OP from './OP.js'
-import { encode, toHex, Reader, Writer, toArray } from '../primitives/utils.js'
+import { encode, toHex, toArray } from '../primitives/utils.js'
 import BigNumber from '../primitives/BigNumber.js'
 
 /**
@@ -10,8 +10,14 @@ 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
+
 export default class Script {
-  chunks: ScriptChunk[]
+  private _chunks: ScriptChunk[]
+  private parsed: boolean
+  private rawBytesCache?: Uint8Array
+  private hexCache?: string
 
   /**
    * @method fromASM
@@ -110,7 +116,9 @@ export default class Script {
     if (!/^[0-9a-fA-F]+$/.test(hex)) {
       throw new Error('Some elements in this string are not hex encoded.')
     }
-    return Script.fromBinary(toArray(hex, 'hex'))
+    const bin = toArray(hex, 'hex')
+    const rawBytes = Uint8Array.from(bin)
+    return new Script([], rawBytes, hex.toLowerCase(), false)
   }
 
   /**
@@ -122,89 +130,44 @@ export default class Script {
    * const script = Script.fromBinary([0x76, 0xa9, ...])
    */
   static fromBinary (bin: number[]): Script {
-    bin = [...bin]
-    const chunks: ScriptChunk[] = []
-
-    let inConditionalBlock: number = 0
-
-    const br = new Reader(bin)
-    while (!br.eof()) {
-      const op = br.readUInt8()
-
-      // if OP_RETURN and not in a conditional block, do not parse the rest of the data,
-      // rather just return the last chunk as data without prefixing with data length.
-      if (op === OP.OP_RETURN && inConditionalBlock === 0) {
-        chunks.push({
-          op,
-          data: br.read()
-        })
-        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--
-      }
-
-      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 {
-          br.read()
-        }
-        chunks.push({
-          data,
-          op
-        })
-      } else if (op === OP.OP_PUSHDATA2) {
-        try {
-          len = br.readUInt16LE()
-          data = br.read(len)
-        } catch {
-          br.read()
-        }
-        chunks.push({
-          data,
-          op
-        })
-      } else if (op === OP.OP_PUSHDATA4) {
-        try {
-          len = br.readUInt32LE()
-          data = br.read(len)
-        } catch {
-          br.read()
-        }
-        chunks.push({
-          data,
-          op
-        })
-      } else {
-        chunks.push({
-          op
-        })
-      }
-    }
-    return new Script(chunks)
+    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[] = []) {
-    this.chunks = chunks
+  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
   }
 
   /**
@@ -228,7 +191,18 @@ export default class Script {
    * @returns The script in hexadecimal format.
    */
   toHex (): string {
-    return encode(this.toBinary(), 'hex') as 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
   }
 
   /**
@@ -237,32 +211,14 @@ export default class Script {
    * @returns The script in binary array format.
    */
   toBinary (): number[] {
-    const writer = new Writer()
+    return Array.from(this.toUint8Array())
+  }
 
-    for (let i = 0; i < this.chunks.length; i++) {
-      const chunk = this.chunks[i]
-      const op = chunk.op
-      writer.writeUInt8(op)
-      if (op === OP.OP_RETURN && chunk.data != null) { // special case for unformatted data
-        writer.write(chunk.data)
-        break
-      } else if (chunk.data != null) {
-        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)
-        }
-      }
+  toUint8Array (): Uint8Array {
+    if (this.rawBytesCache == null) {
+      this.rawBytesCache = this.serializeChunksToBytes()
     }
-
-    return writer.toArray()
+    return this.rawBytesCache
   }
 
   /**
@@ -272,6 +228,7 @@ export default class Script {
    * @returns This script instance for chaining.
    */
   writeScript (script: Script): Script {
+    this.invalidateSerializationCaches()
     this.chunks = this.chunks.concat(script.chunks)
     return this
   }
@@ -283,6 +240,7 @@ export default class Script {
    * @returns This script instance for chaining.
    */
   writeOpCode (op: number): Script {
+    this.invalidateSerializationCaches()
     this.chunks.push({ op })
     return this
   }
@@ -295,6 +253,7 @@ export default class Script {
    * @returns This script instance for chaining.
    */
   setChunkOpCode (i: number, op: number): Script {
+    this.invalidateSerializationCaches()
     this.chunks[i] = { op }
     return this
   }
@@ -306,6 +265,7 @@ export default class Script {
    * @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
@@ -334,6 +294,7 @@ export default class Script {
    * @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) {
@@ -363,6 +324,7 @@ export default class Script {
    * @returns This script instance for chaining.
    */
   writeNumber (num: number): Script {
+    this.invalidateSerializationCaches()
     this.writeBn(new BigNumber(num))
     return this
   }
@@ -373,6 +335,7 @@ export default class 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) {
@@ -391,6 +354,7 @@ export default class 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]])
@@ -443,6 +407,176 @@ export default class Script {
    * @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 = ''

package/src/script/Spend.ts

@@ -7,7 +7,7 @@ import ScriptChunk from './ScriptChunk.js'
 import { minimallyEncode } from '../primitives/utils.js'
 import ScriptEvaluationError from './ScriptEvaluationError.js'
 import * as Hash from '../primitives/Hash.js'
-import TransactionSignature from '../primitives/TransactionSignature.js'
+import TransactionSignature, { SignatureHashCache } from '../primitives/TransactionSignature.js'
 import PublicKey from '../primitives/PublicKey.js'
 import { verify } from '../primitives/ECDSA.js'
 import TransactionInput from '../transaction/TransactionInput.js'
@@ -152,6 +152,7 @@ export default class Spend {
   memoryLimit: number
   stackMem: number
   altStackMem: number
+  private sigHashCache: SignatureHashCache
 
   /**
    * @constructor
@@ -216,6 +217,7 @@ export default class Spend {
     this.ifStack = []
     this.stackMem = 0
     this.altStackMem = 0
+    this.sigHashCache = { hashOutputsSingle: new Map() }
     this.reset()
   }
 
@@ -228,6 +230,7 @@ export default class Spend {
     this.ifStack = []
     this.stackMem = 0
     this.altStackMem = 0
+    this.sigHashCache = { hashOutputsSingle: new Map() }
   }
 
   private ensureStackMem (additional: number): void {
@@ -353,7 +356,7 @@ export default class Spend {
     pubkey: PublicKey,
     subscript: Script
   ): boolean {
-    const preimage = TransactionSignature.format({
+    const preimage = TransactionSignature.formatBytes({
       sourceTXID: this.sourceTXID,
       sourceOutputIndex: this.sourceOutputIndex,
       sourceSatoshis: this.sourceSatoshis,
@@ -364,7 +367,8 @@ export default class Spend {
       subscript,
       inputSequence: this.inputSequence,
       lockTime: this.lockTime,
-      scope: sig.scope
+      scope: sig.scope,
+      cache: this.sigHashCache
     })
     const hash = new BigNumber(Hash.hash256(preimage))
     return verify(hash, sig, pubkey)

package/src/transaction/Beef.ts

@@ -5,6 +5,9 @@ import BeefTx from './BeefTx.js'
 import { Reader, Writer, toHex, toArray, verifyNotNull } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 
+const BufferCtor =
+  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
+
 export const BEEF_V1 = 4022206465 // 0100BEEF in LE order
 export const BEEF_V2 = 4022206466 // 0200BEEF in LE order
 export const ATOMIC_BEEF = 0x01010101 // 01010101
@@ -73,11 +76,49 @@ export class Beef {
   version: number = BEEF_V2
   atomicTxid: string | undefined = undefined
   private txidIndex: Map<string, BeefTx> | undefined = undefined
+  private rawBytesCache?: Uint8Array
+  private hexCache?: string
+  private needsSort: boolean = true
 
   constructor (version: number = BEEF_V2) {
     this.version = version
   }
 
+  private invalidateSerializationCaches (): void {
+    this.rawBytesCache = undefined
+    this.hexCache = undefined
+  }
+
+  private markMutated (requiresSort: boolean = true): void {
+    this.invalidateSerializationCaches()
+    if (requiresSort) {
+      this.needsSort = true
+    }
+  }
+
+  private ensureSerializableState (): void {
+    for (const tx of this.txs) {
+      void tx.txid
+    }
+  }
+
+  private ensureSortedForSerialization (): void {
+    if (this.needsSort) {
+      this.sortTxs()
+    }
+  }
+
+  private getSerializedBytes (): Uint8Array {
+    this.ensureSerializableState()
+    if (this.rawBytesCache == null) {
+      this.ensureSortedForSerialization()
+      const writer = new Writer()
+      this.toWriter(writer)
+      this.rawBytesCache = writer.toUint8Array()
+    }
+    return this.rawBytesCache
+  }
+
   /**
    * @param txid of `beefTx` to find
    * @returns `BeefTx` in `txs` with `txid`.
@@ -123,6 +164,7 @@ export class Beef {
     }
     this.deleteFromIndex(txid)
     this.txs.splice(i, 1)
+    this.markMutated(true)
     btx = this.mergeTxidOnly(txid)
     return btx
   }
@@ -208,6 +250,7 @@ export class Beef {
    * @returns index of merged bump
    */
   mergeBump (bump: MerklePath): number {
+    this.markMutated(false)
     let bumpIndex: number | undefined
     // If this proof is identical to another one previously added, we use that first. Otherwise, we try to merge it with proofs from the same block.
     for (let i = 0; i < this.bumps.length; i++) {
@@ -266,6 +309,7 @@ export class Beef {
    * @returns txid of rawTx
    */
   mergeRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
+    this.markMutated(true)
     const newTx: BeefTx = new BeefTx(rawTx, bumpIndex)
     this.removeExistingTxid(newTx.txid)
     this.txs.push(newTx)
@@ -285,6 +329,7 @@ export class Beef {
    * @returns txid of tx
    */
   mergeTransaction (tx: Transaction): BeefTx {
+    this.markMutated(true)
     const txid = tx.id('hex')
     this.removeExistingTxid(txid)
     let bumpIndex: number | undefined
@@ -315,6 +360,7 @@ export class Beef {
     if (existingTxIndex >= 0) {
       this.deleteFromIndex(txid)
       this.txs.splice(existingTxIndex, 1)
+      this.markMutated(true)
     }
   }
 
@@ -325,6 +371,7 @@ export class Beef {
       this.txs.push(tx)
       this.addToIndex(tx)
       this.tryToValidateBumpIndex(tx)
+      this.markMutated(true)
     }
     return tx
   }
@@ -521,11 +568,11 @@ export class Beef {
    * @returns A binary array representing the BEEF
    */
   toBinary (): number[] {
-    // Always serialize in dependency sorted order.
-    this.sortTxs()
-    const writer = new Writer()
-    this.toWriter(writer)
-    return writer.toArray()
+    return Array.from(this.getSerializedBytes())
+  }
+
+  toUint8Array (): Uint8Array {
+    return this.getSerializedBytes()
   }
 
   /**
@@ -539,7 +586,9 @@ export class Beef {
    * @returns serialized contents of this Beef with AtomicBEEF prefix.
    */
   toBinaryAtomic (txid: string): number[] {
-    this.sortTxs()
+    if (this.needsSort) {
+      this.sortTxs()
+    }
     const tx = this.findTxid(txid)
     if (tx == null) {
       throw new Error(`${txid} does not exist in this Beef`)
@@ -566,7 +615,16 @@ export class Beef {
    * @returns A hex string representing the BEEF
    */
   toHex (): string {
-    return toHex(this.toBinary())
+    if (this.hexCache != null) {
+      return this.hexCache
+    }
+    const bytes = this.getSerializedBytes()
+    const hex =
+      BufferCtor != null
+        ? BufferCtor.from(bytes).toString('hex')
+        : toHex(Array.from(bytes))
+    this.hexCache = hex
+    return hex
   }
 
   static fromReader (br: Reader): Beef {
@@ -745,6 +803,9 @@ export class Beef {
       .concat(txidOnly)
       .concat(result)
 
+    this.needsSort = false
+    this.invalidateSerializationCaches()
+
     return {
       missingInputs: Object.keys(missingInputs),
       notValid: txsNotValid.map((tx) => tx.txid),
@@ -763,6 +824,7 @@ export class Beef {
     c.bumps = Array.from(this.bumps)
     c.txs = Array.from(this.txs)
     c.txidIndex = undefined
+    c.needsSort = this.needsSort
     return c
   }
 
@@ -771,16 +833,21 @@ export class Beef {
    * @param knownTxids
    */
   trimKnownTxids (knownTxids: string[]): void {
+    let mutated = false
     for (let i = 0; i < this.txs.length;) {
       const tx = this.txs[i]
       if (tx.isTxidOnly && knownTxids.includes(tx.txid)) {
         this.deleteFromIndex(tx.txid)
         this.txs.splice(i, 1)
+        mutated = true
       } else {
         i++
       }
     }
     // TODO: bumps could be trimmed to eliminate unreferenced proofs.
+    if (mutated) {
+      this.markMutated(true)
+    }
   }
 
   /**

package/src/transaction/BeefTx.ts

@@ -133,7 +133,7 @@ export default class BeefTx {
       if (this._rawTx != null) {
         writer.write(this._rawTx)
       } else if (this._tx != null) {
-        writer.write(this._tx.toBinary())
+        writer.write(this._tx.toUint8Array())
       } else {
         throw new Error('a valid serialized Transaction is expected')
       }