@bopen-io/wallet-toolbox 1.7.18

package/src/utility/identityUtils.ts

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,7 @@
+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

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

package/src/utility/parseTxScriptOffsets.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,69 @@
+/**
+ * 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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,34 @@
+/**
+ * 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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,275 @@
+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)
+  }
+}