@bopen-io/wallet-toolbox 1.7.18

package/src/utility/Format.ts

@@ -0,0 +1,133 @@
+import { Beef, Transaction } from '@bsv/sdk'
+import * as sdk from '../sdk'
+import { TableTransaction } from '../storage/schema/tables'
+import { StorageAdminStats, StorageProvider } from '../storage/StorageProvider'
+
+export abstract class Format {
+  static alignLeft(v: string | number, fixedWidth: number): string {
+    v = v.toString()
+    if (v.length > fixedWidth) {
+      return v.slice(0, fixedWidth - 1) + '…'
+    }
+    return v.toString().padEnd(fixedWidth)
+  }
+
+  static alignRight(v: string | number, fixedWidth: number): string {
+    v = v.toString()
+    if (v.length > fixedWidth) {
+      return '…' + v.slice(-fixedWidth + 1)
+    }
+    return v.toString().padStart(fixedWidth)
+  }
+
+  static alignMiddle(v: string | number, fixedWidth: number): string {
+    v = v.toString()
+    if (v.length === fixedWidth) return v
+    const l = Math.ceil(fixedWidth / 2)
+    const r = Math.floor(fixedWidth / 2)
+    if (v.length > fixedWidth) {
+      return `${al(v, l)}${ar(v, r)}`
+    }
+    const pl = Math.ceil(v.length / 2)
+    const pr = Math.floor(v.length / 2)
+    return `${ar(v.slice(0, pl), l)}${al(v.slice(-pr), r)}`
+  }
+
+  static satoshis(s: number): string {
+    const minus = s < 0 ? '-' : ''
+    s = Math.abs(s)
+    let a = s.toString().split('')
+    if (a.length > 2) a.splice(-2, 0, '_')
+    if (a.length > 6) a.splice(-6, 0, '_')
+    if (a.length > 10) a.splice(-10, 0, '.')
+    if (a.length > 14) a.splice(-14, 0, '_')
+    if (a.length > 18) a.splice(-18, 0, '_')
+    let v = a.join('')
+    return minus + v
+  }
+
+  static toLogStringTransaction(tx: Transaction): string {
+    const txid = tx.id('hex')
+    try {
+      let log = ''
+      let totalIn = 0,
+        totalOut = 0
+      for (let i = 0; i < Math.max(tx.inputs.length, tx.outputs.length); i++) {
+        let ilog: string = ''
+        let olog: string = ''
+        if (i < tx.inputs.length) {
+          const input = tx.inputs[i]
+          const satoshis = input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis || 0
+          totalIn += satoshis
+          ilog = `${al(`${am(input.sourceTXID || '', 12)}.${input.sourceOutputIndex}`, 17)} ${ar(sa(satoshis), 12)}`
+        }
+        if (i < tx.outputs.length) {
+          const output = tx.outputs[i]
+          totalOut += output.satoshis || 0
+          const script = output.lockingScript.toHex()
+          olog = `${ar(sa(output.satoshis || 0), 12)} (${script.length})${am(script, 13)}`
+        }
+        log += `${al(ilog, 30)} ${ar('' + i, 5)} ${olog}\n`
+      }
+      let h = `txid ${txid}\n`
+      h += `total in:${sa(totalIn)} out:${sa(totalOut)} fee:${sa(totalIn - totalOut)}\n`
+      h += `${al('Inputs', 30)} ${ar('Vin/', 5)} ${'Outputs'}\n`
+      h += `${al('Outpoint', 17)} ${ar('Satoshis', 12)} ${ar('Vout', 5)} ${ar('Satoshis', 12)} ${al('Lock Script', 23)}\n`
+      return h + log
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu)
+      return `Transaction with txid ${txid} is invalid`
+    }
+  }
+
+  static toLogStringBeefTxid(beef: Beef, txid: string): string {
+    const tx = beef.findAtomicTransaction(txid)
+    if (!tx) return `Transaction ${txid} not found in beef`
+    return Format.toLogStringTransaction(tx)
+  }
+
+  static async toLogStringTableTransaction(tx: TableTransaction, storage: StorageProvider): Promise<string> {
+    if (!tx.txid) return `Transaction ${tx.transactionId} has no txid`
+    try {
+      const beef = await storage.getBeefForTransaction(tx.txid, { minProofLevel: 1 })
+      const log = Format.toLogStringBeefTxid(beef, tx.txid)
+      const h = `transactionId:${tx.transactionId} userId:${tx.userId} ${tx.status} satoshis:${sa(tx.satoshis)}\n`
+      return h + log
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu)
+      return `Transaction ${tx.transactionId} with txid ${tx.txid} is invalid`
+    }
+  }
+
+  static toLogStringAdminStats(s: StorageAdminStats): string {
+    let log = `StorageAdminStats: ${s.when} ${s.requestedBy}\n`
+    log += `  ${al('', 13)} ${ar('Day', 18)} ${ar('Month', 18)} ${ar('Total', 18)}\n`
+    log += dmt('users', s.usersDay, s.usersMonth, s.usersTotal)
+    log += dmt('change sats', sa(s.satoshisDefaultDay), sa(s.satoshisDefaultMonth), sa(s.satoshisDefaultTotal))
+    log += dmt('other sats', sa(s.satoshisOtherDay), sa(s.satoshisOtherMonth), sa(s.satoshisOtherTotal))
+    log += dmt('labels', s.labelsDay, s.labelsMonth, s.labelsTotal)
+    log += dmt('tags', s.tagsDay, s.tagsMonth, s.tagsTotal)
+    log += dmt('baskets', s.basketsDay, s.basketsMonth, s.basketsTotal)
+    log += dmt('transactions', s.transactionsDay, s.transactionsMonth, s.transactionsTotal)
+    log += dmt('  completed', s.txCompletedDay, s.txCompletedMonth, s.txCompletedTotal)
+    log += dmt('  failed', s.txFailedDay, s.txFailedMonth, s.txFailedTotal)
+    log += dmt('  nosend', s.txNosendDay, s.txNosendMonth, s.txNosendTotal)
+    log += dmt('  unproven', s.txUnprovenDay, s.txUnprovenMonth, s.txUnprovenTotal)
+    log += dmt('  sending', s.txSendingDay, s.txSendingMonth, s.txSendingTotal)
+    log += dmt('  unprocessed', s.txUnprocessedDay, s.txUnprocessedMonth, s.txUnprocessedTotal)
+    log += dmt('  unsigned', s.txUnsignedDay, s.txUnsignedMonth, s.txUnsignedTotal)
+    log += dmt('  nonfinal', s.txNonfinalDay, s.txNonfinalMonth, s.txNonfinalTotal)
+    log += dmt('  unfail', s.txUnfailDay, s.txUnfailMonth, s.txUnfailTotal)
+
+    return log
+
+    function dmt(l: string, d: number | string, m: number | string, t: number | string): string {
+      return `  ${al(l, 13)} ${ar(d, 18)} ${ar(m, 18)} ${ar(t, 18)}\n`
+    }
+  }
+}
+
+const al = Format.alignLeft
+const ar = Format.alignRight
+const am = Format.alignMiddle
+const sa = Format.satoshis

package/src/utility/README.md

@@ -0,0 +1,3 @@
+# Utility
+
+Useful stuff that's shared by more than one high level function but not important enough to merrit its own bucket ":-)"

package/src/utility/ReaderUint8Array.ts

@@ -0,0 +1,187 @@
+import { BigNumber, Utils } from '@bsv/sdk'
+import { asArray } from './utilityHelpers.noBuffer'
+
+export class ReaderUint8Array {
+  public bin: Uint8Array
+  public pos: number
+  private readonly length: number
+
+  static makeReader(bin: Uint8Array | number[], pos: number = 0): ReaderUint8Array | Utils.Reader {
+    if (bin instanceof Uint8Array) {
+      return new ReaderUint8Array(bin, pos)
+    }
+    if (Array.isArray(bin)) {
+      return new Utils.Reader(bin, pos)
+    }
+    throw new Error('ReaderUint8Array.makeReader: bin must be Uint8Array or number[]')
+  }
+
+  constructor(bin: Uint8Array = new Uint8Array(0), pos: number = 0) {
+    this.bin = bin
+    this.pos = pos
+    this.length = bin.length
+  }
+
+  public eof(): boolean {
+    return this.pos >= this.length
+  }
+
+  public read(len = this.length): Uint8Array {
+    const start = this.pos
+    const end = this.pos + len
+    this.pos = end
+    return this.bin.slice(start, end)
+  }
+
+  public readReverse(len = this.length): Uint8Array {
+    const buf2 = new Uint8Array(len)
+    for (let i = 0; i < len; i++) {
+      buf2[i] = this.bin[this.pos + len - 1 - i]
+    }
+    this.pos += len
+    return buf2
+  }
+
+  public readUInt8(): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    return val
+  }
+
+  public readInt8(): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80) !== 0 ? val - 0x100 : val
+  }
+
+  public readUInt16BE(): number {
+    const val = (this.bin[this.pos] << 8) | this.bin[this.pos + 1]
+    this.pos += 2
+    return val
+  }
+
+  public readInt16BE(): number {
+    const val = this.readUInt16BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x8000) !== 0 ? val - 0x10000 : val
+  }
+
+  public readUInt16LE(): number {
+    const val = this.bin[this.pos] | (this.bin[this.pos + 1] << 8)
+    this.pos += 2
+    return val
+  }
+
+  public readInt16LE(): number {
+    const val = this.readUInt16LE()
+    // If the sign bit is set, convert to negative value
+    const x = (val & 0x8000) !== 0 ? val - 0x10000 : val
+    return x
+  }
+
+  public readUInt32BE(): number {
+    const val =
+      this.bin[this.pos] * 0x1000000 + // Shift the first byte by 24 bits
+      ((this.bin[this.pos + 1] << 16) | // Shift the second byte by 16 bits
+        (this.bin[this.pos + 2] << 8) | // Shift the third byte by 8 bits
+        this.bin[this.pos + 3]) // The fourth byte
+    this.pos += 4
+    return val
+  }
+
+  public readInt32BE(): number {
+    const val = this.readUInt32BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt32LE(): number {
+    const val =
+      (this.bin[this.pos] |
+        (this.bin[this.pos + 1] << 8) |
+        (this.bin[this.pos + 2] << 16) |
+        (this.bin[this.pos + 3] << 24)) >>>
+      0
+    this.pos += 4
+    return val
+  }
+
+  public readInt32LE(): number {
+    const val = this.readUInt32LE()
+    // Explicitly check if the sign bit is set and then convert to a negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt64BEBn(): BigNumber {
+    const bin = asArray(this.bin.slice(this.pos, this.pos + 8))
+    const bn = new BigNumber(bin)
+    this.pos = this.pos + 8
+    return bn
+  }
+
+  public readUInt64LEBn(): BigNumber {
+    const bin = asArray(this.readReverse(8))
+    const bn = new BigNumber(bin)
+    return bn
+  }
+
+  public readInt64LEBn(): BigNumber {
+    const OverflowInt64 = new BigNumber(2).pow(new BigNumber(63))
+    const OverflowUint64 = new BigNumber(2).pow(new BigNumber(64))
+    const bin = asArray(this.readReverse(8))
+    let bn = new BigNumber(bin)
+    if (bn.gte(OverflowInt64)) {
+      bn = bn.sub(OverflowUint64) // Adjust for negative numbers
+    }
+    return bn
+  }
+
+  public readVarIntNum(signed: boolean = true): number {
+    const first = this.readUInt8()
+    let bn: BigNumber
+    switch (first) {
+      case 0xfd:
+        return this.readUInt16LE()
+      case 0xfe:
+        return this.readUInt32LE()
+      case 0xff:
+        bn = signed ? this.readInt64LEBn() : this.readUInt64LEBn()
+        if (bn.lte(new BigNumber(2).pow(new BigNumber(53)))) {
+          return bn.toNumber()
+        } else {
+          throw new Error('number too large to retain precision - use readVarIntBn')
+        }
+      default:
+        return first
+    }
+  }
+
+  public readVarInt(): Uint8Array {
+    const first = this.bin[this.pos]
+    switch (first) {
+      case 0xfd:
+        return this.read(1 + 2)
+      case 0xfe:
+        return this.read(1 + 4)
+      case 0xff:
+        return this.read(1 + 8)
+      default:
+        return this.read(1)
+    }
+  }
+
+  public readVarIntBn(): BigNumber {
+    const first = this.readUInt8()
+    switch (first) {
+      case 0xfd:
+        return new BigNumber(this.readUInt16LE())
+      case 0xfe:
+        return new BigNumber(this.readUInt32LE())
+      case 0xff:
+        return this.readUInt64LEBn()
+      default:
+        return new BigNumber(first)
+    }
+  }
+}

package/src/utility/ScriptTemplateBRC29.ts

@@ -0,0 +1,73 @@
+import {
+  HexString,
+  KeyDeriverApi,
+  WalletProtocol,
+  ScriptTemplate,
+  ScriptTemplateUnlock,
+  LockingScript,
+  P2PKH,
+  PrivateKey,
+  Script,
+  CachedKeyDeriver
+} from '@bsv/sdk'
+import { asBsvSdkPrivateKey, verifyTruthy } from './utilityHelpers'
+
+export const brc29ProtocolID: WalletProtocol = [2, '3241645161d8']
+
+export interface ScriptTemplateParamsBRC29 {
+  derivationPrefix?: string
+  derivationSuffix?: string
+  keyDeriver: KeyDeriverApi
+}
+
+/**
+ * Simple Authenticated BSV P2PKH Payment Protocol
+ * https://brc.dev/29
+ */
+export class ScriptTemplateBRC29 implements ScriptTemplate {
+  p2pkh: P2PKH
+
+  constructor(public params: ScriptTemplateParamsBRC29) {
+    this.p2pkh = new P2PKH()
+
+    verifyTruthy(params.derivationPrefix)
+    verifyTruthy(params.derivationSuffix)
+  }
+
+  getKeyID() {
+    return `${this.params.derivationPrefix} ${this.params.derivationSuffix}`
+  }
+
+  getKeyDeriver(privKey: PrivateKey | HexString): KeyDeriverApi {
+    if (typeof privKey === 'string') privKey = PrivateKey.fromHex(privKey)
+    if (!this.params.keyDeriver || this.params.keyDeriver.rootKey.toHex() !== privKey.toHex())
+      return new CachedKeyDeriver(privKey)
+    return this.params.keyDeriver
+  }
+
+  lock(lockerPrivKey: string, unlockerPubKey: string): LockingScript {
+    const address = this.getKeyDeriver(lockerPrivKey)
+      .derivePublicKey(brc29ProtocolID, this.getKeyID(), unlockerPubKey, false)
+      .toAddress()
+    const r = this.p2pkh.lock(address)
+    return r
+  }
+
+  unlock(
+    unlockerPrivKey: string,
+    lockerPubKey: string,
+    sourceSatoshis?: number,
+    lockingScript?: Script
+  ): ScriptTemplateUnlock {
+    const derivedPrivateKey = this.getKeyDeriver(unlockerPrivKey)
+      .derivePrivateKey(brc29ProtocolID, this.getKeyID(), lockerPubKey)
+      .toHex()
+    const r = this.p2pkh.unlock(asBsvSdkPrivateKey(derivedPrivateKey), 'all', false, sourceSatoshis, lockingScript)
+    return r
+  }
+
+  /**
+   * P2PKH unlock estimateLength is a constant
+   */
+  unlockLength = 108
+}

package/src/utility/__tests/utilityHelpers.noBuffer.test.ts

@@ -0,0 +1,109 @@
+import { asString, asUint8Array } from '../utilityHelpers.noBuffer'
+
+describe('utilityHelpers.noBuffer tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 convert from Uint8Array', async () => {
+    const a = new Uint8Array([1, 2, 3, 4])
+    {
+      const r = asUint8Array(a)
+      expect(r.length).toBe(4)
+      expect(r.every((v, i) => v === a[i])).toBe(true)
+    }
+    {
+      const r = asString(a)
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'hex')
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'utf8')
+      expect(r).toBe('\x01\x02\x03\x04')
+    }
+    {
+      const r = asString(a, 'base64')
+      expect(r).toBe('AQIDBA==')
+    }
+  })
+
+  test('1 convert from number[]', async () => {
+    const a = [1, 2, 3, 4]
+    {
+      const r = asUint8Array(a)
+      expect(r.length).toBe(4)
+      expect(r.every((v, i) => v === a[i])).toBe(true)
+    }
+    {
+      const r = asString(a)
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'hex')
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'utf8')
+      expect(r).toBe('\x01\x02\x03\x04')
+    }
+    {
+      const r = asString(a, 'base64')
+      expect(r).toBe('AQIDBA==')
+    }
+  })
+
+  test('2 convert from hex string', async () => {
+    const a = '01020304'
+    {
+      const r = asUint8Array(a)
+      expect(r.length).toBe(4)
+      expect(r.every((v, i) => v === parseInt(a.slice(i * 2, i * 2 + 2), 16))).toBe(true)
+    }
+    {
+      const r = asString(a)
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'hex')
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'hex', 'hex')
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'hex', 'utf8')
+      expect(r).toBe('\x01\x02\x03\x04')
+    }
+    {
+      const r = asString(a, 'hex', 'base64')
+      expect(r).toBe('AQIDBA==')
+    }
+  })
+
+  test('3 convert from utf8 string', async () => {
+    const a = '\x01\x02\x03\x04'
+    {
+      const r = asUint8Array(a, 'utf8')
+      expect(r.length).toBe(4)
+      expect(r.every((v, i) => v === i + 1)).toBe(true)
+    }
+    {
+      const r = asString(a, 'utf8', 'hex')
+      expect(r).toBe('01020304')
+    }
+    {
+      const r = asString(a, 'utf8')
+      expect(r).toBe('\x01\x02\x03\x04')
+    }
+    {
+      const r = asString(a, 'utf8', 'utf8')
+      expect(r).toBe('\x01\x02\x03\x04')
+    }
+    {
+      const r = asString(a, 'utf8', 'base64')
+      expect(r).toBe('AQIDBA==')
+    }
+  })
+})

package/src/utility/aggregateResults.ts

@@ -0,0 +1,68 @@
+import { Beef, ReviewActionResult, SendWithResult } from '@bsv/sdk'
+import { PostReqsToNetworkResult } from '../storage/methods/attemptToPostReqsToNetwork'
+import { StorageGetBeefOptions, WERR_INTERNAL } from '../sdk'
+import { StorageProvider } from '../index.client'
+
+export const aggregateActionResults = async (
+  storage: StorageProvider,
+  sendWithResultReqs: SendWithResult[],
+  postToNetworkResult: PostReqsToNetworkResult
+): Promise<{
+  swr: SendWithResult[]
+  rar: ReviewActionResult[]
+}> => {
+  const swr: SendWithResult[] = []
+  const rar: ReviewActionResult[] = []
+
+  for (const ar of sendWithResultReqs) {
+    const txid = ar.txid
+
+    const d = postToNetworkResult.details.find(d => d.txid === txid)
+    if (!d) throw new WERR_INTERNAL(`missing details for ${txid}`)
+
+    const arNdr: ReviewActionResult = { txid: d.txid, status: 'success', competingTxs: d.competingTxs }
+    switch (d.status) {
+      case 'success':
+        // processing network has accepted this transaction
+        ar.status = 'unproven'
+        break
+      case 'doubleSpend':
+        // confirmed double spend.
+        ar.status = 'failed'
+        arNdr.status = 'doubleSpend'
+        if (d.competingTxs) arNdr.competingBeef = await createMergedBeefOfTxids(d.competingTxs, storage)
+        break
+      case 'serviceError':
+        // services might improve
+        ar.status = 'sending'
+        arNdr.status = 'serviceError'
+        break
+      case 'invalidTx':
+        // nothing will fix this transaction
+        ar.status = 'failed'
+        arNdr.status = 'invalidTx'
+        break
+      case 'unknown':
+      case 'invalid':
+      default:
+        throw new WERR_INTERNAL(`processAction with notDelayed status ${d.status} should not occur.`)
+    }
+
+    swr.push({ txid, status: ar.status })
+    rar.push(arNdr)
+  }
+
+  return { swr, rar }
+}
+
+async function createMergedBeefOfTxids(txids: string[], storage: StorageProvider): Promise<number[]> {
+  const beef = new Beef()
+  const options: StorageGetBeefOptions = {
+    mergeToBeef: beef,
+    ignoreNewProven: true
+  }
+  for (const txid of txids) {
+    await storage.getBeefForTransaction(txid, options)
+  }
+  return beef.toBinary()
+}