@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/src/utility/identityUtils.ts

@@ -1,159 +0,0 @@
-import {
-  LookupAnswer,
-  Transaction,
-  PushDrop,
-  VerifiableCertificate,
-  Utils,
-  ProtoWallet,
-  LookupResolver,
-  DiscoverCertificatesResult,
-  IdentityCertificate,
-  IdentityCertifier,
-  Base64String
-} from '@bsv/sdk'
-import { Certifier, TrustSettings } from '../WalletSettingsManager'
-
-const OUTPUT_INDEX = 0
-
-// Our extended certificate includes certifierInfo.
-export interface ExtendedVerifiableCertificate extends IdentityCertificate {
-  certifierInfo: IdentityCertifier
-  publiclyRevealedKeyring: Record<string, Base64String>
-}
-
-// --- Helper Types for Grouping ---
-
-interface IdentityGroup {
-  totalTrust: number
-  members: ExtendedVerifiableCertificate[]
-}
-
-/**
- * Transforms an array of VerifiableCertificate instances according to the trust settings.
- * Only certificates whose grouped total trust meets the threshold are returned,
- * and each certificate is augmented with a certifierInfo property.
- *
- * @param trustSettings - the user's trust settings including trustLevel and trusted certifiers.
- * @param certificates - an array of VerifiableCertificate objects.
- * @returns a DiscoverCertificatesResult with totalCertificates and ordered certificates.
- */
-export const transformVerifiableCertificatesWithTrust = (
-  trustSettings: TrustSettings,
-  certificates: VerifiableCertificate[]
-): DiscoverCertificatesResult => {
-  // Group certificates by subject while accumulating trust.
-  const identityGroups: Record<string, IdentityGroup> = {}
-  // Cache certifier lookups.
-  const certifierCache: Record<string, Certifier> = {}
-
-  certificates.forEach(cert => {
-    const { subject, certifier } = cert
-    if (!subject || !certifier) return
-
-    // Lookup and cache certifier details from trustSettings.
-    if (!certifierCache[certifier]) {
-      const found = trustSettings.trustedCertifiers.find(x => x.identityKey === certifier)
-      if (!found) return // Skip this certificate if its certifier is not trusted.
-      certifierCache[certifier] = found
-    }
-
-    // Create the IdentityCertifier object that we want to attach.
-    const certifierInfo: IdentityCertifier = {
-      name: certifierCache[certifier].name,
-      iconUrl: certifierCache[certifier].iconUrl || '',
-      description: certifierCache[certifier].description,
-      trust: certifierCache[certifier].trust
-    }
-
-    // Create an extended certificate that includes certifierInfo.
-    // Note: We use object spread to copy over all properties from the original certificate.
-    const extendedCert: IdentityCertificate = {
-      ...cert,
-      signature: cert.signature!, // We know it exists at this point
-      decryptedFields: cert.decryptedFields as Record<string, string>,
-      publiclyRevealedKeyring: cert.keyring,
-      certifierInfo
-    }
-
-    // Group certificates by subject.
-    if (!identityGroups[subject]) {
-      identityGroups[subject] = { totalTrust: 0, members: [] }
-    }
-    identityGroups[subject].totalTrust += certifierInfo.trust
-    identityGroups[subject].members.push(extendedCert)
-  })
-
-  // Filter out groups that do not meet the trust threshold and flatten the results.
-  const finalResults: ExtendedVerifiableCertificate[] = []
-  Object.values(identityGroups).forEach(group => {
-    if (group.totalTrust >= trustSettings.trustLevel) {
-      finalResults.push(...group.members)
-    }
-  })
-
-  // Sort the certificates by their certifier trust in descending order.
-  finalResults.sort((a, b) => b.certifierInfo.trust - a.certifierInfo.trust)
-
-  return {
-    totalCertificates: finalResults.length,
-    certificates: finalResults
-  }
-}
-
-/**
- * Performs an identity overlay service lookup query and returns the parsed results
- *
- * @param query
- * @returns
- */
-export const queryOverlay = async (query: unknown, resolver: LookupResolver): Promise<VerifiableCertificate[]> => {
-  const results = await resolver.query({
-    service: 'ls_identity',
-    query
-  })
-
-  return await parseResults(results)
-}
-
-/**
- * Internal func: Parse the returned UTXOs Decrypt and verify the certificates and signatures Return the set of identity keys, certificates and decrypted certificate fields
- *
- * @param {Output[]} outputs
- * @returns {Promise<VerifiableCertificate[]>}
- */
-export const parseResults = async (lookupResult: LookupAnswer): Promise<VerifiableCertificate[]> => {
-  if (lookupResult.type === 'output-list') {
-    const parsedResults: VerifiableCertificate[] = []
-
-    for (const output of lookupResult.outputs) {
-      try {
-        const tx = Transaction.fromBEEF(output.beef)
-        // Decode the Identity token fields from the Bitcoin outputScript
-        const decodedOutput = PushDrop.decode(tx.outputs[output.outputIndex].lockingScript)
-
-        // Parse out the certificate and relevant data
-        const certificate: VerifiableCertificate = JSON.parse(Utils.toUTF8(decodedOutput.fields[0])) // TEST
-        const verifiableCert = new VerifiableCertificate(
-          certificate.type,
-          certificate.serialNumber,
-          certificate.subject,
-          certificate.certifier,
-          certificate.revocationOutpoint,
-          certificate.fields,
-          certificate.keyring,
-          certificate.signature
-        )
-        const decryptedFields = await verifiableCert.decryptFields(new ProtoWallet('anyone'))
-        // Verify the certificate signature is correct
-        await verifiableCert.verify()
-        verifiableCert.decryptedFields = decryptedFields
-        parsedResults.push(verifiableCert)
-      } catch (error) {
-        console.error(error)
-        // do nothing
-      }
-    }
-    return parsedResults
-  }
-  return []
-}

package/src/utility/index.all.ts

@@ -1,7 +0,0 @@
-export * from './stampLog'
-export * from './ScriptTemplateBRC29'
-export * from './parseTxScriptOffsets'
-export * from './tscProofToMerklePath'
-export * from './utilityHelpers'
-
-export * from './utilityHelpers.buffer'

package/src/utility/index.client.ts

@@ -1,7 +0,0 @@
-export * from './stampLog'
-export * from './ScriptTemplateBRC29'
-export * from './parseTxScriptOffsets'
-export * from './tscProofToMerklePath'
-export * from './utilityHelpers'
-
-export * from './utilityHelpers.noBuffer'

package/src/utility/parseTxScriptOffsets.ts

@@ -1,29 +0,0 @@
-import { Utils as SdkUtils } from '@bsv/sdk'
-
-export interface TxScriptOffsets {
-  inputs: { vin: number; offset: number; length: number }[]
-  outputs: { vout: number; offset: number; length: number }[]
-}
-
-export function parseTxScriptOffsets(rawTx: number[]): TxScriptOffsets {
-  const br = new SdkUtils.Reader(rawTx)
-  const inputs: { vin: number; offset: number; length: number }[] = []
-  const outputs: { vout: number; offset: number; length: number }[] = []
-
-  br.pos += 4 // version
-  const inputsLength = br.readVarIntNum()
-  for (let i = 0; i < inputsLength; i++) {
-    br.pos += 36 // txid and vout
-    const scriptLength = br.readVarIntNum()
-    inputs.push({ vin: i, offset: br.pos, length: scriptLength })
-    br.pos += scriptLength + 4 // script and sequence
-  }
-  const outputsLength = br.readVarIntNum()
-  for (let i = 0; i < outputsLength; i++) {
-    br.pos += 8 // satoshis
-    const scriptLength = br.readVarIntNum()
-    outputs.push({ vout: i, offset: br.pos, length: scriptLength })
-    br.pos += scriptLength
-  }
-  return { inputs, outputs }
-}

package/src/utility/stampLog.ts

@@ -1,69 +0,0 @@
-/**
- * If a log is being kept, add a time stamped line.
- * @param log  Optional time stamped log to extend, or an object with a log property to update
- * @param lineToAdd Content to add to line.
- * @returns undefined or log extended by time stamped `lineToAdd` and new line.
- */
-export function stampLog(log: string | undefined | { log?: string }, lineToAdd: string): string | undefined {
-  const add = `${new Date().toISOString()} ${lineToAdd}\n`
-  if (typeof log === 'object' && typeof log.log === 'string') return (log.log = log.log + add)
-  if (typeof log === 'string') return log + add
-  return undefined
-}
-
-/**
- * Replaces individual timestamps with delta msecs.
- * Looks for two network crossings and adjusts clock for clock skew if found.
- * Assumes log built by repeated calls to `stampLog`
- * @param log Each logged event starts with ISO time stamp, space, rest of line, terminated by `\n`.
- * @returns reformated multi-line event log
- */
-export function stampLogFormat(log?: string): string {
-  if (typeof log !== 'string') return ''
-  const logLines = log.split('\n')
-  const data: {
-    when: number
-    rest: string
-    delta: number
-    newClock: boolean
-  }[] = []
-  let last = 0
-  const newClocks: number[] = []
-  for (const line of logLines) {
-    const spaceAt = line.indexOf(' ')
-    if (spaceAt > -1) {
-      const when = new Date(line.substring(0, spaceAt)).getTime()
-      const rest = line.substring(spaceAt + 1)
-      const delta = when - (last || when)
-      const newClock = rest.indexOf('**NETWORK**') > -1
-      if (newClock) newClocks.push(data.length)
-      data.push({ when, rest, delta, newClock })
-      last = when
-    }
-  }
-  const total = data[data.length - 1].when - data[0].when
-  if (newClocks.length % 2 === 0) {
-    // Adjust for paired network crossing times and clock skew between clocks.
-    let network = total
-    let lastNewClock = 0
-    for (const newClock of newClocks) {
-      network -= data[newClock - 1].when - data[lastNewClock].when
-      lastNewClock = newClock
-    }
-    network -= data[data.length - 1].when - data[lastNewClock].when
-    let networks = newClocks.length
-    for (const newClock of newClocks) {
-      const n = networks > 1 ? Math.floor(network / networks) : network
-      data[newClock].delta = n
-      network -= n
-      networks--
-    }
-  }
-  let log2 = `${new Date(data[0].when).toISOString()} Total = ${total} msecs\n`
-  for (const d of data) {
-    let df = d.delta.toString()
-    df = `${' '.repeat(8 - df.length)}${df}`
-    log2 += `${df} ${d.rest}\n`
-  }
-  return log2
-}

package/src/utility/tscProofToMerklePath.ts

@@ -1,48 +0,0 @@
-import { MerklePath } from '@bsv/sdk'
-
-export interface TscMerkleProofApi {
-  height: number
-  index: number
-  nodes: string[]
-}
-
-export function convertProofToMerklePath(txid: string, proof: TscMerkleProofApi): MerklePath {
-  const blockHeight = proof.height
-  const treeHeight = proof.nodes.length
-  type Leaf = {
-    offset: number
-    hash?: string
-    txid?: boolean
-    duplicate?: boolean
-  }
-  const path: Leaf[][] = Array(treeHeight)
-    .fill(0)
-    .map(() => [])
-  let index = proof.index
-  for (let level = 0; level < treeHeight; level++) {
-    const node = proof.nodes[level]
-    const isOdd = index % 2 === 1
-    const offset = isOdd ? index - 1 : index + 1
-    const leaf: Leaf = { offset }
-    if (node === '*' || (level === 0 && node === txid)) {
-      leaf.duplicate = true
-    } else {
-      leaf.hash = node
-    }
-    path[level].push(leaf)
-    if (level === 0) {
-      const txidLeaf: Leaf = {
-        offset: proof.index,
-        hash: txid,
-        txid: true
-      }
-      if (isOdd) {
-        path[0].push(txidLeaf)
-      } else {
-        path[0].unshift(txidLeaf)
-      }
-    }
-    index = index >> 1
-  }
-  return new MerklePath(blockHeight, path)
-}

package/src/utility/utilityHelpers.buffer.ts

@@ -1,34 +0,0 @@
-/**
- * Coerce a value to Buffer if currently encoded as a string or
- * @param val Buffer or string or number[]. If string, encoding param applies. If number[], Buffer.from constructor is used.
- * @param encoding defaults to 'hex'. Only applies to val of type string
- * @returns input val if it is a Buffer or new Buffer from string val
- * @publicbody
- */
-export function asBuffer(val: Buffer | string | number[], encoding?: BufferEncoding): Buffer {
-  let b: Buffer
-  if (Buffer.isBuffer(val)) b = val
-  else if (typeof val === 'string') b = Buffer.from(val, encoding ?? 'hex')
-  else b = Buffer.from(val)
-  return b
-}
-
-/**
- * Coerce a value to an encoded string if currently a Buffer or number[]
- * @param val Buffer or string or number[]. If string, encoding param applies. If number[], Buffer.from constructor is used.
- * @param encoding defaults to 'hex'
- * @returns input val if it is a string; or if number[], first converted to Buffer then as Buffer; if Buffer encoded using `encoding`
- * @publicbody
- */
-export function asString(val: Buffer | string | number[], encoding?: BufferEncoding): string {
-  if (Array.isArray(val)) val = Buffer.from(val)
-  return Buffer.isBuffer(val) ? val.toString(encoding ?? 'hex') : val
-}
-
-export function asArray(val: Buffer | string | number[], encoding?: BufferEncoding): number[] {
-  let a: number[]
-  if (Array.isArray(val)) a = val
-  else if (Buffer.isBuffer(val)) a = Array.from(val)
-  else a = Array.from(Buffer.from(val, encoding || 'hex'))
-  return a
-}

package/src/utility/utilityHelpers.noBuffer.ts

@@ -1,60 +0,0 @@
-import { Utils } from '@bsv/sdk'
-
-/**
- * Convert a value to an encoded string if currently an encoded string or number[] or Uint8Array.
- * @param val string or number[] or Uint8Array. If string, encoding must be hex. If number[], each value must be 0..255.
- * @param enc optional encoding type if val is string, defaults to 'hex'. Can be 'hex', 'utf8', or 'base64'.
- * @param returnEnc optional encoding type for returned string if different from `enc`, defaults to 'hex'. Can be 'hex', 'utf8', or 'base64'.
- * @returns hex encoded string representation of val.
- * @publicbody
- */
-export function asString(
-  val: string | number[] | Uint8Array,
-  enc?: 'hex' | 'utf8' | 'base64',
-  returnEnc?: 'hex' | 'utf8' | 'base64'
-): string {
-  enc ||= 'hex'
-  returnEnc ||= enc
-  if (typeof val === 'string') {
-    if (enc === returnEnc) return val
-    val = asUint8Array(val, enc)
-  }
-  let v = Array.isArray(val) ? val : Array.from(val)
-  switch (returnEnc) {
-    case 'utf8':
-      return Utils.toUTF8(v)
-    case 'base64':
-      return Utils.toBase64(v)
-  }
-  return Utils.toHex(v)
-}
-
-/**
- * Convert a value to number[] if currently an encoded string or number[] or Uint8Array.
- * @param val string or number[] or Uint8Array. If string, encoding must be hex. If number[], each value must be 0..255.
- * @param enc optional encoding type if val is string, defaults to 'hex'. Can be 'hex', 'utf8', or 'base64'.
- * @returns number[] array of byte values representation of val.
- * @publicbody
- */
-export function asArray(val: string | number[] | Uint8Array, enc?: 'hex' | 'utf8' | 'base64'): number[] {
-  if (Array.isArray(val)) return val
-  if (typeof val !== 'string') return Array.from(val)
-  enc ||= 'hex'
-  let a: number[] = Utils.toArray(val, enc)
-  return a
-}
-
-/**
- * Convert a value to Uint8Array if currently an encoded string or number[] or Uint8Array.
- * @param val string or number[] or Uint8Array. If string, encoding must be hex. If number[], each value must be 0..255.
- * @param enc optional encoding type if val is string, defaults to 'hex'. Can be 'hex', 'utf8', or 'base64'.
- * @returns Uint8Array representation of val.
- * @publicbody
- */
-export function asUint8Array(val: string | number[] | Uint8Array, enc?: 'hex' | 'utf8' | 'base64'): Uint8Array {
-  if (Array.isArray(val)) return Uint8Array.from(val)
-  if (typeof val !== 'string') return val
-  enc ||= 'hex'
-  let a: number[] = Utils.toArray(val, enc)
-  return Uint8Array.from(a)
-}

package/src/utility/utilityHelpers.ts

@@ -1,275 +0,0 @@
-import { HexString, PubKeyHex, WalletNetwork } from '@bsv/sdk'
-import { Beef, Hash, PrivateKey, PublicKey, Random, Script, Transaction, Utils } from '@bsv/sdk'
-import { Chain } from '../sdk/types'
-import { asArray } from './utilityHelpers.noBuffer'
-import { CertOpsWallet } from '../sdk/CertOpsWallet'
-import { WERR_BAD_REQUEST, WERR_INTERNAL, WERR_INVALID_PARAMETER } from '../sdk/WERR_errors'
-
-export async function getIdentityKey(wallet: CertOpsWallet): Promise<PubKeyHex> {
-  return (await wallet.getPublicKey({ identityKey: true })).publicKey
-}
-
-export function toWalletNetwork(chain: Chain): WalletNetwork {
-  return chain === 'main' ? 'mainnet' : 'testnet'
-}
-
-export function makeAtomicBeef(tx: Transaction, beef: number[] | Beef): number[] {
-  if (Array.isArray(beef)) beef = Beef.fromBinary(beef)
-  beef.mergeTransaction(tx)
-  return beef.toBinaryAtomic(tx.id('hex'))
-}
-
-/**
- * Coerce a bsv transaction encoded as a hex string, serialized array, or Transaction to Transaction
- * If tx is already a Transaction, just return it.
- * @publicbody
- */
-export function asBsvSdkTx(tx: HexString | number[] | Transaction): Transaction {
-  if (Array.isArray(tx)) {
-    tx = Transaction.fromBinary(tx)
-  } else if (typeof tx === 'string') {
-    tx = Transaction.fromHex(tx)
-  }
-  return tx
-}
-
-/**
- * Coerce a bsv script encoded as a hex string, serialized array, or Script to Script
- * If script is already a Script, just return it.
- * @publicbody
- */
-export function asBsvSdkScript(script: HexString | number[] | Script): Script {
-  if (Array.isArray(script)) {
-    script = Script.fromBinary(script)
-  } else if (typeof script === 'string') {
-    script = Script.fromHex(script)
-  }
-  return script
-}
-
-/**
- * @param privKey bitcoin private key in 32 byte hex string form
- * @returns @bsv/sdk PrivateKey
- */
-export function asBsvSdkPrivateKey(privKey: string): PrivateKey {
-  return PrivateKey.fromString(privKey, 'hex')
-}
-
-/**
- * @param pubKey bitcoin public key in standard compressed key hex string form
- * @returns @bsv/sdk PublicKey
- */
-export function asBsvSdkPublickKey(pubKey: string): PublicKey {
-  return PublicKey.fromString(pubKey)
-}
-
-/**
- * Helper function.
- *
- * Verifies that a possibly optional value has a value.
- */
-export function verifyTruthy<T>(v: T | null | undefined, description?: string): T {
-  if (!v) throw new WERR_INTERNAL(description ?? 'A truthy value is required.')
-  return v
-}
-
-/**
- * Helper function.
- *
- * Verifies that a hex string is trimmed and lower case.
- */
-export function verifyHexString(v: string): string {
-  if (typeof v !== 'string') throw new WERR_INTERNAL('A string is required.')
-  v = v.trim().toLowerCase()
-  return v
-}
-
-/**
- * Helper function.
- *
- * Verifies that an optional or null hex string is undefined or a trimmed lowercase string.
- */
-export function verifyOptionalHexString(v?: string | null): string | undefined {
-  if (!v) return undefined
-  return verifyHexString(v)
-}
-
-/**
- * Helper function.
- *
- * Verifies that an optional or null number has a numeric value.
- */
-export function verifyNumber(v: number | null | undefined): number {
-  if (typeof v !== 'number') throw new WERR_INTERNAL('A number is required.')
-  return v
-}
-
-/**
- * Helper function.
- *
- * Verifies that an optional or null number has a numeric value.
- */
-export function verifyInteger(v: number | null | undefined): number {
-  if (typeof v !== 'number' || !Number.isInteger(v)) throw new WERR_INTERNAL('An integer is required.')
-  return v
-}
-
-/**
- * Helper function.
- *
- * Verifies that a database record identifier is an integer greater than zero.
- */
-export function verifyId(id: number | undefined | null): number {
-  id = verifyInteger(id)
-  if (id < 1) throw new WERR_INTERNAL(`id must be valid integer greater than zero.`)
-  return id
-}
-
-/**
- * Helper function.
- *
- * @throws WERR_BAD_REQUEST if results has length greater than one.
- *
- * @returns results[0] or undefined if length is zero.
- */
-export function verifyOneOrNone<T>(results: T[]): T | undefined {
-  if (results.length > 1) throw new WERR_BAD_REQUEST('Result must be unique.')
-  return results[0]
-}
-
-/**
- * Helper function.
- *
- * @throws WERR_BAD_REQUEST if results has length other than one.
- *
- * @returns results[0].
- */
-export function verifyOne<T>(results: T[], errorDescrition?: string): T {
-  if (results.length !== 1) throw new WERR_BAD_REQUEST(errorDescrition ?? 'Result must exist and be unique.')
-  return results[0]
-}
-
-/**
- * Returns an await'able Promise that resolves in the given number of msecs.
- * @param msecs number of milliseconds to wait before resolving the promise.
- * Must be greater than zero and less than 2 minutes (120,000 msecs)
- * @publicbody
- */
-export function wait(msecs: number): Promise<void> {
-  const MIN_WAIT = 0
-  const MAX_WAIT = 2 * 60 * 1000 // maximum allowed wait in ms (2 minutes)
-  if (typeof msecs !== 'number' || !Number.isFinite(msecs) || isNaN(msecs) || msecs < MIN_WAIT || msecs > MAX_WAIT) {
-    throw new WERR_INVALID_PARAMETER('msecs', `a number between ${MIN_WAIT} and ${MAX_WAIT} msecs, not ${msecs}.`)
-  }
-  return new Promise(resolve => setTimeout(resolve, msecs))
-}
-
-/**
- * @returns count cryptographically secure random bytes as array of bytes
- */
-export function randomBytes(count: number): number[] {
-  return Random(count)
-}
-
-/**
- * @returns count cryptographically secure random bytes as hex encoded string
- */
-export function randomBytesHex(count: number): string {
-  return Utils.toHex(Random(count))
-}
-
-/**
- * @returns count cryptographically secure random bytes as base64 encoded string
- */
-export function randomBytesBase64(count: number): string {
-  return Utils.toBase64(Random(count))
-}
-
-export function validateSecondsSinceEpoch(time: number): Date {
-  const date = new Date(time * 1000)
-  if (date.getTime() / 1000 !== time || time < 1600000000 || time > 100000000000) {
-    throw new WERR_INVALID_PARAMETER('time', `valid "since epoch" unix time`)
-  }
-  return date
-}
-
-/**
- * Compares lengths and direct equality of values.
- * @param arr1
- * @param arr2
- * @returns
- */
-export function arraysEqual(arr1: Number[], arr2: Number[]) {
-  if (arr1.length !== arr2.length) return false
-  for (let i = 0; i < arr1.length; i++) {
-    if (arr1[i] !== arr2[i]) return false
-  }
-  return true
-}
-
-export function optionalArraysEqual(arr1?: Number[], arr2?: Number[]) {
-  if (!arr1 && !arr2) return true
-  if (!arr1 || !arr2) return false
-  return arraysEqual(arr1, arr2)
-}
-
-export function maxDate(d1?: Date, d2?: Date): Date | undefined {
-  if (d1 && d2) {
-    if (d1 > d2) return d1
-    return d2
-  }
-  if (d1) return d1
-  if (d2) return d2
-  return undefined
-}
-
-/**
- * Calculate the SHA256 hash of an array of bytes
- * @returns sha256 hash of buffer contents.
- * @publicbody
- */
-export function sha256Hash(data: number[] | Uint8Array): number[] {
-  if (!Array.isArray(data)) {
-    data = asArray(data)
-  }
-  const first = new Hash.SHA256().update(data).digest()
-  return first
-}
-
-/**
- * Calculate the SHA256 hash of the SHA256 hash of an array of bytes.
- * @param data an array of bytes
- * @returns double sha256 hash of data, byte 0 of hash first.
- * @publicbody
- */
-export function doubleSha256LE(data: number[] | Uint8Array): number[] {
-  if (!Array.isArray(data)) {
-    data = asArray(data)
-  }
-  const first = new Hash.SHA256().update(data).digest()
-  const second = new Hash.SHA256().update(first).digest()
-  return second
-}
-
-/**
- * Calculate the SHA256 hash of the SHA256 hash of an array of bytes.
- * @param data is an array of bytes.
- * @returns reversed (big-endian) double sha256 hash of data, byte 31 of hash first.
- * @publicbody
- */
-export function doubleSha256BE(data: number[] | Uint8Array): number[] {
-  return doubleSha256LE(data).reverse()
-}
-
-/**
- * Logging function to handle logging based on running in jest "single test" mode,
- *
- * @param {string} message - The main message to log.
- * @param {...any} optionalParams - Additional parameters to log (optional).
- */
-export const logger = (message: string, ...optionalParams: any[]): void => {
-  const isSingleTest = process.argv.some(arg => arg === '--testNamePattern' || arg === '-t')
-  if (isSingleTest) {
-    console.log(message, ...optionalParams)
-  }
-}