@bsv/sdk 2.0.0-beta.0 → 2.0.1

package/src/script/__tests/spend.valid.vectors.ts

@@ -1,4 +1,12 @@
-export default [
+export const chronicle = [
+  [
+    '51',
+    'b0b1b2b8b95187',
+    'test'
+  ],
+]
+
+export const preChronicle = [
   [
     'Format is: [scriptSig, scriptPubKey, comment]'
   ],
@@ -397,16 +405,6 @@ export default [
     'a591',
     'test'
   ],
-  [
-    '04ffffff7f01e40164',
-    'a591',
-    'test'
-  ],
-  [
-    '51',
-    'b0b1b2b3b4b5b6b7b8b95187',
-    'test'
-  ],
   [
     '51',
     '61',
@@ -1557,11 +1555,6 @@ export default [
     'a591',
     'test'
   ],
-  [
-    '51',
-    'b0b1b2b3b4b5b6b7b8b95187',
-    'test'
-  ],
   [
     '51',
     '61',

package/src/script/templates/PushDrop.ts

@@ -6,9 +6,8 @@ import {
   Signature,
   PublicKey
 } from '../../primitives/index.js'
-import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import { WalletInterface, WalletProtocol } from '../../wallet/Wallet.interfaces.js'
 import { Transaction } from '../../transaction/index.js'
-import { WalletProtocol } from '../../wallet/Wallet.interfaces.js'
 import { verifyNotNull } from '../../primitives/utils.js'
 
 /**
@@ -58,25 +57,41 @@ export default class PushDrop implements ScriptTemplate {
 
   /**
    * Decodes a PushDrop script back into its token fields and the locking public key. If a signature was present, it will be the last field returned.
-   * Warning: Only works with a P2PK lock at the beginning of the script.
    * @param script PushDrop script to decode back into token fields
+   * @param lockPosition Where the locking public key is positioned in the script ('before' = at start, 'after' = at end after DROP operations)
    * @returns An object containing PushDrop token fields and the locking public key. If a signature was included, it will be the last field.
    */
-  static decode(script: LockingScript): {
+  static decode (script: LockingScript, lockPosition: 'before' | 'after' = 'before'): {
     lockingPublicKey: PublicKey
     fields: number[][]
   } {
-    const lockingPublicKey = PublicKey.fromString(
-      Utils.toHex(verifyNotNull(script.chunks[0].data, 'script.chunks[0].data must have value'))
-    )
+    let lockingPublicKey: PublicKey
+    let startIndex: number
+
+    if (lockPosition === 'before') {
+      lockingPublicKey = PublicKey.fromString(
+        Utils.toHex(verifyNotNull(script.chunks[0].data, 'script.chunks[0].data must have value'))
+      )
+      startIndex = 2
+    } else {
+      // lockPosition === 'after'
+      // Find the public key at the end (after the last DROP/2DROP, before OP_CHECKSIG)
+      const lastChunkIndex = script.chunks.length - 1
+      if (script.chunks[lastChunkIndex].op !== OP.OP_CHECKSIG) {
+        throw new Error('Expected OP_CHECKSIG at the end of the script')
+      }
+      lockingPublicKey = PublicKey.fromString(
+        Utils.toHex(verifyNotNull(script.chunks[lastChunkIndex - 1].data, 'public key chunk data must have value'))
+      )
+      startIndex = 0
+    }
 
     const fields: number[][] = []
-    for (let i = 2; i < script.chunks.length; i++) {
-      const nextOpcode = script.chunks[i + 1]?.op // ✅ Prevent accessing `op` from `undefined`
-      let chunk: number[] = script.chunks[i].data ?? [] // ✅ Ensure `chunk` is always `number[]`
+    for (let i = startIndex; i < script.chunks.length; i++) {
+      const nextOpcode = script.chunks[i + 1]?.op
+      let chunk: number[] = script.chunks[i].data ?? []
 
       if (chunk.length === 0) {
-        // ✅ Only modify `chunk` if it was empty
         if (script.chunks[i].op >= 80 && script.chunks[i].op <= 95) {
           chunk = [script.chunks[i].op - 80]
         } else if (script.chunks[i].op === 0) {
@@ -105,7 +120,7 @@ export default class PushDrop implements ScriptTemplate {
    * @param {WalletInterface} wallet - The wallet interface used for creating signatures and accessing public keys.
    * @param {string} originator — The originator to use with Wallet requests
    */
-  constructor(wallet: WalletInterface, originator?: string) {
+  constructor (wallet: WalletInterface, originator?: string) {
     this.wallet = wallet
     this.originator = originator
   }
@@ -121,7 +136,7 @@ export default class PushDrop implements ScriptTemplate {
    * @param {boolean} [includeSignature=true] - Flag indicating if a signature should be included in the script (default yes).
    * @returns {Promise<LockingScript>} The generated PushDrop locking script.
    */
-  async lock(
+  async lock (
     fields: number[][],
     protocolID: WalletProtocol,
     keyID: string,
@@ -184,7 +199,7 @@ export default class PushDrop implements ScriptTemplate {
    * @param {boolean} [anyoneCanPay=false] - Specifies if the anyone-can-pay flag is set.
    * @returns {Object} An object containing functions to sign the transaction and estimate the script length.
    */
-  unlock(
+  unlock (
     protocolID: WalletProtocol,
     keyID: string,
     counterparty: string,
@@ -193,9 +208,9 @@ export default class PushDrop implements ScriptTemplate {
     sourceSatoshis?: number,
     lockingScript?: LockingScript
   ): {
-    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-    estimateLength: () => Promise<73>
-  } {
+      sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+      estimateLength: () => Promise<73>
+    } {
     return {
       sign: async (
         tx: Transaction,

package/src/script/templates/__tests/PushDrop.test.ts

@@ -259,5 +259,33 @@ describe('PushDrop', () => {
       ).publicKey
       expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
     })
+
+    it('decodes the locking script correctly with lockPosition after', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+
+      const lockingScript = await pushDrop.lock(
+        fields,
+        protocolID,
+        keyID,
+        counterparty,
+        false,
+        true,
+        'after'
+      )
+
+      const decoded = await PushDrop.decode(lockingScript, 'after')
+      expect(decoded.fields).toEqual(fields)
+      const expectedPublicKey = (
+        await wallet.getPublicKey({ protocolID, keyID, counterparty })
+      ).publicKey
+      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    })
   })
 })

package/src/storage/__tests/StorageUploader.test.ts

@@ -15,7 +15,7 @@ describe('StorageUploader Tests', () => {
   let walletClient: WalletClient
 
   // We'll have TWO spies:
-  let authFetchSpy: jest.SpiedFunction<typeof global.fetch>
+  let authFetchSpy: jest.SpyInstance
   let globalFetchSpy: jest.SpiedFunction<typeof global.fetch>
 
   beforeEach(() => {

package/src/transaction/Beef.ts

@@ -2,12 +2,9 @@ import MerklePath from './MerklePath.js'
 import Transaction from './Transaction.js'
 import ChainTracker from './ChainTracker.js'
 import BeefTx from './BeefTx.js'
-import { Reader, Writer, toHex, toArray, verifyNotNull } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, verifyNotNull, ReaderUint8Array, WriterUint8Array, toUint8Array } 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
@@ -112,13 +109,37 @@ export class Beef {
     this.ensureSerializableState()
     if (this.rawBytesCache == null) {
       this.ensureSortedForSerialization()
-      const writer = new Writer()
+      const writer = new WriterUint8Array()
       this.toWriter(writer)
       this.rawBytesCache = writer.toUint8Array()
     }
     return this.rawBytesCache
   }
 
+  private getBeefForAtomic (txid: string): { beef: Beef, writer: WriterUint8Array } {
+    if (this.needsSort) {
+      this.sortTxs()
+    }
+    const tx = this.findTxid(txid)
+    if (tx == null) {
+      throw new Error(`${txid} does not exist in this Beef`)
+    }
+
+    // If the transaction is not the last one, clone and modify
+    const beef = (this.txs[this.txs.length - 1] === tx) ? this : this.clone()
+
+    if (beef !== this) {
+      const i = this.txs.findIndex((t) => t.txid === txid)
+      beef.txs.splice(i + 1)
+    }
+
+    const writer = new WriterUint8Array()
+    writer.writeUInt32LE(ATOMIC_BEEF)
+    writer.writeReverse(toArray(txid, 'hex'))
+
+    return { beef, writer }
+  }
+
   /**
    * @param txid of `beefTx` to find
    * @returns `BeefTx` in `txs` with `txid`.
@@ -308,7 +329,7 @@ export class Beef {
    * @param bumpIndex Optional. If a number, must be valid index into bumps array.
    * @returns txid of rawTx
    */
-  mergeRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
+  mergeRawTx (rawTx: number[] | Uint8Array, bumpIndex?: number): BeefTx {
     this.markMutated(true)
     const newTx: BeefTx = new BeefTx(rawTx, bumpIndex)
     this.removeExistingTxid(newTx.txid)
@@ -394,8 +415,8 @@ export class Beef {
     return beefTx
   }
 
-  mergeBeef (beef: number[] | Beef): void {
-    const b: Beef = Array.isArray(beef) ? Beef.fromBinary(beef) : beef
+  mergeBeef (beef: Beef | number[] | Uint8Array): void {
+    const b: Beef = (beef instanceof Beef) ? beef : Beef.fromBinary(beef)
 
     for (const bump of b.bumps) {
       this.mergeBump(bump)
@@ -549,7 +570,7 @@ export class Beef {
    * Serializes this data to `writer`
    * @param writer
    */
-  toWriter (writer: Writer): void {
+  toWriter (writer: Writer | WriterUint8Array): void {
     writer.writeUInt32LE(this.version)
 
     writer.writeVarIntNum(this.bumps.length)
@@ -566,11 +587,16 @@ export class Beef {
   /**
    * Returns a binary array representing the serialized BEEF
    * @returns A binary array representing the BEEF
+   * @returns An array of byte values containing binary serialization of the BEEF
    */
   toBinary (): number[] {
     return Array.from(this.getSerializedBytes())
   }
 
+  /**
+   * Returns a binary array representing the serialized BEEF
+   * @returns A Uint8Array containing binary serialization of the BEEF
+   */
   toUint8Array (): Uint8Array {
     return this.getSerializedBytes()
   }
@@ -586,30 +612,31 @@ export class Beef {
    * @returns serialized contents of this Beef with AtomicBEEF prefix.
    */
   toBinaryAtomic (txid: string): number[] {
-    if (this.needsSort) {
-      this.sortTxs()
-    }
-    const tx = this.findTxid(txid)
-    if (tx == null) {
-      throw new Error(`${txid} does not exist in this Beef`)
-    }
-
-    // If the transaction is not the last one, clone and modify
-    const beef = (this.txs[this.txs.length - 1] === tx) ? this : this.clone()
-
-    if (beef !== this) {
-      const i = this.txs.findIndex((t) => t.txid === txid)
-      beef.txs.splice(i + 1)
-    }
-
-    const writer = new Writer()
-    writer.writeUInt32LE(ATOMIC_BEEF)
-    writer.writeReverse(toArray(txid, 'hex'))
+    const { beef, writer } = this.getBeefForAtomic(txid)
     beef.toWriter(writer)
-
     return writer.toArray()
   }
 
+  /**
+   * Serialize this Beef as AtomicBEEF.
+   *
+   * `txid` must exist
+   *
+   * after sorting, if txid is not last txid, creates a clone and removes newer txs
+   *
+   * @param txid
+   * @returns serialized contents of this Beef with AtomicBEEF prefix.
+   */
+  toUint8ArrayAtomic (txid: string): Uint8Array {
+    const { beef, writer } = this.getBeefForAtomic(txid)
+    const beefUint8 = beef.getSerializedBytes()
+    const prefix = writer.toUint8Array()
+    const atomic = new Uint8Array(prefix.length + beefUint8.length)
+    atomic.set(prefix, 0)
+    atomic.set(beefUint8, prefix.length)
+    return atomic
+  }
+
   /**
    * Returns a hex string representing the serialized BEEF
    * @returns A hex string representing the BEEF
@@ -619,15 +646,12 @@ export class Beef {
       return this.hexCache
     }
     const bytes = this.getSerializedBytes()
-    const hex =
-      BufferCtor != null
-        ? BufferCtor.from(bytes).toString('hex')
-        : toHex(Array.from(bytes))
+    const hex = toHex(bytes)
     this.hexCache = hex
     return hex
   }
 
-  static fromReader (br: Reader): Beef {
+  static fromReader (br: Reader | ReaderUint8Array): Beef {
     let version = br.readUInt32LE()
     let atomicTxid: string | undefined
     if (version === ATOMIC_BEEF) {
@@ -657,11 +681,11 @@ export class Beef {
 
   /**
    * Constructs an instance of the Beef class based on the provided binary array
-   * @param bin The binary array from which to construct BEEF
+   * @param bin The binary array or Uint8Array from which to construct BEEF
    * @returns An instance of the Beef class constructed from the binary data
    */
-  static fromBinary (bin: number[]): Beef {
-    const br = new Reader(bin)
+  static fromBinary (bin: number[] | Uint8Array): Beef {
+    const br = ReaderUint8Array.makeReader(bin)
     return Beef.fromReader(br)
   }
 
@@ -672,8 +696,8 @@ export class Beef {
    * @returns An instance of the Beef class constructed from the string
    */
   static fromString (s: string, enc: 'hex' | 'utf8' | 'base64' = 'hex'): Beef {
-    const bin = toArray(s, enc)
-    const br = new Reader(bin)
+    const bin = toUint8Array(s, enc)
+    const br = new ReaderUint8Array(bin)
     return Beef.fromReader(br)
   }
 
@@ -825,6 +849,8 @@ export class Beef {
     c.txs = Array.from(this.txs)
     c.txidIndex = undefined
     c.needsSort = this.needsSort
+    c.hexCache = this.hexCache
+    c.rawBytesCache = this.rawBytesCache
     return c
   }
 
@@ -844,7 +870,44 @@ export class Beef {
         i++
       }
     }
-    // TODO: bumps could be trimmed to eliminate unreferenced proofs.
+
+    // Trim unreferenced bumps after removing known txids
+    const referencedBumpIndices = new Set<number>()
+    for (const tx of this.txs) {
+      if (tx.bumpIndex !== undefined) {
+        referencedBumpIndices.add(tx.bumpIndex)
+      }
+    }
+
+    // Check if there are any unreferenced bumps to remove
+    if (referencedBumpIndices.size < this.bumps.length) {
+      // Build mapping of old indices to new indices after removal
+      const indexMap = new Map<number, number>()
+      let newIndex = 0
+      for (let i = 0; i < this.bumps.length; i++) {
+        if (referencedBumpIndices.has(i)) {
+          indexMap.set(i, newIndex)
+          newIndex++
+        }
+      }
+
+      // Remove unreferenced bumps
+      this.bumps = this.bumps.filter((_, i) => referencedBumpIndices.has(i))
+
+      // Update all transaction bumpIndex references
+      for (const tx of this.txs) {
+        if (tx.bumpIndex !== undefined) {
+          const newIndex = indexMap.get(tx.bumpIndex)
+          if (newIndex === undefined) {
+            throw new Error(`Internal error: bumpIndex ${tx.bumpIndex} not found in indexMap`)
+          }
+          tx.bumpIndex = newIndex
+        }
+      }
+
+      mutated = true
+    }
+
     if (mutated) {
       this.markMutated(true)
     }

package/src/transaction/BeefTx.ts

@@ -1,5 +1,5 @@
 import { hash256 } from '../primitives/Hash.js'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, ReaderUint8Array, WriterUint8Array } from '../primitives/utils.js'
 import Transaction from './Transaction.js'
 import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
 
@@ -15,7 +15,7 @@ import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
 export default class BeefTx {
   _bumpIndex?: number
   _tx?: Transaction
-  _rawTx?: number[]
+  _rawTx?: Uint8Array
   _txid?: string
   inputTxids: string[] = []
   /**
@@ -64,10 +64,28 @@ export default class BeefTx {
     return undefined
   }
 
+  /**
+   * Raw transaction bytes, if available as number[]
+   */
   get rawTx (): number[] | undefined {
+    if (this._rawTx != null) {
+      return Array.from(this._rawTx)
+    }
+    if (this._tx != null) {
+      const bytes = this._tx.toUint8Array()
+      this._rawTx = bytes // cache
+      return Array.from(bytes)
+    }
+    return undefined
+  }
+
+  /**
+   * Raw transaction bytes, if available as Uint8Array
+   */
+  get rawTxUint8Array (): Uint8Array | undefined {
     if (this._rawTx != null) return this._rawTx
     if (this._tx != null) {
-      this._rawTx = this._tx.toBinary()
+      this._rawTx = this._tx.toUint8Array()
       return this._rawTx
     }
     return undefined
@@ -77,13 +95,17 @@ export default class BeefTx {
    * @param tx If string, must be a valid txid. If `number[]` must be a valid serialized transaction.
    * @param bumpIndex If transaction already has a proof in the beef to which it will be added.
    */
-  constructor (tx: Transaction | number[] | string, bumpIndex?: number) {
+  constructor (tx: Transaction | Uint8Array | number[] | string, bumpIndex?: number) {
     if (typeof tx === 'string') {
       this._txid = tx
-    } else if (Array.isArray(tx)) {
+    } else if (tx instanceof Uint8Array) {
       this._rawTx = tx
-    } else {
+    } else if (Array.isArray(tx)) {
+      this._rawTx = new Uint8Array(tx)
+    } else if (tx instanceof Transaction) {
       this._tx = tx
+    } else {
+      throw new Error('Invalid transaction data type')
     }
     this.bumpIndex = bumpIndex
     this.updateInputTxids()
@@ -93,7 +115,7 @@ export default class BeefTx {
     return new BeefTx(tx, bumpIndex)
   }
 
-  static fromRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
+  static fromRawTx (rawTx: Uint8Array | number[], bumpIndex?: number): BeefTx {
     return new BeefTx(rawTx, bumpIndex)
   }
 
@@ -106,18 +128,17 @@ export default class BeefTx {
       // If we have a proof, or don't have a parsed transaction
       this.inputTxids = []
     } else {
-      const inputTxids: Record<string, boolean> = {} // ✅ Explicit object type
+      const inputTxids: Set<string> = new Set() // minor perf improvement
       for (const input of this.tx.inputs) {
         if (input.sourceTXID !== undefined && input.sourceTXID !== null && input.sourceTXID !== '') {
-          // ✅ Ensure sourceTXID is defined
-          inputTxids[input.sourceTXID] = true
+          inputTxids.add(input.sourceTXID)
         }
       }
-      this.inputTxids = Object.keys(inputTxids)
+      this.inputTxids = Array.from(inputTxids)
     }
   }
 
-  toWriter (writer: Writer, version: number): void {
+  toWriter (writer: Writer | WriterUint8Array, version: number): void {
     const writeByte = (bb: number): void => {
       writer.writeUInt8(bb)
     }
@@ -130,13 +151,11 @@ export default class BeefTx {
     }
 
     const writeTx = (): void => {
-      if (this._rawTx != null) {
-        writer.write(this._rawTx)
-      } else if (this._tx != null) {
-        writer.write(this._tx.toUint8Array())
-      } else {
+      const bytes = this.rawTxUint8Array
+      if (bytes == null) {
         throw new Error('a valid serialized Transaction is expected')
       }
+      writer.write(bytes)
     }
 
     const writeBumpIndex = (): void => {
@@ -166,8 +185,8 @@ export default class BeefTx {
     }
   }
 
-  static fromReader (br: Reader, version: number): BeefTx {
-    let data: Transaction | number[] | string | undefined
+  static fromReader (br: Reader | ReaderUint8Array, version: number): BeefTx {
+    let data: Transaction | undefined
     let bumpIndex: number | undefined
     let beefTx: BeefTx | undefined
     if (version === BEEF_V2) {

package/src/transaction/MerklePath.ts

@@ -1,7 +1,8 @@
 
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, WriterUint8Array } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 import ChainTracker from './ChainTracker.js'
+import { ReaderUint8Array } from '../primitives/ReaderUint8Array.js'
 
 export interface MerklePathLeaf {
   offset: number
@@ -54,7 +55,7 @@ export default class MerklePath {
   }
 
   static fromReader (
-    reader: Reader,
+    reader: Reader | ReaderUint8Array,
     legalOffsetsOnly: boolean = true
   ): MerklePath {
     const blockHeight = reader.readVarIntNum()
@@ -103,8 +104,8 @@ export default class MerklePath {
    * @param {number[]} bump - The binary array representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromBinary (bump: number[]): MerklePath {
-    const reader = new Reader(bump)
+  static fromBinary (bump: number[] | Uint8Array): MerklePath {
+    const reader = new ReaderUint8Array(bump)
     return MerklePath.fromReader(reader)
   }
 
@@ -181,12 +182,11 @@ export default class MerklePath {
   }
 
   /**
-   * Converts the MerklePath to a binary array format.
+   * Serializes the MerklePath to the writer provided.
    *
-   * @returns {number[]} - The binary array representation of the Merkle Path.
+   * @param writer - The writer to which the Merkle Path will be serialized.
    */
-  toBinary (): number[] {
-    const writer = new Writer()
+  toWriter (writer: Writer | WriterUint8Array): void {
     writer.writeVarIntNum(this.blockHeight)
     const treeHeight = this.path.length
     writer.writeUInt8(treeHeight)
@@ -208,16 +208,37 @@ export default class MerklePath {
         }
       }
     }
+  }
+
+  /**
+   * Converts the MerklePath to a binary array format.
+   *
+   * @returns {number[]} - The binary array representation of the Merkle Path.
+   */
+  toBinary (): number[] {
+    const writer = new Writer()
+    this.toWriter(writer)
     return writer.toArray()
   }
 
+  /**
+   * Converts the MerklePath to a binary array format.
+   *
+   * @returns {Uint8Array} - The binary array representation of the Merkle Path.
+   */
+  toBinaryUint8Array (): Uint8Array {
+    const writer = new WriterUint8Array()
+    this.toWriter(writer)
+    return writer.toUint8Array()
+  }
+
   /**
    * Converts the MerklePath to a hexadecimal string format.
    *
    * @returns {string} - The hexadecimal string representation of the Merkle Path.
    */
   toHex (): string {
-    return toHex(this.toBinary())
+    return toHex(this.toBinaryUint8Array())
   }
 
   //