@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/src/script/index.ts

@@ -0,0 +1,10 @@
+export { default as OP } from './OP.js'
+export { default as Script } from './Script.js'
+export { default as LockingScript } from './LockingScript.js'
+export { default as UnlockingScript } from './UnlockingScript.js'
+export { default as Spend } from './Spend.js'
+export type { default as ScriptTemplateUnlock } from './ScriptTemplateUnlock.js'
+export { default as ScriptEvaluationError } from './ScriptEvaluationError.js'
+export type { default as ScriptTemplate } from './ScriptTemplate.js'
+export * from './templates/index.js'
+export type { default as ScriptChunk } from './ScriptChunk.js'

package/mobile/node_modules/@bsv/sdk/src/script/templates/P2PKH.ts

@@ -0,0 +1,157 @@
+import OP from '../OP.js'
+import ScriptTemplate from '../ScriptTemplate.js'
+import { fromBase58Check, verifyNotNull } from '../../primitives/utils.js'
+import LockingScript from '../LockingScript.js'
+import UnlockingScript from '../UnlockingScript.js'
+import Transaction from '../../transaction/Transaction.js'
+import PrivateKey from '../../primitives/PrivateKey.js'
+import TransactionSignature from '../../primitives/TransactionSignature.js'
+import { sha256 } from '../../primitives/Hash.js'
+import Script from '../Script.js'
+
+/**
+ * P2PKH (Pay To Public Key Hash) class implementing ScriptTemplate.
+ *
+ * This class provides methods to create Pay To Public Key Hash locking and unlocking scripts, including the unlocking of P2PKH UTXOs with the private key.
+ */
+export default class P2PKH implements ScriptTemplate {
+  /**
+   * Creates a P2PKH locking script for a given public key hash or address string
+   *
+   * @param {number[] | string} pubkeyhash or address - An array or address representing the public key hash.
+   * @returns {LockingScript} - A P2PKH locking script.
+   */
+  lock(pubkeyhash: string | number[]): LockingScript {
+    let data: number[]
+    if (typeof pubkeyhash === 'string') {
+      const hash = fromBase58Check(pubkeyhash)
+      if (hash.prefix[0] !== 0x00 && hash.prefix[0] !== 0x6f) {
+        throw new Error('only P2PKH is supported')
+      }
+      data = hash.data as number[]
+    } else {
+      data = pubkeyhash
+    }
+    if (data.length !== 20) {
+      throw new Error('P2PKH hash length must be 20 bytes')
+    }
+    return new LockingScript([
+      { op: OP.OP_DUP },
+      { op: OP.OP_HASH160 },
+      { op: data.length, data },
+      { op: OP.OP_EQUALVERIFY },
+      { op: OP.OP_CHECKSIG }
+    ])
+  }
+
+  /**
+   * Creates a function that generates a P2PKH unlocking script along with its signature and length estimation.
+   *
+   * The returned object contains:
+   * 1. `sign` - A function that, when invoked with a transaction and an input index,
+   *    produces an unlocking script suitable for a P2PKH locked output.
+   * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+   *
+   * @param {PrivateKey} privateKey - The private key used for signing the transaction.
+   * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
+   * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
+   * @param {number} sourceSatoshis - Optional. The amount being unlocked. Otherwise the input.sourceTransaction is required.
+   * @param {Script} lockingScript - Optional. The lockinScript. Otherwise the input.sourceTransaction is required.
+   * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+   */
+  unlock(
+    privateKey: PrivateKey,
+    signOutputs: 'all' | 'none' | 'single' = 'all',
+    anyoneCanPay: boolean = false,
+    sourceSatoshis?: number,
+    lockingScript?: Script
+  ): {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<108>
+  } {
+    return {
+      sign: async (tx: Transaction, inputIndex: number) => {
+        let signatureScope = TransactionSignature.SIGHASH_FORKID
+        if (signOutputs === 'all') {
+          signatureScope |= TransactionSignature.SIGHASH_ALL
+        }
+        if (signOutputs === 'none') {
+          signatureScope |= TransactionSignature.SIGHASH_NONE
+        }
+        if (signOutputs === 'single') {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE
+        }
+        if (anyoneCanPay) {
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
+        }
+
+        const input = tx.inputs[inputIndex]
+
+        const otherInputs = tx.inputs.filter(
+          (_, index) => index !== inputIndex
+        )
+
+        const sourceTXID = input.sourceTXID ?? input.sourceTransaction?.id('hex')
+        if (sourceTXID == null || sourceTXID === undefined) {
+          throw new Error(
+            'The input sourceTXID or sourceTransaction is required for transaction signing.'
+          )
+        }
+        if (sourceTXID === '') {
+          throw new Error(
+            'The input sourceTXID or sourceTransaction is required for transaction signing.'
+          )
+        }
+        sourceSatoshis ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        if (sourceSatoshis == null || sourceSatoshis === undefined) {
+          throw new Error(
+            'The sourceSatoshis or input sourceTransaction is required for transaction signing.'
+          )
+        }
+        lockingScript ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex]
+            .lockingScript
+        if (lockingScript == null) {
+          throw new Error(
+            'The lockingScript or input sourceTransaction is required for transaction signing.'
+          )
+        }
+
+        const preimage = TransactionSignature.format({
+          sourceTXID,
+          sourceOutputIndex: verifyNotNull(input.sourceOutputIndex, 'input.sourceOutputIndex must have value'),
+          sourceSatoshis,
+          transactionVersion: tx.version,
+          otherInputs,
+          inputIndex,
+          outputs: tx.outputs,
+          inputSequence: verifyNotNull(input.sequence, 'input.sequence must have value'),
+          subscript: lockingScript,
+          lockTime: tx.lockTime,
+          scope: signatureScope
+        })
+
+        const rawSignature = privateKey.sign(sha256(preimage))
+        const sig = new TransactionSignature(
+          rawSignature.r,
+          rawSignature.s,
+          signatureScope
+        )
+        const sigForScript = sig.toChecksigFormat()
+        const pubkeyForScript = privateKey
+          .toPublicKey()
+          .encode(true) as number[]
+        return new UnlockingScript([
+          { op: sigForScript.length, data: sigForScript },
+          { op: pubkeyForScript.length, data: pubkeyForScript }
+        ])
+      },
+      estimateLength: async () => {
+        // public key (1+33) + signature (1+73)
+        // Note: We add 1 to each element's length because of the associated OP_PUSH
+        return 108
+      }
+    }
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/script/templates/PushDrop.ts

@@ -0,0 +1,281 @@
+import { ScriptTemplate, LockingScript, UnlockingScript, OP } from '../index.js'
+import {
+  Utils,
+  Hash,
+  TransactionSignature,
+  Signature,
+  PublicKey
+} from '../../primitives/index.js'
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import { Transaction } from '../../transaction/index.js'
+import { WalletProtocol } from '../../wallet/Wallet.interfaces.js'
+import { verifyNotNull } from '../../primitives/utils.js'
+
+/**
+ * For a given piece of data to push onto the stack in script, creates the correct minimally-encoded script chunk,
+ * including the correct push operation.
+ *
+ * TODO: This should be made into a TS-SDK util (distinct from the `minimallyEncode` util)
+ */
+const createMinimallyEncodedScriptChunk = (
+  data: number[]
+): { op: number, data?: number[] } => {
+  if (data.length === 0) {
+    // Could have used OP_0.
+    return { op: 0 }
+  }
+  if (data.length === 1 && data[0] === 0) {
+    // Could have used OP_0.
+    return { op: 0 }
+  }
+  if (data.length === 1 && data[0] > 0 && data[0] <= 16) {
+    // Could have used OP_0 .. OP_16.
+    return { op: 0x50 + data[0] }
+  }
+  if (data.length === 1 && data[0] === 0x81) {
+    // Could have used OP_1NEGATE.
+    return { op: 0x4f }
+  }
+  if (data.length <= 75) {
+    // Could have used a direct push (opcode indicating number of bytes
+    // pushed + those bytes).
+    return { op: data.length, data }
+  }
+  if (data.length <= 255) {
+    // Could have used OP_PUSHDATA.
+    return { op: 0x4c, data }
+  }
+  if (data.length <= 65535) {
+    // Could have used OP_PUSHDATA2.
+    return { op: 0x4d, data }
+  }
+  return { op: 0x4e, data }
+}
+
+export default class PushDrop implements ScriptTemplate {
+  wallet: WalletInterface
+  originator?: string
+
+  /**
+   * 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
+   * @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): {
+    lockingPublicKey: PublicKey
+    fields: number[][]
+  } {
+    const lockingPublicKey = PublicKey.fromString(
+      Utils.toHex(verifyNotNull(script.chunks[0].data, 'script.chunks[0].data must have value'))
+    )
+
+    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[]`
+
+      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) {
+          chunk = [0]
+        } else if (script.chunks[i].op === 0x4f) {
+          chunk = [0x81]
+        }
+      }
+      fields.push(chunk)
+
+      // If the next value is DROP or 2DROP then this is the final field
+      if (nextOpcode === OP.OP_DROP || nextOpcode === OP.OP_2DROP) {
+        break
+      }
+    }
+
+    return {
+      fields,
+      lockingPublicKey
+    }
+  }
+
+  /**
+   * Constructs a new instance of the PushDrop class.
+   *
+   * @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) {
+    this.wallet = wallet
+    this.originator = originator
+  }
+
+  /**
+   * Creates a PushDrop locking script with arbitrary data fields and a public key lock.
+   *
+   * @param {number[][]} fields - The token fields to include in the locking script.
+   * @param {WalletProtocol} protocolID - The protocol ID to use.
+   * @param {string} keyID - The key ID to use.
+   * @param {string} counterparty - The counterparty involved in the transaction, "self" or "anyone".
+   * @param {boolean} [forSelf=false] - Flag indicating if the lock is for the creator (default no).
+   * @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(
+    fields: number[][],
+    protocolID: WalletProtocol,
+    keyID: string,
+    counterparty: string,
+    forSelf = false,
+    includeSignature = true,
+    lockPosition: 'before' | 'after' = 'before'
+  ): Promise<LockingScript> {
+    const { publicKey } = await this.wallet.getPublicKey({
+      protocolID,
+      keyID,
+      counterparty,
+      forSelf
+    }, this.originator)
+    const lockChunks: Array<{ op: number, data?: number[] }> = []
+    const pushDropChunks: Array<{ op: number, data?: number[] }> = []
+    lockChunks.push({
+      op: publicKey.length / 2,
+      data: Utils.toArray(publicKey, 'hex')
+    })
+    lockChunks.push({ op: OP.OP_CHECKSIG })
+    if (includeSignature) {
+      const dataToSign = fields.reduce((a, e) => [...a, ...e], [])
+      const { signature } = await this.wallet.createSignature({
+        data: dataToSign,
+        protocolID,
+        keyID,
+        counterparty
+      }, this.originator)
+      fields.push(signature)
+    }
+    for (const field of fields) {
+      pushDropChunks.push(createMinimallyEncodedScriptChunk(field))
+    }
+    let notYetDropped = fields.length
+    while (notYetDropped > 1) {
+      pushDropChunks.push({ op: OP.OP_2DROP })
+      notYetDropped -= 2
+    }
+    if (notYetDropped !== 0) {
+      pushDropChunks.push({ op: OP.OP_DROP })
+    }
+    if (lockPosition === 'before') {
+      return new LockingScript([...lockChunks, ...pushDropChunks])
+    } else {
+      return new LockingScript([...pushDropChunks, ...lockChunks])
+    }
+  }
+
+  /**
+   * Creates an unlocking script for spending a PushDrop token output.
+   *
+   * @param {WalletProtocol} protocolID - The protocol ID to use.
+   * @param {string} keyID - The key ID to use.
+   * @param {string} counterparty - The counterparty involved in the transaction, "self" or "anyone".
+   * @param {string} [sourceTXID] - The TXID of the source transaction.
+   * @param {number} [sourceSatoshis] - The number of satoshis in the source output.
+   * @param {LockingScript} [lockingScript] - The locking script of the source output.
+   * @param {'all' | 'none' | 'single'} [signOutputs='all'] - Specifies which outputs to sign.
+   * @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(
+    protocolID: WalletProtocol,
+    keyID: string,
+    counterparty: string,
+    signOutputs: 'all' | 'none' | 'single' = 'all',
+    anyoneCanPay = false,
+    sourceSatoshis?: number,
+    lockingScript?: LockingScript
+  ): {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<73>
+  } {
+    return {
+      sign: async (
+        tx: Transaction,
+        inputIndex: number
+      ): Promise<UnlockingScript> => {
+        let signatureScope = TransactionSignature.SIGHASH_FORKID
+        if (signOutputs === 'all') {
+          signatureScope |= TransactionSignature.SIGHASH_ALL
+        }
+        if (signOutputs === 'none') {
+          signatureScope |= TransactionSignature.SIGHASH_NONE
+        }
+        if (signOutputs === 'single') {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE
+        }
+        if (anyoneCanPay) {
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
+        }
+
+        const input = tx.inputs[inputIndex]
+
+        const otherInputs = tx.inputs.filter(
+          (_, index) => index !== inputIndex
+        )
+
+        const sourceTXID = input.sourceTXID ?? input.sourceTransaction?.id('hex')
+        if (sourceTXID == null || sourceTXID === undefined) {
+          throw new Error(
+            'The input sourceTXID or sourceTransaction is required for transaction signing.'
+          )
+        }
+        sourceSatoshis ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        if (sourceSatoshis == null || sourceSatoshis === undefined) {
+          throw new Error(
+            'The sourceSatoshis or input sourceTransaction is required for transaction signing.'
+          )
+        }
+        lockingScript ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex]
+            .lockingScript
+        if (lockingScript == null) {
+          throw new Error(
+            'The lockingScript or input sourceTransaction is required for transaction signing.'
+          )
+        }
+
+        const preimage = TransactionSignature.format({
+          sourceTXID,
+          sourceOutputIndex: verifyNotNull(input.sourceOutputIndex, 'input.sourceOutputIndex must have value'),
+          sourceSatoshis,
+          transactionVersion: tx.version,
+          otherInputs,
+          inputIndex,
+          outputs: tx.outputs,
+          inputSequence: input.sequence ?? 0xffffffff,
+          subscript: lockingScript,
+          lockTime: tx.lockTime,
+          scope: signatureScope
+        })
+
+        const preimageHash = Hash.sha256(preimage)
+        const { signature: bareSignature } = await this.wallet.createSignature({
+          data: preimageHash,
+          protocolID,
+          keyID,
+          counterparty
+        }, this.originator)
+        const signature = Signature.fromDER([...bareSignature])
+        const txSignature = new TransactionSignature(
+          signature.r,
+          signature.s,
+          signatureScope
+        )
+        const sigForScript = txSignature.toChecksigFormat()
+        return new UnlockingScript([
+          { op: sigForScript.length, data: sigForScript }
+        ])
+      },
+      estimateLength: async () => 73
+    }
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/script/templates/RPuzzle.ts

@@ -0,0 +1,161 @@
+import OP from '../OP.js'
+import ScriptTemplate from '../ScriptTemplate.js'
+import LockingScript from '../LockingScript.js'
+import UnlockingScript from '../UnlockingScript.js'
+import Transaction from '../../transaction/Transaction.js'
+import PrivateKey from '../../primitives/PrivateKey.js'
+import TransactionSignature from '../../primitives/TransactionSignature.js'
+import { sha256 } from '../../primitives/Hash.js'
+import ScriptChunk from '../ScriptChunk.js'
+import BigNumber from '../../primitives/BigNumber.js'
+import Script from '../Script.js'
+
+/**
+ * RPuzzle class implementing ScriptTemplate.
+ *
+ * This class provides methods to create R Puzzle and R Puzzle Hash locking and unlocking scripts, including the unlocking of UTXOs with the correct K value.
+ */
+export default class RPuzzle implements ScriptTemplate {
+  type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw'
+
+  /**
+   * @constructor
+   * Constructs an R Puzzle template instance for a given puzzle type
+   *
+   * @param {'raw'|'SHA1'|'SHA256'|'HASH256'|'RIPEMD160'|'HASH160'} type Denotes the type of puzzle to create
+   */
+  constructor(
+    type:
+      | 'raw'
+      | 'SHA1'
+      | 'SHA256'
+      | 'HASH256'
+      | 'RIPEMD160'
+      | 'HASH160' = 'raw'
+  ) {
+    this.type = type
+  }
+
+  /**
+   * Creates an R puzzle locking script for a given R value or R value hash.
+   *
+   * @param {number[]} value - An array representing the R value or its hash.
+   * @returns {LockingScript} - An R puzzle locking script.
+   */
+  lock(value: number[]): LockingScript {
+    const chunks: ScriptChunk[] = [
+      { op: OP.OP_OVER },
+      { op: OP.OP_3 },
+      { op: OP.OP_SPLIT },
+      { op: OP.OP_NIP },
+      { op: OP.OP_1 },
+      { op: OP.OP_SPLIT },
+      { op: OP.OP_SWAP },
+      { op: OP.OP_SPLIT },
+      { op: OP.OP_DROP }
+    ]
+    if (this.type !== 'raw') {
+      chunks.push({
+        op: OP['OP_' + this.type]
+      })
+    }
+    chunks.push({ op: value.length, data: value })
+    chunks.push({ op: OP.OP_EQUALVERIFY })
+    chunks.push({ op: OP.OP_CHECKSIG })
+    return new LockingScript(chunks)
+  }
+
+  /**
+   * Creates a function that generates an R puzzle unlocking script along with its signature and length estimation.
+   *
+   * The returned object contains:
+   * 1. `sign` - A function that, when invoked with a transaction and an input index,
+   *    produces an unlocking script suitable for an R puzzle locked output.
+   * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+   *
+   * @param {BigNumber} k — The K-value used to unlock the R-puzzle.
+   * @param {PrivateKey} privateKey - The private key used for signing the transaction. If not provided, a random key will be generated.
+   * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
+   * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
+   * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+   */
+  unlock(
+    k: BigNumber,
+    privateKey: PrivateKey,
+    signOutputs: 'all' | 'none' | 'single' = 'all',
+    anyoneCanPay: boolean = false
+  ): {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<108>
+  } {
+    return {
+      sign: async (tx: Transaction, inputIndex: number) => {
+        if (typeof privateKey === 'undefined') {
+          privateKey = PrivateKey.fromRandom()
+        }
+        let signatureScope = TransactionSignature.SIGHASH_FORKID
+        if (signOutputs === 'all') {
+          signatureScope |= TransactionSignature.SIGHASH_ALL
+        }
+        if (signOutputs === 'none') {
+          signatureScope |= TransactionSignature.SIGHASH_NONE
+        }
+        if (signOutputs === 'single') {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE
+        }
+        if (anyoneCanPay) {
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
+        }
+        const otherInputs = [...tx.inputs]
+        const [input] = otherInputs.splice(inputIndex, 1)
+        if (typeof input.sourceTransaction !== 'object') {
+          throw new Error(
+            'The source transaction is needed for transaction signing.'
+          )
+        }
+        const preimage = TransactionSignature.format({
+          sourceTXID: input.sourceTransaction?.id('hex') ?? '',
+          sourceOutputIndex: input.sourceOutputIndex ?? 0,
+          sourceSatoshis:
+            input.sourceTransaction?.outputs[input.sourceOutputIndex]
+              ?.satoshis ?? 0,
+          transactionVersion: tx.version,
+          otherInputs,
+          inputIndex,
+          outputs: tx.outputs,
+          inputSequence: input.sequence ?? 0xffffffff,
+          subscript:
+            input.sourceTransaction?.outputs[input.sourceOutputIndex]
+              ?.lockingScript ?? new Script(),
+          lockTime: tx.lockTime,
+          scope: signatureScope
+        })
+
+        const rawSignature = privateKey.sign(
+          sha256(preimage),
+          undefined,
+          true,
+          k
+        )
+        const sig = new TransactionSignature(
+          rawSignature.r,
+          rawSignature.s,
+          signatureScope
+        )
+        const sigForScript = sig.toChecksigFormat()
+        const pubkeyForScript = privateKey
+          .toPublicKey()
+          .encode(true) as number[]
+        return new UnlockingScript([
+          { op: sigForScript.length, data: sigForScript },
+          { op: pubkeyForScript.length, data: pubkeyForScript }
+        ])
+      },
+      estimateLength: async () => {
+        // public key (1+33) + signature (1+73)
+        // Note: We add 1 to each element's length because of the associated OP_PUSH
+        return 108
+      }
+    }
+  }
+}