@bsv/wallet-toolbox 1.3.23 → 1.3.25

package/src/services/chaintracker/chaintracks/util/blockHeaderUtilities.ts

@@ -0,0 +1,490 @@
+import { validateAgainstDirtyHashes } from './dirtyHashes'
+import { BigNumber, Hash, Utils } from '@bsv/sdk'
+
+import { promises as fs } from 'fs'
+
+import { asArray, asBuffer, asString } from '../../../../utility/utilityHelpers.buffer'
+import { doubleSha256BE, doubleSha256LE } from '../../../../utility/utilityHelpers'
+import { BaseBlockHeader, BlockHeader } from '../Api/BlockHeaderApi'
+import { Chain } from '../../../../sdk/types'
+
+/**
+ * Computes sha256 hash of file contents read as bytes with no encoding.
+ * @param filepath Full filepath to file.
+ * @param bufferSize Optional read buffer size to use. Defaults to 80,000 bytes.
+ * @returns `{hash, length}` where `hash` is base64 string form of file hash and `length` is file length in bytes.
+ */
+export async function sha256HashOfBinaryFile(
+  filepath: string,
+  bufferSize = 80000
+): Promise<{ hash: string; length: number }> {
+  const file = await fs.open(filepath, 'r')
+  try {
+    let length = 0
+
+    const sha256 = new Hash.SHA256()
+    const readBuf = Buffer.alloc(bufferSize)
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const rr = await file.read(readBuf, 0, readBuf.length)
+      if (!rr.bytesRead) break
+      length += rr.bytesRead
+      sha256.update(asArray(rr.buffer))
+    }
+
+    return { hash: Utils.toBase64(sha256.digest()), length }
+  } finally {
+    await file.close()
+  }
+}
+
+/**
+ * Validate headers contained in an array of bytes. The headers must be consecutive block headers, 80 bytes long,
+ *  where the hash of each header equals the previousHash of the following header.
+ * @param buffer Buffer of headers to be validated.
+ * @param previousHash Expected previousHash of first header.
+ * @param offset Optional starting offset within `buffer`.
+ * @param count Optional number of headers to validate. Validates to end of buffer if missing.
+ * @returns Header hash of last header validated or previousHash if there where none.
+ */
+export function validateBufferOfHeaders(buffer: number[], previousHash: string, offset = 0, count = -1): string {
+  if (count < 0) count = Math.floor((buffer.length - offset) / 80)
+  count = Math.max(0, count)
+  let lastHeaderHash = previousHash
+  for (let i = 0; i < count; i++) {
+    const headerStart = offset + i * 80
+    const headerEnd = headerStart + 80
+    if (headerEnd > buffer.length) {
+      throw {
+        message: `header ${i} missing bytes for header at offset ${headerStart} in buffer of length ${buffer.length}`
+      }
+    }
+    const header = buffer.slice(headerStart, headerEnd)
+    const hashPrev = asString(header.slice(4, 36).reverse())
+    if (lastHeaderHash !== hashPrev)
+      throw { message: `header ${i} invalid previousHash ${lastHeaderHash} vs ${hashPrev}` }
+    lastHeaderHash = asString(doubleSha256BE(header))
+    validateAgainstDirtyHashes(lastHeaderHash)
+  }
+  return lastHeaderHash
+}
+
+/**
+ * @param work chainWork as a BigNumber
+ * @returns Converted chainWork value from BN to hex string of 32 bytes.
+ */
+export function workBNtoBuffer(work: BigNumber): string {
+  return work.toString(16).padStart(64, '0')
+}
+
+/**
+ * Returns true if work1 is more work (greater than) work2
+ */
+export function isMoreWork(work1: string, work2: string): boolean {
+  return new BigNumber(asArray(work1), 16).gt(new BigNumber(asArray(work2), 16))
+}
+
+/**
+ * Add two Buffer encoded chainwork values
+ * @returns Sum of work1 + work2 as Buffer encoded chainWork value
+ */
+export function addWork(work1: string, work2: string): string {
+  const sum = new BigNumber(asArray(work1), 16).add(new BigNumber(asArray(work2), 16))
+  return workBNtoBuffer(sum)
+}
+
+/**
+ * Subtract Buffer encoded chainwork values
+ * @returns work1 - work2 as Buffer encoded chainWork value
+ */
+export function subWork(work1: string, work2: string): string {
+  const sum = new BigNumber(asArray(work1), 16).sub(new BigNumber(asArray(work2), 16))
+  return workBNtoBuffer(sum)
+}
+
+/**
+ * Computes "target" value for 4 byte Bitcoin block header "bits" value.
+ * @param bits number or converted from Buffer using `readUint32LE`
+ * @returns 32 byte Buffer with "target" value
+ */
+export function convertBitsToTarget(bits: number | number[]): BigNumber {
+  if (Array.isArray(bits)) bits = readUInt32LE(bits, 0)
+
+  const shift = (bits >> 24) & 0xff
+  const data = bits & 0x007fffff
+
+  const target = new BigNumber(data)
+  if (shift <= 3) {
+    target.iushrn(8 * (3 - shift))
+  } else {
+    target.iushln(8 * (shift - 3))
+  }
+
+  return target
+}
+
+/**
+ * Computes "chainWork" value for 4 byte Bitcoin block header "bits" value.
+ * @param bits number or converted from Buffer using `readUint32LE`
+ * @returns 32 byte Buffer with "chainWork" value
+ */
+export function convertBitsToWork(bits: number | number[]): string {
+  const target = convertBitsToTarget(bits)
+
+  // convert target to work
+  const work = target.notn(256).div(target.addn(1)).addn(1)
+
+  return work.toString(16).padStart(64, '0')
+}
+
+export function deserializeBaseBlockHeaders(
+  buffer: number[],
+  offset = 0,
+  count?: number | undefined
+): BaseBlockHeader[] {
+  const headers: BaseBlockHeader[] = []
+  while ((!count || headers.length < count) && offset + 80 <= buffer.length && offset >= 0) {
+    headers.push(deserializeBlockHeader(buffer, offset))
+    offset += 80
+  }
+  return headers
+}
+
+export function deserializeBlockHeaders(
+  firstHeight: number,
+  buffer: number[],
+  offset = 0,
+  count?: number | undefined
+): BlockHeader[] {
+  const headers: BlockHeader[] = []
+  let nextHeight = firstHeight
+  while ((!count || headers.length < count) && offset + 80 <= buffer.length && offset >= 0) {
+    const baseBuffer = buffer.slice(offset, offset + 80)
+    const base = deserializeBlockHeader(baseBuffer)
+    const header = {
+      ...base,
+      height: nextHeight++,
+      hash: asString(blockHash(baseBuffer))
+    }
+    headers.push(header)
+    offset += 80
+  }
+  return headers
+}
+
+/**
+ * Extract an array of block hashes and of merkleRoots from a buffer of serialized block headers.
+ * @param buffer
+ */
+export function extractHashesAndRoots(buffer: Buffer): { hashes: Buffer[]; merkleRoots: Buffer[] } {
+  const hashes: Buffer[] = []
+  const merkleRoots: Buffer[] = []
+  for (let i = 0; i < buffer.length / 80; i++) {
+    const offset = i * 80
+    const hash = asBuffer(doubleSha256LE(asArray(buffer.subarray(offset, 80 + offset))).reverse())
+    const merkleRoot = buffer.subarray(36 + offset, 68 + offset).reverse()
+    hashes.push(hash)
+    merkleRoots.push(merkleRoot)
+  }
+  return { hashes, merkleRoots }
+}
+
+/**
+ * Given a block header, ensures that its format is correct. This does not
+ * check its difficulty or validity relative to the chain of headers.
+ *
+ * Throws on format errors.
+ *
+ * @param The header to validate
+ *
+ * @returns true if the header is correctly formatted
+ */
+export function validateHeaderFormat(header: BlockHeader): void {
+  const ALLOWED_KEYS = {
+    version: true,
+    previousHash: true,
+    merkleRoot: true,
+    time: true,
+    bits: true,
+    nonce: true,
+    height: true,
+    hash: true
+  }
+
+  const UINT_MAX = 0xffffffff
+
+  /**
+   * Root object checks
+   */
+  if (typeof header === 'undefined') {
+    throw new Error('Missing header.')
+  }
+  if (typeof header !== 'object') {
+    throw new Error('Header must be an object.')
+  }
+  if (!Object.keys(header).every(key => ALLOWED_KEYS[key])) {
+    throw new Error('Header contains extra properties.')
+  }
+
+  /**
+   * Version
+   */
+  if (typeof header.version !== 'number') {
+    throw new Error('Header version must be a number.')
+  }
+  if (!Number.isInteger(header.version)) {
+    throw new Error('Header version must be an integer.')
+  }
+  if (header.version < 0 || header.version > UINT_MAX) {
+    throw new Error(`Header version must be between 0 and ${UINT_MAX}.`)
+  }
+
+  /**
+   * Height
+   */
+  if (typeof header.height !== 'number') {
+    throw new Error('Header height must be a number.')
+  }
+  if (!Number.isInteger(header.height)) {
+    throw new Error('Header height must be an integer.')
+  }
+  if (header.height < 0 || header.height > UINT_MAX / 2) {
+    throw new Error(`Header version must be between 0 and ${UINT_MAX / 2}.`)
+  }
+
+  /**
+   * Previous hash
+   */
+  if (header.previousHash.length !== 64) {
+    throw new Error('Header previousHash must be 32 hex bytes.')
+  }
+
+  /**
+   * Merkle root
+   */
+  if (header.merkleRoot.length !== 64) {
+    throw new Error('Header merkleRoot must be 32 hex bytes.')
+  }
+
+  /**
+   * Time
+   */
+  if (typeof header.time !== 'number') {
+    throw new Error('Header time must be a number.')
+  }
+  if (!Number.isInteger(header.time)) {
+    throw new Error('Header time must be an integer.')
+  }
+  if (header.time < 0 || header.time > UINT_MAX) {
+    throw new Error(`Header time must be between 0 and ${UINT_MAX}.`)
+  }
+
+  /**
+   * Bits
+   */
+  if (typeof header.bits !== 'number') {
+    throw new Error('Header bits must be a number.')
+  }
+  if (!Number.isInteger(header.bits)) {
+    throw new Error('Header bits must be an integer.')
+  }
+  if (header.bits < 0 || header.bits > UINT_MAX) {
+    throw new Error(`Header bits must be between 0 and ${UINT_MAX}.`)
+  }
+
+  /**
+   * Nonce
+   */
+  if (typeof header.nonce !== 'number') {
+    throw new Error('Header nonce must be a number.')
+  }
+  if (!Number.isInteger(header.nonce)) {
+    throw new Error('Header nonce must be an integer.')
+  }
+  if (header.nonce < 0 || header.nonce > UINT_MAX) {
+    throw new Error(`Header nonce must be between 0 and ${UINT_MAX}.`)
+  }
+
+  /**
+   * Hash
+   */
+  if (header.hash.length !== 64) {
+    throw new Error('Header hash must be 32 hex bytes.')
+  }
+  if (header.hash !== asString(blockHash(header))) {
+    throw new Error('Header hash is invalid.')
+  }
+}
+
+/**
+ * Ensures that a header has a valid proof-of-work
+ * Requires chain is 'main'
+ *
+ * @param header The header to validate
+ *
+ * @returns true if the header is valid
+ */
+export function validateHeaderDifficulty(hash: Buffer, bits: number) {
+  const hashBN = new BigNumber(asArray(hash))
+
+  const target = convertBitsToTarget(bits)
+
+  if (hashBN.lte(target)) return true
+
+  throw new Error('Block hash is not less than specified target.')
+}
+
+/**
+ * Computes double sha256 hash of bitcoin block header
+ * bytes are reversed to bigendian order
+ *
+ * If header is a Buffer, it is required to 80 bytes long
+ * and in standard block header serialized encoding.
+ *
+ * @returns doule sha256 hash of header bytes reversed
+ * @publicbody
+ */
+export function blockHash(header: BaseBlockHeader | number[]): string {
+  const a = !Array.isArray(header) ? serializeBlockHeader(header) : header
+  if (a.length !== 80) throw new Error('Block header must be 80 bytes long.')
+  return asString(doubleSha256BE(a))
+}
+
+/**
+ * Serializes a block header as an 80 byte Buffer.
+ * The exact serialized format is defined in the Bitcoin White Paper
+ * such that computing a double sha256 hash of the buffer computes
+ * the block hash for the header.
+ * @returns 80 byte Buffer
+ * @publicbody
+ */
+export function serializeBlockHeader(header: BaseBlockHeader, buffer?: number[], offset?: number): number[] {
+  const writer = new Utils.Writer()
+  writer.writeUInt32LE(header.version)
+  writer.write(asArray(header.previousHash).reverse())
+  writer.write(asArray(header.merkleRoot).reverse())
+  writer.writeUInt32LE(header.time)
+  writer.writeUInt32LE(header.bits)
+  writer.writeUInt32LE(header.nonce)
+  const data = writer.toArray()
+  if (buffer) {
+    offset ||= 0
+    buffer.splice(offset, buffer.length, ...data)
+  }
+  return data
+}
+
+/**
+ * Deserialize a block header from an 80 byte buffer
+ * @publicbody
+ */
+export function deserializeBlockHeader(buffer: number[], offset = 0): BaseBlockHeader {
+  const reader = new Utils.Reader(buffer, offset)
+  const header: BaseBlockHeader = {
+    version: reader.readUInt32LE(),
+    previousHash: asString(reader.read(32).reverse()),
+    merkleRoot: asString(reader.read(32).reverse()),
+    time: reader.readUInt32LE(),
+    bits: reader.readUInt32LE(),
+    nonce: reader.readUInt32LE()
+  }
+  return header
+}
+
+/**
+ * Returns the genesis block for the specified chain.
+ * @publicbody
+ */
+export function genesisHeader(chain: Chain): BlockHeader {
+  return chain === 'main'
+    ? {
+        version: 1,
+        previousHash: '0000000000000000000000000000000000000000000000000000000000000000',
+        merkleRoot: '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
+        time: 1231006505,
+        bits: 486604799,
+        nonce: 2083236893,
+        height: 0,
+        hash: '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f'
+      }
+    : {
+        version: 1,
+        previousHash: '0000000000000000000000000000000000000000000000000000000000000000',
+        merkleRoot: '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
+        time: 1296688602,
+        bits: 486604799,
+        nonce: 414098458,
+        height: 0,
+        hash: '000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943'
+      }
+}
+
+/**
+ * Returns the genesis block for the specified chain.
+ * @publicbody
+ */
+export function genesisBuffer(chain: Chain): number[] {
+  return serializeBlockHeader(genesisHeader(chain))
+}
+
+/**
+ * Returns a copy of a Buffer with byte order reversed.
+ * @returns new buffer with byte order reversed.
+ * @publicbody
+ */
+export function swapByteOrder(buffer: number[]): number[] {
+  return buffer.slice().reverse()
+}
+
+/**
+ * @param num a number value in the Uint32 value range
+ * @param littleEndian true for little-endian byte order in Buffer
+ * @returns four byte buffer with Uint32 number encoded
+ * @publicbody
+ */
+export function convertUint32ToBuffer(n: number, littleEndian = true): number[] {
+  const a = [
+    n & 0xff, // lowest byte
+    (n >> 8) & 0xff,
+    (n >> 16) & 0xff,
+    (n >> 24) & 0xff // highest byte
+  ]
+  return littleEndian ? a : a.reverse()
+}
+
+export function writeUInt32LE(n: number, a: number[], offset: number): number {
+  a[offset++] = n & 0xff // lowest byte
+  a[offset++] = (n >> 8) & 0xff
+  a[offset++] = (n >> 16) & 0xff
+  a[offset++] = (n >> 24) & 0xff // highest byte
+  return offset
+}
+
+export function writeUInt32BE(n: number, a: number[], offset: number): number {
+  a[offset++] = (n >> 24) & 0xff // highest byte
+  a[offset++] = (n >> 16) & 0xff
+  a[offset++] = (n >> 8) & 0xff
+  a[offset++] = n & 0xff // lowest byte
+  return offset
+}
+
+export function readUInt32LE(a: number[], offset: number): number {
+  return a[offset++] | (a[offset++] << 8) | (a[offset++] << 16) | (a[offset++] << 24)
+}
+
+export function readUInt32BE(a: number[], offset: number): number {
+  return (a[offset++] << 24) | (a[offset++] << 16) | (a[offset++] << 8) | a[offset++]
+}
+
+/**
+ * @param buffer four byte buffer with Uint32 number encoded
+ * @param littleEndian true for little-endian byte order in Buffer
+ * @returns a number value in the Uint32 value range
+ * @publicbody
+ */
+export function convertBufferToUint32(buffer: number[], littleEndian = true): number {
+  const a = littleEndian ? buffer : buffer.slice().reverse()
+  const n = a[0] | (a[1] << 8) | (a[2] << 16) | (a[3] << 24)
+  return n
+}

package/src/services/chaintracker/chaintracks/util/dirtyHashes.ts

@@ -0,0 +1,29 @@
+/**
+ * These hashes are for blocks that are to known to have violated the Bitcoin
+ * protocol. Regardless of the amount of proof-of-work that chains built on top
+ * of them may have accumulated, they cannot be considered valid Bitcoin blocks.
+ *
+ * In the first instance, segregating witness data from transactions is not
+ * part of the design of Bitcoin.
+ *
+ * In the second instance, adding new opcodes to be used when evaluating
+ * scripts is also not allowed.
+ */
+export const dirtyHashes = {
+  // Block 478,558 with hash of 0000000000000000011865af4122fe3b144e2cbeea86142e8ff2fb4107352d43 was the last block shared by BSV, BCH and BTC
+  // Block 478,559 with hash of 00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148 was the first block of the BTC Segwit chain.
+  // Block 478,559 with hash of 000000000000000000651ef99cb9fcbe0dadde1d424bd9f15ff20136191a5eec was the valid Bitcoin block shared by BSV and BCH.
+  '00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148':
+    'This is the first header of the invalid SegWit chain.',
+  '0000000000000000004626ff6e3b936941d341c5932ece4357eeccac44e6d56c':
+    'This is the first header of the invalid ABC chain.'
+}
+
+/**
+ * Throws Error if blockHash is in the dirtyHashes list.
+ */
+export function validateAgainstDirtyHashes(blockHash: string): void {
+  if (dirtyHashes[blockHash]) {
+    throw new Error(`Not adding a header with a dirty hash: ${dirtyHashes[blockHash]}`)
+  }
+}

package/src/services/createDefaultWalletServicesOptions.ts

@@ -2,10 +2,15 @@ import { randomBytesHex, sdk } from '../index.client'
 import { ChaintracksServiceClient } from './chaintracker'
 
 export function createDefaultWalletServicesOptions(chain: sdk.Chain): sdk.WalletServicesOptions {
+  const deploymentId = `wallet-toolbox-${randomBytesHex(16)}`
   const taalApiKey =
     chain === 'main'
       ? 'mainnet_9596de07e92300c6287e4393594ae39c' // no plan
       : 'testnet_0e6cf72133b43ea2d7861da2a38684e3' // personal "starter" key
+  const gorillaPoolApiKey =
+    chain === 'main'
+      ? ''
+      : ''
 
   const o: sdk.WalletServicesOptions = {
     chain,
@@ -36,7 +41,12 @@ export function createDefaultWalletServicesOptions(chain: sdk.Chain): sdk.Wallet
     arcUrl: arcDefaultUrl(chain),
     arcConfig: {
       apiKey: taalApiKey,
-      deploymentId: `wallet-toolbox-${randomBytesHex(16)}`
+      deploymentId
+    },
+    arcGorillaPoolUrl: arcGorillaPoolUrl(chain),
+    arcGorillaPoolConfig: {
+      apiKey: gorillaPoolApiKey,
+      deploymentId
     }
   }
   return o
@@ -46,3 +56,8 @@ export function arcDefaultUrl(chain: sdk.Chain): string {
   const url = chain === 'main' ? 'https://arc.taal.com' : 'https://arc-test.taal.com'
   return url
 }
+
+export function arcGorillaPoolUrl(chain: sdk.Chain): string | undefined {
+  const url = chain === 'main' ? 'https://arc.gorillapool.io' : undefined
+  return url
+}

package/src/services/providers/ARC.ts

@@ -36,6 +36,7 @@ function defaultDeploymentId(): string {
  * Represents an ARC transaction broadcaster.
  */
 export class ARC {
+  readonly name: string
   readonly URL: string
   readonly apiKey: string | undefined
   readonly deploymentId: string
@@ -50,16 +51,17 @@ export class ARC {
    * @param {string} URL - The URL endpoint for the ARC API.
    * @param {ArcConfig} config - Configuration options for the ARC broadcaster.
    */
-  constructor(URL: string, config?: ArcConfig)
+  constructor(URL: string, config?: ArcConfig, name?: string)
   /**
    * Constructs an instance of the ARC broadcaster.
    *
    * @param {string} URL - The URL endpoint for the ARC API.
    * @param {string} apiKey - The API key used for authorization with the ARC API.
    */
-  constructor(URL: string, apiKey?: string)
+  constructor(URL: string, apiKey?: string, name?: string)
 
-  constructor(URL: string, config?: string | ArcConfig) {
+  constructor(URL: string, config?: string | ArcConfig, name?: string) {
+    this.name = name ?? 'ARC'
     this.URL = URL
     if (typeof config === 'string') {
       this.apiKey = config
@@ -143,7 +145,7 @@ export class ARC {
     }
 
     const url = `${this.URL}/v1/tx`
-    const nn = () => ({ name: 'ARCv1tx', when: new Date().toISOString() })
+    const nn = () => ({ name: this.name, when: new Date().toISOString() })
     const nne = () => ({ ...nn(), rawTx, txids: txids.join(','), url })
 
     try {
@@ -241,13 +243,13 @@ export class ARC {
    */
   async postBeef(beef: Beef, txids: string[]): Promise<sdk.PostBeefResult> {
     const r: sdk.PostBeefResult = {
-      name: 'ARC',
+      name: this.name,
       status: 'success',
       txidResults: [],
       notes: []
     }
 
-    const nn = () => ({ name: 'ARCpostBeef', when: new Date().toISOString() })
+    const nn = () => ({ name: this.name, when: new Date().toISOString() })
 
     if (beef.version === BEEF_V2 && beef.txs.every(btx => !btx.isTxidOnly)) {
       beef.version = BEEF_V1

package/src/signer/methods/internalizeAction.ts

@@ -39,7 +39,7 @@ export async function internalizeAction(
   wallet: Wallet,
   auth: sdk.AuthId,
   args: InternalizeActionArgs
-): Promise<InternalizeActionResult> {
+): Promise<sdk.StorageInternalizeActionResult> {
   const vargs = sdk.validateInternalizeActionArgs(args)
 
   const { ab, tx, txid } = await validateAtomicBeef()
@@ -60,7 +60,7 @@ export async function internalizeAction(
     }
   }
 
-  const r: InternalizeActionResult = await wallet.storage.internalizeAction(args)
+  const r: sdk.StorageInternalizeActionResult = await wallet.storage.internalizeAction(args)
 
   return r
 
@@ -89,25 +89,15 @@ export async function internalizeAction(
     // TODO: Add support for known txids...
 
     const txValid = await ab.verify(await wallet.getServices().getChainTracker(), false)
-    if (!txValid || !ab.atomicTxid) throw new sdk.WERR_INVALID_PARAMETER('tx', 'valid AtomicBEEF')
+    if (!txValid || !ab.atomicTxid) {
+      console.log(`internalizeAction beef is invalid: ${ab.toLogString()}`)
+      throw new sdk.WERR_INVALID_PARAMETER('tx', 'valid AtomicBEEF')
+    }
     const txid = ab.atomicTxid
     const btx = ab.findTxid(txid)
     if (!btx) throw new sdk.WERR_INVALID_PARAMETER('tx', `valid AtomicBEEF with newest txid of ${txid}`)
     const tx = btx.tx!
 
-    /*
-    for (const i of tx.inputs) {
-      if (!i.sourceTXID)
-        throw new sdk.WERR_INTERNAL('beef Transactions must have sourceTXIDs')
-      if (!i.sourceTransaction) {
-        const btx = ab.findTxid(i.sourceTXID)
-        if (!btx)
-          throw new sdk.WERR_INVALID_PARAMETER('tx', `valid AtomicBEEF and contain input transaction with txid ${i.sourceTXID}`);
-        i.sourceTransaction = btx.tx
-      }
-    }
-    */
-
     return { ab, tx, txid }
   }
 }

package/src/storage/StorageKnex.ts

@@ -488,6 +488,27 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     let q = this.toDb(args.trx)<T>(table)
     if (args.partial && Object.keys(args.partial).length > 0) q.where(args.partial)
     if (args.since) q.where('updated_at', '>=', this.validateDateForWhere(args.since))
+    if (args.orderDescending) {
+      let sortColumn = ''
+      switch (table) {
+        case 'certificates': sortColumn = 'certificateId'; break
+        case 'commissions': sortColumn = 'commissionId'; break
+        case 'output_baskets': sortColumn = 'basketId'; break
+        case 'outputs': sortColumn = 'outputId'; break
+        case 'output_tags': sortColumn = 'outputTagId'; break
+        case 'proven_tx_reqs': sortColumn = 'provenTxReqId'; break
+        case 'proven_txs': sortColumn = 'provenTxId'; break
+        case 'sync_states': sortColumn = 'syncStateId'; break
+        case 'transactions': sortColumn = 'transactionId'; break
+        case 'tx_labels': sortColumn = 'txLabelId'; break
+        case 'users': sortColumn = 'userId'; break
+        case 'monitor_events': sortColumn = 'id'; break
+        default: break;
+      }
+      if (sortColumn !== '') {
+        q.orderBy(sortColumn, 'desc')
+      }
+    }
     if (args.paged) {
       q.limit(args.paged.limit)
       q.offset(args.paged.offset || 0)
@@ -554,7 +575,10 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
       )
     const q = this.setupQuery('proven_tx_reqs', args)
     if (args.status && args.status.length > 0) q.whereIn('status', args.status)
-    if (args.txids && args.txids.length > 0) q.whereIn('txid', args.txids)
+    if (args.txids) {
+      const txids = args.txids.filter(txid => txid !== undefined)
+      if (txids.length > 0) q.whereIn('txid', txids)
+    }
     return q
   }
   findProvenTxsQuery(args: sdk.FindProvenTxsArgs): Knex.QueryBuilder {