@bsv/sdk 2.0.0-beta.0 → 2.0.0

package/src/transaction/Transaction.ts

@@ -3,7 +3,7 @@ import TransactionInput from './TransactionInput.js'
 import TransactionOutput from './TransactionOutput.js'
 import UnlockingScript from '../script/UnlockingScript.js'
 import LockingScript from '../script/LockingScript.js'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, ReaderUint8Array, toUint8Array, WriterUint8Array } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 import FeeModel from './FeeModel.js'
 import LivePolicy from './fee-models/LivePolicy.js'
@@ -16,9 +16,6 @@ import { defaultChainTracker } from './chaintrackers/DefaultChainTracker.js'
 import { Beef, BEEF_V1 } from './Beef.js'
 import P2PKH from '../script/templates/P2PKH.js'
 
-const BufferCtor =
-  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
-
 /**
  * Represents a complete Bitcoin transaction. This class encapsulates all the details
  * required for creating, signing, and processing a Bitcoin transaction, including
@@ -109,7 +106,7 @@ export default class Transaction {
    * @param txid Optional TXID of the transaction to retrieve from the BEEF data.
    * @returns An anchored transaction, linked to its associated inputs populated with merkle paths.
    */
-  static fromBEEF (beef: number[], txid?: string): Transaction {
+  static fromBEEF (beef: number[] | Uint8Array, txid?: string): Transaction {
     const { tx } = Transaction.fromAnyBeef(beef, txid)
     return tx
   }
@@ -121,7 +118,7 @@ export default class Transaction {
    * @param beef A binary representation of an Atomic BEEF structure.
    * @returns The subject transaction, linked to its associated inputs populated with merkle paths.
    */
-  static fromAtomicBEEF (beef: number[]): Transaction {
+  static fromAtomicBEEF (beef: number[] | Uint8Array): Transaction {
     const { tx, txid, beef: b } = Transaction.fromAnyBeef(beef)
     if (txid !== b.atomicTxid) {
       if (b.atomicTxid != null) {
@@ -133,7 +130,7 @@ export default class Transaction {
     return tx
   }
 
-  private static fromAnyBeef (beef: number[], txid?: string): { tx: Transaction, beef: Beef, txid: string } {
+  private static fromAnyBeef (beef: number[] | Uint8Array, txid?: string): { tx: Transaction, beef: Beef, txid: string } {
     const b = Beef.fromBinary(beef)
     if (b.txs.length < 1) {
       throw new Error('beef must include at least one transaction.')
@@ -155,8 +152,8 @@ export default class Transaction {
    * @param ef A binary representation of a transaction in EF format.
    * @returns An extended transaction, linked to its associated inputs by locking script and satoshis amounts only.
    */
-  static fromEF (ef: number[]): Transaction {
-    const br = new Reader(ef)
+  static fromEF (ef: number[] | Uint8Array): Transaction {
+    const br = ReaderUint8Array.makeReader(ef)
     const version = br.readUInt32LE()
     if (toHex(br.read(6)) !== '0000000000ef') { throw new Error('Invalid EF marker') }
     const inputsLength = br.readVarIntNum()
@@ -217,11 +214,11 @@ export default class Transaction {
    *   outputs: { vout: number, offset: number, length: number }[]
    * }
    */
-  static parseScriptOffsets (bin: number[]): {
+  static parseScriptOffsets (bin: number[] | Uint8Array): {
     inputs: Array<{ vin: number, offset: number, length: number }>
     outputs: Array<{ vout: number, offset: number, length: number }>
   } {
-    const br = new Reader(bin)
+    const br = ReaderUint8Array.makeReader(bin)
     const inputs: Array<{ vin: number, offset: number, length: number }> = []
     const outputs: Array<{ vout: number, offset: number, length: number }> = []
 
@@ -243,7 +240,7 @@ export default class Transaction {
     return { inputs, outputs }
   }
 
-  static fromReader (br: Reader): Transaction {
+  static fromReader (br: Reader | ReaderUint8Array): Transaction {
     const version = br.readUInt32LE()
     const inputsLength = br.readVarIntNum()
     const inputs: TransactionInput[] = []
@@ -284,10 +281,10 @@ export default class Transaction {
    * @param {number[]} bin - The binary array representation of the transaction.
    * @returns {Transaction} - A new Transaction instance.
    */
-  static fromBinary (bin: number[]): Transaction {
+  static fromBinary (bin: number[] | Uint8Array): Transaction {
     const copy = bin.slice()
     const rawBytes = Uint8Array.from(copy)
-    const br = new Reader(copy)
+    const br = new ReaderUint8Array(rawBytes)
     const tx = Transaction.fromReader(br)
     tx.rawBytesCache = rawBytes
     return tx
@@ -301,15 +298,11 @@ export default class Transaction {
    * @returns {Transaction} - A new Transaction instance.
    */
   static fromHex (hex: string): Transaction {
-    const bin = toArray(hex, 'hex')
-    const rawBytes = Uint8Array.from(bin)
-    const br = new Reader(bin)
+    const rawBytes = toUint8Array(hex, 'hex')
+    const br = new ReaderUint8Array(rawBytes)
     const tx = Transaction.fromReader(br)
     tx.rawBytesCache = rawBytes
-    tx.hexCache =
-      BufferCtor != null
-        ? BufferCtor.from(rawBytes).toString('hex')
-        : toHex(bin)
+    tx.hexCache = toHex(rawBytes)
     return tx
   }
 
@@ -321,7 +314,7 @@ export default class Transaction {
    * @returns {Transaction} - A new Transaction instance.
    */
   static fromHexEF (hex: string): Transaction {
-    return Transaction.fromEF(toArray(hex, 'hex'))
+    return Transaction.fromEF(toUint8Array(hex, 'hex'))
   }
 
   /**
@@ -616,7 +609,7 @@ export default class Transaction {
     return await broadcaster.broadcast(this)
   }
 
-  private writeTransactionBody (writer: Writer): void {
+  private writeTransactionBody (writer: Writer | WriterUint8Array): void {
     writer.writeUInt32LE(this.version)
     writer.writeVarIntNum(this.inputs.length)
     for (const i of this.inputs) {
@@ -649,7 +642,7 @@ export default class Transaction {
   }
 
   private buildSerializedBytes (): Uint8Array {
-    const writer = new Writer()
+    const writer = new WriterUint8Array()
     this.writeTransactionBody(writer)
     return writer.toUint8Array()
   }
@@ -674,13 +667,7 @@ export default class Transaction {
     return this.getSerializedBytes()
   }
 
-  /**
-   * Converts the transaction to a BRC-30 EF format.
-   *
-   * @returns {number[]} - The BRC-30 EF representation of the transaction.
-   */
-  toEF (): number[] {
-    const writer = new Writer()
+  private writeEF (writer: Writer | WriterUint8Array): void {
     writer.writeUInt32LE(this.version)
     writer.write([0, 0, 0, 0, 0, 0xef])
     writer.writeVarIntNum(this.inputs.length)
@@ -721,16 +708,37 @@ export default class Transaction {
       writer.write(scriptBin)
     }
     writer.writeUInt32LE(this.lockTime)
+  }
+
+  /**
+   * Converts the transaction to a BRC-30 EF format.
+   *
+   * @returns {number[]} - The BRC-30 EF representation of the transaction.
+   */
+  toEF (): number[] {
+    const writer = new Writer()
+    this.writeEF(writer)
     return writer.toArray()
   }
 
+  /**
+   * Converts the transaction to a BRC-30 EF format.
+   *
+   * @returns {Uint8Array} - The BRC-30 EF representation of the transaction.
+   */
+  toEFUint8Array (): Uint8Array {
+    const writer = new WriterUint8Array()
+    this.writeEF(writer)
+    return writer.toUint8Array()
+  }
+
   /**
    * Converts the transaction to a hexadecimal string EF.
    *
    * @returns {string} - The hexadecimal string representation of the transaction EF.
    */
   toHexEF (): string {
-    return toHex(this.toEF())
+    return toHex(this.toEFUint8Array())
   }
 
   /**
@@ -743,10 +751,7 @@ export default class Transaction {
       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
   }
@@ -951,13 +956,13 @@ export default class Transaction {
   /**
    * Serializes this transaction, together with its inputs and the respective merkle proofs, into the BEEF (BRC-62) format. This enables efficient verification of its compliance with the rules of SPV.
    *
+   * @param writer The writer to serialize to
    * @param allowPartial If true, error will not be thrown if there are any missing sourceTransactions.
    *
    * @returns The serialized BEEF structure
    * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
    */
-  toBEEF (allowPartial?: boolean): number[] {
-    const writer = new Writer()
+  writeSerializedBEEF (writer: Writer | WriterUint8Array, allowPartial?: boolean): void {
     writer.writeUInt32LE(BEEF_V1)
     const BUMPs: MerklePath[] = []
     const bumpIndexByInstance = new Map<MerklePath, number>()
@@ -1035,6 +1040,34 @@ export default class Transaction {
     return writer.toArray()
   }
 
+  /**
+   * Serializes this transaction, together with its inputs and the respective merkle proofs, into the BEEF (BRC-62) format. This enables efficient verification of its compliance with the rules of SPV.
+   *
+   * @param allowPartial If true, error will not be thrown if there are any missing sourceTransactions.
+   *
+   * @returns {number[]} The serialized BEEF structure
+   * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
+   */
+  toBEEF (allowPartial?: boolean): number[] {
+    const writer = new Writer()
+    this.writeSerializedBEEF(writer, allowPartial)
+    return writer.toArray()
+  }
+
+  /**
+   * Serializes this transaction, together with its inputs and the respective merkle proofs, into the BEEF (BRC-62) format. This enables efficient verification of its compliance with the rules of SPV.
+   *
+   * @param allowPartial If true, error will not be thrown if there are any missing sourceTransactions.
+   *
+   * @returns {number[]} The serialized BEEF structure
+   * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
+   */
+  toBEEFUint8Array (allowPartial?: boolean): Uint8Array {
+    const writer = new WriterUint8Array()
+    this.writeSerializedBEEF(writer, allowPartial)
+    return writer.toArray()
+  }
+
   /**
    * Serializes this transaction and its inputs into the Atomic BEEF (BRC-95) format.
    * The Atomic BEEF format starts with a 4-byte prefix `0x01010101`, followed by the TXID of the subject transaction,
@@ -1052,4 +1085,210 @@ export default class Transaction {
     const beefData = this.toBEEF(allowPartial)
     return prefix.concat(txHash, beefData)
   }
+
+  /**
+   * Serializes this transaction and its inputs into the Atomic BEEF (BRC-95) format.
+   * The Atomic BEEF format starts with a 4-byte prefix `0x01010101`, followed by the TXID of the subject transaction,
+   * and then the BEEF data containing only the subject transaction and its dependencies.
+   * This format ensures that the BEEF structure is atomic and contains no unrelated transactions.
+   *
+   * @param allowPartial If true, error will not be thrown if there are any missing sourceTransactions.
+   *
+   * @returns {number[]} - The serialized Atomic BEEF structure.
+   * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
+   */
+  toAtomicBEEFUint8Array (allowPartial?: boolean): Uint8Array {
+    const writer = new WriterUint8Array()
+    const prefix = [1, 1, 1, 1]
+    writer.write(prefix)
+    const txHash = this.hash() as number[]
+    writer.write(txHash)
+    this.writeSerializedBEEF(writer, allowPartial)
+    return writer.toUint8Array()
+  }
+
+  /**
+   * Completes the transaction using a wallet interface, which will handle
+   * signing and transaction finalization. This method converts the current
+   * transaction into a format that can be processed by the wallet, and then
+   * updates this transaction object with the result from the wallet.
+   *
+   * @param {WalletInterface} wallet - The BRC-100 compliant wallet to use for completing the transaction
+   * @param {string} [actionDescription] - Optional description for the action
+   * @param {string} [originator] - Optional originator domain name
+   * @param {CreateActionOptions} [options] - Optional settings for transaction creation (e.g., acceptDelayedBroadcast, trustSelf, noSend, etc.)
+   * @returns {Promise<void>}
+   */
+  async completeWithWallet (wallet: WalletInterface, actionDescription?: DescriptionString5to50Bytes, originator?: string, options?: CreateActionOptions): Promise<void> {
+    const inputCount = this.inputs.length
+    const outputCount = this.outputs.length
+    const description = actionDescription ?? `Transaction with ${inputCount} input(s) and ${outputCount} output(s)`
+
+    const actionArgs: CreateActionArgs = {
+      description,
+      inputs: [] as any[],
+      outputs: [] as any[],
+      lockTime: this.lockTime,
+      version: this.version
+    }
+
+    // Check if any input has an unlocking script template
+    const hasTemplates = this.inputs.some(input => input.unlockingScriptTemplate != null)
+
+    // Process inputs - collect all source transactions and convert them to BEEF
+    const beefData = new Beef()
+    for (let i = 0; i < this.inputs.length; i++) {
+      const input = this.inputs[i]
+
+      if (input.sourceTransaction == null) {
+        throw new Error('All inputs must have a sourceTransaction when using completeWithWallet')
+      }
+
+      // Merge source transaction into BEEF
+      const sourceBEEF = input.sourceTransaction.toBEEF()
+      beefData.mergeBeef(sourceBEEF)
+
+      const sourceTXID = input.sourceTransaction.id('hex')
+
+      const inputArg: any = {
+        outpoint: `${sourceTXID}.${input.sourceOutputIndex}`,
+        inputDescription: 'Input from source transaction',
+        sequenceNumber: input.sequence
+      }
+
+      // Handle inputs with templates vs scripts
+      if (hasTemplates) {
+        // When using signAction flow, need to provide length for templates
+        if (input.unlockingScriptTemplate != null) {
+          const estimatedLength = await input.unlockingScriptTemplate.estimateLength(this, i)
+          inputArg.unlockingScriptLength = estimatedLength
+        } else if (input.unlockingScript != null) {
+          // Still provide the script if it exists
+          inputArg.unlockingScript = input.unlockingScript.toHex()
+        } else {
+          throw new Error(`Input ${i} must have either an unlockingScript or unlockingScriptTemplate`)
+        }
+      } else {
+        // Original flow: all inputs must have unlocking scripts
+        if (input.unlockingScript == null) {
+          throw new Error('All inputs must have an unlockingScript when using completeWithWallet')
+        }
+        inputArg.unlockingScript = input.unlockingScript.toHex()
+      }
+
+      actionArgs.inputs.push(inputArg)
+    }
+
+    // Add inputBEEF if there are inputs
+    if (this.inputs.length > 0) {
+      actionArgs.inputBEEF = beefData.toBinary()
+    }
+
+    // Process outputs
+    for (const output of this.outputs) {
+      actionArgs.outputs.push({
+        satoshis: output.satoshis,
+        lockingScript: output.lockingScript.toHex(),
+        outputDescription: 'Output from source transaction'
+      })
+    }
+
+    // Add any labels from metadata if they exist
+    if (this.metadata?.labels != null && Array.isArray(this.metadata.labels)) {
+      actionArgs.labels = this.metadata.labels
+    }
+
+    let atomicBEEF: number[]
+
+    // Use signAction flow for templates
+    if (hasTemplates) {
+      // Merge user options with required signAndProcess: false for template flow
+      actionArgs.options = {
+        ...options,
+        signAndProcess: false
+      }
+
+      const { signableTransaction } = await wallet.createAction(actionArgs, originator)
+
+      if (signableTransaction == null) {
+        throw new Error('Wallet createAction did not return signableTransaction')
+      }
+
+      // Parse the signable transaction BEEF to get the unsigned transaction
+      const partialTx = Transaction.fromBEEF(signableTransaction.tx)
+
+      // Sign inputs with templates and collect all unlocking scripts
+      const spends: Record<number, { unlockingScript: string }> = {}
+
+      for (let i = 0; i < this.inputs.length; i++) {
+        const input = this.inputs[i]
+
+        if (input.unlockingScriptTemplate != null) {
+          // Use the template to sign this input
+          const unlockingScript = await input.unlockingScriptTemplate.sign(partialTx, i)
+          spends[i] = {
+            unlockingScript: unlockingScript.toHex()
+          }
+        } else if (input.unlockingScript != null) {
+          // Include pre-existing unlocking scripts
+          spends[i] = {
+            unlockingScript: input.unlockingScript.toHex()
+          }
+        }
+      }
+
+      // Extract options that apply to signAction (subset of CreateActionOptions)
+      const signActionOptions: SignActionOptions | undefined = options != null
+        ? {
+            acceptDelayedBroadcast: options.acceptDelayedBroadcast,
+            returnTXIDOnly: options.returnTXIDOnly,
+            noSend: options.noSend,
+            sendWith: options.sendWith
+          }
+        : undefined
+
+      // Call signAction with the generated unlocking scripts
+      const signResult = await wallet.signAction({
+        reference: signableTransaction.reference,
+        spends,
+        options: signActionOptions
+      }, originator)
+
+      if (signResult.tx == null) {
+        throw new Error('Wallet signAction did not return transaction data')
+      }
+
+      atomicBEEF = signResult.tx
+    } else {
+      // Pass through user options for standard flow
+      if (options != null) {
+        actionArgs.options = options
+      }
+
+      const { tx } = await wallet.createAction(actionArgs, originator)
+
+      if (tx == null) {
+        throw new Error('Wallet createAction did not return transaction data')
+      }
+
+      atomicBEEF = tx
+    }
+
+    // Create a new transaction from the atomic BEEF
+    const newTransaction = Transaction.fromAtomicBEEF(atomicBEEF)
+
+    // Update this transaction's properties with the new transaction's properties
+    this.version = newTransaction.version
+    this.inputs = newTransaction.inputs
+    this.outputs = newTransaction.outputs
+    this.lockTime = newTransaction.lockTime
+    this.merklePath = newTransaction.merklePath
+    this.cachedHash = newTransaction.cachedHash
+
+    // Preserve metadata from the original transaction but update with any new metadata
+    this.metadata = {
+      ...this.metadata,
+      ...newTransaction.metadata
+    }
+  }
 }

package/src/transaction/__tests/Beef.test.ts

@@ -324,6 +324,81 @@ describe('Beef tests', () => {
     }
   })
 
+  test('6b_trimKnownTxids_removes_unreferenced_bumps', async () => {
+    // Create a beef with multiple transactions and bumps
+    const beef = Beef.fromString(beefs[0])
+    
+    // Verify initial state
+    const initialBumpCount = beef.bumps.length
+    const initialTxCount = beef.txs.length
+    expect(initialBumpCount).toBe(1)
+    expect(initialTxCount).toBe(1)
+    
+    // Add some txid-only transactions that don't have bumps
+    beef.mergeTxidOnly('txid1')
+    beef.mergeTxidOnly('txid2')
+    beef.mergeTxidOnly('txid3')
+    
+    expect(beef.txs.length).toBe(4)
+    expect(beef.bumps.length).toBe(1)
+    
+    // Get the txid of the transaction with a bump
+    const txWithBump = beef.txs.find(tx => tx.bumpIndex !== undefined)
+    expect(txWithBump).toBeTruthy()
+    
+    // Trim all txid-only transactions
+    beef.trimKnownTxids(['txid1', 'txid2', 'txid3'])
+    
+    // Verify txids were removed
+    expect(beef.txs.length).toBe(1)
+    expect(beef.bumps.length).toBe(1) // Bump should still be there because it's referenced
+    
+    // Now test removing the transaction that has the bump
+    // First, make it txidOnly
+    const originalTxid = txWithBump!.txid
+    beef.makeTxidOnly(originalTxid)
+    
+    // Now trim it
+    beef.trimKnownTxids([originalTxid])
+    
+    // The bump should be removed since no transactions reference it anymore
+    expect(beef.txs.length).toBe(0)
+    expect(beef.bumps.length).toBe(0)
+  })
+
+  test('6c_trimKnownTxids_updates_bump_indices', async () => {
+    // Use existing beef with bumps
+    const beef = Beef.fromString(beefs[0])
+    
+    const initialBumpCount = beef.bumps.length
+    const initialTxCount = beef.txs.length
+    
+    // Find transaction with bump
+    const txWithBump = beef.txs.find(tx => tx.bumpIndex !== undefined)
+    expect(txWithBump).toBeTruthy()
+    const originalBumpIndex = txWithBump!.bumpIndex
+    
+    // Add some txid-only transactions
+    beef.mergeTxidOnly('known1')
+    beef.mergeTxidOnly('known2')
+    
+    expect(beef.txs.length).toBe(initialTxCount + 2)
+    expect(beef.bumps.length).toBe(initialBumpCount)
+    
+    // Trim the known txids
+    beef.trimKnownTxids(['known1', 'known2'])
+    
+    // Verify bump count didn't change (all bumps are still referenced)
+    expect(beef.bumps.length).toBe(initialBumpCount)
+    
+    // Verify transaction count decreased
+    expect(beef.txs.length).toBe(initialTxCount)
+    
+    // Verify bumpIndex is still correct
+    const txAfterTrim = beef.txs.find(tx => tx.txid === txWithBump!.txid)
+    expect(txAfterTrim?.bumpIndex).toBe(originalBumpIndex)
+  })
+
   test('7_AtomicBeef', async () => {
     {
       const beef = Beef.fromString(beefs[0])
@@ -391,6 +466,8 @@ describe('Beef tests', () => {
     const t2 = Transaction.fromAtomicBEEF(atomic)
     const beef2 = t2.toAtomicBEEF()
     expect(atomic).toEqual(beef2)
+    const atomic2 = beef.toUint8ArrayAtomic(tx.id('hex'))
+    expect(atomic).toEqual(Array.from(atomic2))
   })
   test('9_sortTxs', async () => {
     {