@bsv/wallet-toolbox 1.3.24 → 1.3.26

package/src/services/Services.ts

@@ -8,6 +8,7 @@ import { updateChaintracksFiatExchangeRates, updateExchangeratesapi } from './pr
 import { ARC } from './providers/ARC'
 import { Bitails } from './providers/Bitails'
 import { getBeefForTxid } from './providers/getBeefForTxid'
+import { ServicesCallHistory } from '../sdk/WalletServices.interfaces'
 
 export class Services implements sdk.WalletServices {
   static createDefaultOptions(chain: sdk.Chain): sdk.WalletServicesOptions {
@@ -16,7 +17,8 @@ export class Services implements sdk.WalletServices {
 
   options: sdk.WalletServicesOptions
   whatsonchain: WhatsOnChain
-  arc: ARC
+  arcTaal: ARC
+  arcGorillaPool?: ARC
   bitails: Bitails
 
   getMerklePathServices: ServiceCollection<sdk.GetMerklePathService>
@@ -36,43 +38,65 @@ export class Services implements sdk.WalletServices {
 
     this.whatsonchain = new WhatsOnChain(this.chain, { apiKey: this.options.whatsOnChainApiKey }, this)
 
-    this.arc = new ARC(this.options.arcUrl, this.options.arcConfig)
+    this.arcTaal = new ARC(this.options.arcUrl, this.options.arcConfig, 'arcTaal')
+    if (this.options.arcGorillaPoolUrl) {
+      //this.arcGorillaPool = new ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, 'arcGorillaPool')
+    }
 
     this.bitails = new Bitails(this.chain)
 
     //prettier-ignore
-    this.getMerklePathServices = new ServiceCollection<sdk.GetMerklePathService>()
+    this.getMerklePathServices = new ServiceCollection<sdk.GetMerklePathService>('getMerklePath')
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getMerklePath.bind(this.whatsonchain) })
       .add({ name: 'Bitails', service: this.bitails.getMerklePath.bind(this.bitails) })
 
     //prettier-ignore
-    this.getRawTxServices = new ServiceCollection<sdk.GetRawTxService>()
+    this.getRawTxServices = new ServiceCollection<sdk.GetRawTxService>('getRawTx')
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain) })
 
+    this.postBeefServices = new ServiceCollection<sdk.PostBeefService>('postBeef')
+    if (this.arcGorillaPool) {
+      //prettier-ignore
+      this.postBeefServices.add({ name: 'GorillaPool', service: this.arcGorillaPool.postBeef.bind(this.arcGorillaPool) })
+    }
     //prettier-ignore
-    this.postBeefServices = new ServiceCollection<sdk.PostBeefService>()
-      .add({ name: 'TaalArcBeef', service: this.arc.postBeef.bind(this.arc) })
+    this.postBeefServices
+      .add({ name: 'TaalArcBeef', service: this.arcTaal.postBeef.bind(this.arcTaal) })
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.postBeef.bind(this.whatsonchain) })
       .add({ name: 'Bitails', service: this.bitails.postBeef.bind(this.bitails) })
+      ;
 
     //prettier-ignore
-    this.getUtxoStatusServices = new ServiceCollection<sdk.GetUtxoStatusService>()
+    this.getUtxoStatusServices = new ServiceCollection<sdk.GetUtxoStatusService>('getUtxoStatus')
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getUtxoStatus.bind(this.whatsonchain) })
 
     //prettier-ignore
-    this.getStatusForTxidsServices = new ServiceCollection<sdk.GetStatusForTxidsService>()
+    this.getStatusForTxidsServices = new ServiceCollection<sdk.GetStatusForTxidsService>('getStatusForTxids')
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getStatusForTxids.bind(this.whatsonchain) })
 
     //prettier-ignore
-    this.getScriptHashHistoryServices = new ServiceCollection<sdk.GetScriptHashHistoryService>()
+    this.getScriptHashHistoryServices = new ServiceCollection<sdk.GetScriptHashHistoryService>('getScriptHashHistory')
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getScriptHashHistory.bind(this.whatsonchain) })
 
     //prettier-ignore
-    this.updateFiatExchangeRateServices = new ServiceCollection<sdk.UpdateFiatExchangeRateService>()
+    this.updateFiatExchangeRateServices = new ServiceCollection<sdk.UpdateFiatExchangeRateService>('updateFiatExchangeRate')
       .add({ name: 'ChaintracksService', service: updateChaintracksFiatExchangeRates })
       .add({ name: 'exchangeratesapi', service: updateExchangeratesapi })
   }
 
+  getServicesCallHistory(reset?: boolean) : ServicesCallHistory {
+    return {
+      version: 2,
+      getMerklePath: this.getMerklePathServices.getServiceCallHistory(reset),
+      getRawTx: this.getRawTxServices.getServiceCallHistory(reset),
+      postBeef: this.postBeefServices.getServiceCallHistory(reset),
+      getUtxoStatus: this.getUtxoStatusServices.getServiceCallHistory(reset),
+      getStatusForTxids: this.getStatusForTxidsServices.getServiceCallHistory(reset),
+      getScriptHashHistory: this.getScriptHashHistoryServices.getServiceCallHistory(reset),
+      updateFiatExchangeRates: this.updateFiatExchangeRateServices.getServiceCallHistory(reset)
+    }
+  }
+
   async getChainTracker(): Promise<ChainTracker> {
     if (!this.options.chaintracks)
       throw new sdk.WERR_INVALID_PARAMETER('options.chaintracks', `valid to enable 'getChainTracker' service.`)
@@ -123,11 +147,22 @@ export class Services implements sdk.WalletServices {
     }
 
     for (let tries = 0; tries < services.count; tries++) {
-      const service = services.service
-      const r = await service(txids)
-      if (r.status === 'success') {
-        r0 = r
-        break
+      const stc = services.serviceToCall
+      try {
+        const r = await stc.service(txids)
+        if (r.status === 'success') {
+          services.addServiceCallSuccess(stc)
+          r0 = r
+          break
+        } else {
+          if (r.error)
+            services.addServiceCallError(stc, r.error)
+          else
+            services.addServiceCallFailure(stc)
+        }
+      } catch (eu: unknown) {
+        const e = sdk.WalletError.fromUnknown(eu)
+        services.addServiceCallError(stc, e)
       }
       services.next()
     }
@@ -174,11 +209,22 @@ export class Services implements sdk.WalletServices {
 
     for (let retry = 0; retry < 2; retry++) {
       for (let tries = 0; tries < services.count; tries++) {
-        const service = services.service
-        const r = await service(output, outputFormat, outpoint)
-        if (r.status === 'success') {
-          r0 = r
-          break
+        const stc = services.serviceToCall
+        try {
+          const r = await stc.service(output, outputFormat, outpoint)
+          if (r.status === 'success') {
+            services.addServiceCallSuccess(stc)
+            r0 = r
+            break
+          } else {
+            if (r.error)
+              services.addServiceCallError(stc, r.error)
+            else
+              services.addServiceCallFailure(stc)
+          }
+        } catch (eu: unknown) {
+          const e = sdk.WalletError.fromUnknown(eu)
+          services.addServiceCallError(stc, e)
         }
         services.next()
       }
@@ -200,19 +246,27 @@ export class Services implements sdk.WalletServices {
     }
 
     for (let tries = 0; tries < services.count; tries++) {
-      const service = services.service
-      const r = await service(hash)
-      if (r.status === 'success') {
-        r0 = r
-        break
+      const stc = services.serviceToCall
+      try {
+        const r = await stc.service(hash)
+        if (r.status === 'success') {
+          r0 = r
+          break
+        } else {
+          if (r.error)
+            services.addServiceCallError(stc, r.error)
+          else
+            services.addServiceCallFailure(stc)
+        }
+      } catch (eu: unknown) {
+        const e = sdk.WalletError.fromUnknown(eu)
+        services.addServiceCallError(stc, e)
       }
       services.next()
     }
     return r0
   }
 
-  postBeefCount = 0
-
   /**
    *
    * @param beef
@@ -220,15 +274,20 @@ export class Services implements sdk.WalletServices {
    * @returns
    */
   async postBeef(beef: Beef, txids: string[]): Promise<sdk.PostBeefResult[]> {
-    this.postBeefCount++
-    const services = [...this.postBeefServices.allServices]
-    for (let i = this.postBeefCount % services.length; i > 0; i--) {
-      // roll the array of services so the providers aren't always called in the same order.
-      services.unshift(services.pop()!)
-    }
+    const services = this.postBeefServices
+    const stcs = services.allServicesToCall
     let rs = await Promise.all(
-      services.map(async service => {
-        const r = await service(beef, txids)
+      stcs.map(async stc => {
+        const r = await stc.service(beef, txids)
+        if (r.status === 'success') {
+          services.addServiceCallSuccess(stc)
+        } else {
+          if (r.error) {
+            services.addServiceCallError(stc, r.error)
+          } else {
+            services.addServiceCallFailure(stc)
+          }
+        }
         return r
       })
     )
@@ -236,31 +295,46 @@ export class Services implements sdk.WalletServices {
   }
 
   async getRawTx(txid: string, useNext?: boolean): Promise<sdk.GetRawTxResult> {
-    if (useNext) this.getRawTxServices.next()
+    const services = this.getRawTxServices
+    if (useNext) services.next()
 
     const r0: sdk.GetRawTxResult = { txid }
 
-    for (let tries = 0; tries < this.getRawTxServices.count; tries++) {
-      const service = this.getRawTxServices.service
-      const r = await service(txid, this.chain)
-      if (r.rawTx) {
-        const hash = asString(doubleSha256BE(r.rawTx!))
-        // Confirm transaction hash matches txid
-        if (hash === asString(txid)) {
-          // If we have a match, call it done.
-          r0.rawTx = r.rawTx
-          r0.name = r.name
-          r0.error = undefined
-          break
+    for (let tries = 0; tries < services.count; tries++) {
+      const stc = services.serviceToCall
+      try {
+        const r = await stc.service(txid, this.chain)
+        if (r.rawTx) {
+          const hash = asString(doubleSha256BE(r.rawTx!))
+          // Confirm transaction hash matches txid
+          if (hash === asString(txid)) {
+            // If we have a match, call it done.
+            r0.rawTx = r.rawTx
+            r0.name = r.name
+            r0.error = undefined
+            services.addServiceCallSuccess(stc)
+            break
+          }
+          r.error = new sdk.WERR_INTERNAL(`computed txid ${hash} doesn't match requested value ${txid}`)
+          r.rawTx = undefined
         }
-        r.error = new sdk.WERR_INTERNAL(`computed txid ${hash} doesn't match requested value ${txid}`)
-        r.rawTx = undefined
-      }
-      if (r.error && !r0.error && !r0.rawTx)
-        // If we have an error and didn't before...
-        r0.error = r.error
 
-      this.getRawTxServices.next()
+        if (r.error)
+          services.addServiceCallError(stc, r.error)
+        else if (!r.rawTx)
+          services.addServiceCallSuccess(stc, `not found`)
+        else
+          services.addServiceCallFailure(stc)
+
+        if (r.error && !r0.error && !r0.rawTx)
+          // If we have an error and didn't before...
+          r0.error = r.error
+
+      } catch (eu: unknown) {
+        const e = sdk.WalletError.fromUnknown(eu)
+        services.addServiceCallError(stc, e)
+      }
+      services.next()
     }
     return r0
   }
@@ -307,28 +381,41 @@ export class Services implements sdk.WalletServices {
   }
 
   async getMerklePath(txid: string, useNext?: boolean): Promise<sdk.GetMerklePathResult> {
-    if (useNext) this.getMerklePathServices.next()
+    const services = this.getMerklePathServices
+    if (useNext) services.next()
 
     const r0: sdk.GetMerklePathResult = { notes: [] }
 
-    for (let tries = 0; tries < this.getMerklePathServices.count; tries++) {
-      const service = this.getMerklePathServices.service
-      const r = await service(txid, this)
-      if (r.notes) r0.notes!.push(...r.notes)
-      if (!r0.name) r0.name = r.name
-      if (r.merklePath) {
-        // If we have a proof, call it done.
-        r0.merklePath = r.merklePath
-        r0.header = r.header
-        r0.name = r.name
-        r0.error = undefined
-        break
-      } else if (r.error && !r0.error) {
-        // If we have an error and didn't before...
-        r0.error = r.error
+    for (let tries = 0; tries < services.count; tries++) {
+      const stc = services.serviceToCall
+      try {
+        const r = await stc.service(txid, this)
+        if (r.notes) r0.notes!.push(...r.notes)
+        if (!r0.name) r0.name = r.name
+        if (r.merklePath) {
+          // If we have a proof, call it done.
+          r0.merklePath = r.merklePath
+          r0.header = r.header
+          r0.name = r.name
+          r0.error = undefined
+          services.addServiceCallSuccess(stc)
+          break
+        }
+        
+        if (r.error)
+          services.addServiceCallError(stc, r.error)
+        else
+          services.addServiceCallFailure(stc)
+
+        if (r.error && !r0.error) {
+          // If we have an error and didn't before...
+          r0.error = r.error
+        }
+      } catch (eu: unknown) {
+        const e = sdk.WalletError.fromUnknown(eu)
+        services.addServiceCallError(stc, e)
       }
-
-      this.getMerklePathServices.next()
+      services.next()
     }
     return r0
   }
@@ -350,16 +437,19 @@ export class Services implements sdk.WalletServices {
     let r0: sdk.FiatExchangeRates | undefined
 
     for (let tries = 0; tries < services.count; tries++) {
-      const service = services.service
+      const stc = services.serviceToCall
       try {
-        const r = await service(this.targetCurrencies, this.options)
+        const r = await stc.service(this.targetCurrencies, this.options)
         if (this.targetCurrencies.every(c => typeof r.rates[c] === 'number')) {
+          services.addServiceCallSuccess(stc)
           r0 = r
           break
+        } else {
+          services.addServiceCallFailure(stc)
         }
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
-        console.error(`updateFiatExchangeRates servcice name ${service.name} error ${e.message}`)
+        services.addServiceCallError(stc, e)
       }
       services.next()
     }

package/src/services/__tests/ArcGorillaPool.man.test.ts

@@ -0,0 +1,108 @@
+import { _tu, logger } from '../../../test/utils/TestUtilsWalletStorage'
+import { sdk, wait } from '../../index.client'
+import { ARC } from '../providers/ARC'
+import { Beef, BeefTx } from '@bsv/sdk'
+import { arcDefaultUrl, arcGorillaPoolUrl } from '../createDefaultWalletServicesOptions'
+import { Setup } from '../../index.all'
+
+describe('ArcGorillaPool tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('main')
+  const arc = new ARC(arcGorillaPoolUrl(env.chain)!, {
+    apiKey: ''
+  })
+
+  test.skip('0 double spend', async () => {
+    const beef = Beef.fromString(testnetDoubleSpendBeef)
+    const txids = [beef.txs.slice(-1)[0].txid]
+    const r = await arc.postBeef(beef, txids)
+    expect(r.status === 'error').toBe(true)
+    expect(r.txidResults[0].doubleSpend).toBe(true)
+  })
+
+  test.skip('1 postRawTx', async () => {
+    const r = await postRawTxTest('main', arc)
+    logger(`2 postBeef mainnet done ${r}`)
+  })
+
+  test('2 postBeef', async () => {
+    const r = await postBeefTest('main', arc)
+    logger(`2 postBeef mainnet done ${r}`)
+  })
+})
+
+async function postBeefTest(chain: sdk.Chain, arc: ARC): Promise<string> {
+  if (Setup.noEnv(chain)) return 'skipped'
+  const c = await _tu.createNoSendTxPair(chain)
+
+  const txids = [c.txidDo, c.txidUndo]
+
+  const r = await arc.postBeef(c.beef, txids)
+  expect(r.status).toBe('success')
+  for (const txid of txids) {
+    const tr = r.txidResults.find(tx => tx.txid === txid)
+    expect(tr).not.toBeUndefined()
+    expect(tr!.status).toBe('success')
+  }
+
+  // replace Undo transaction with double spend transaction and send again.
+  const beef2 = c.beef.clone()
+  beef2.txs[beef2.txs.length - 1] = BeefTx.fromTx(c.doubleSpendTx)
+  const txids2 = [c.txidDo, c.doubleSpendTx.id('hex')]
+
+  const r2 = await arc.postBeef(beef2, txids2)
+  expect(r2.status).toBe('error')
+  for (const txid of txids2) {
+    const tr = r2.txidResults.find(tx => tx.txid === txid)
+    expect(tr).not.toBeUndefined()
+    if (txid === c.txidDo) {
+      expect(tr!.status).toBe('success')
+    } else {
+      expect(tr!.status).toBe('error')
+      expect(tr!.doubleSpend).toBe(true)
+      expect(tr!.competingTxs).toEqual([c.txidUndo])
+    }
+  }
+  return 'passed'
+}
+
+async function postRawTxTest(chain: sdk.Chain, arc: ARC): Promise<void> {
+  if (Setup.noEnv(chain)) return
+  const c = await _tu.createNoSendTxPair(chain)
+
+  const rawTxDo = c.beef.findTxid(c.txidDo)!.tx!.toHex()
+  const rawTxUndo = c.beef.findTxid(c.txidUndo)!.tx!.toHex()
+
+  const rDo = await arc.postRawTx(rawTxDo)
+  expect(rDo.status).toBe('success')
+  expect(rDo.txid).toBe(c.txidDo)
+
+  await wait(1000)
+
+  const rUndo = await arc.postRawTx(rawTxUndo)
+  expect(rUndo.status).toBe('success')
+  expect(rUndo.txid).toBe(c.txidUndo)
+  expect(rUndo.doubleSpend).not.toBe(true)
+
+  await wait(1000)
+
+  {
+    // Send same transaction again...
+    const rUndo = await arc.postRawTx(rawTxUndo)
+    expect(rUndo.status).toBe('success')
+    expect(rUndo.txid).toBe(c.txidUndo)
+    expect(rUndo.doubleSpend).not.toBe(true)
+  }
+
+  await wait(1000)
+
+  // Confirm double spend detection.
+  const rDouble = await arc.postRawTx(c.doubleSpendTx.toHex())
+  expect(rDouble.status).toBe('error')
+  expect(rDouble.doubleSpend).toBe(true)
+  expect(rDouble.competingTxs![0]).toBe(c.txidUndo)
+}
+
+const testnetDoubleSpendBeef =
+  '0100beef01fe65631900020200009df812619ae232d2363d91516ab3e811211192933526bbc2aee71b54ccb236d10102462876eec65d9aa26d957421c5cc8dd9119b61177242b9dd814fb190fd0a361801010076a3297928f6841bcb656e91225540e87c65f67d8ec12bc768d7656eb7561b3d02010000000159617a9d17562f7c9765e5dfa6a9a393aa2809ca6166a3d7a31c09efcc5070141f0000006a47304402200a528145a67ba1879b88a093cb711f79f04413a81d5678f314302e36a7f59e43022010bc4bb3c2574052c50bbdc8a05c31fb39e69280656b34f5dc22e2ceadc3bb4a412102fd4200bf389d16479b3d06f97fee0752f2c3b9dc29fb3ddce2b327d851b8902bffffffff0204000000000000001976a9140df1a69c834bb7d9bb5b2b7d6a34e5a401db3e1688ac01000000000000001976a91423f2562a8092ed24eddc77c74387b44c561692a188ac0000000001000100000001462876eec65d9aa26d957421c5cc8dd9119b61177242b9dd814fb190fd0a3618000000006a47304402204183bbfdcf11d50907b91f5e70ea8f81228501ce84e24af75c8d984682d094dc022029caa8f7e5acb4990bbeafee523a3c4a99b78e98b9e5c41349147b099679d4ae412103b76389eea6494c2c30443cba9d59b9dba05fb04e467bc94272629615b87a429fffffffff0202000000000000001976a91476d851e59fcb4ee0ebe6947496db3a393b08e49c88ac01000000000000001976a91423f2562a8092ed24eddc77c74387b44c561692a188ac0000000000'

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

@@ -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

@@ -23,12 +23,13 @@ import {
 } from './schema/tables'
 import { KnexMigrations } from './schema/KnexMigrations'
 import { Knex } from 'knex'
-import { StorageAdminStats, StorageProvider, StorageProviderOptions } from './StorageProvider'
+import { AdminStatsResult, StorageProvider, StorageProviderOptions } from './StorageProvider'
 import { purgeData } from './methods/purgeData'
 import { listActions } from './methods/listActionsKnex'
 import { listOutputs } from './methods/listOutputsKnex'
 import { DBType } from './StorageReader'
 import { reviewStatus } from './methods/reviewStatus'
+import { ServicesCallHistory } from '../sdk/WalletServices.interfaces'
 
 export interface StorageKnexOptions extends StorageProviderOptions {
   /**
@@ -488,6 +489,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 +576,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 {
@@ -1128,9 +1153,13 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return entities
   }
 
-  async adminStats(adminIdentityKey: string): Promise<StorageAdminStats> {
+  async adminStats(adminIdentityKey: string): Promise<AdminStatsResult> {
     if (this.dbtype !== 'MySQL') throw new sdk.WERR_NOT_IMPLEMENTED('adminStats, only MySQL is supported')
 
+    const monitorEvent = verifyOneOrNone(await this.findMonitorEvents({ partial: { event: 'ServiceCallHistory'}, orderDescending: true, paged: { limit: 1 } }))
+    const monitorStats: ServicesCallHistory | undefined = monitorEvent ? JSON.parse(monitorEvent.details!) : undefined
+    const servicesStats = this.getServices().getServicesCallHistory(true)
+
     const one_day_ago = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
     const one_week_ago = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString()
     const one_month_ago = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString()
@@ -1271,7 +1300,9 @@ select
     (select count(*) from output_tags where created_at > '${one_month_ago}') as tagsMonth,
 	  (select count(*) from output_tags) as tagsTotal
       `)
-    const r: StorageAdminStats = {
+    const r: AdminStatsResult = {
+      monitorStats,
+      servicesStats,
       requestedBy: adminIdentityKey,
       when: new Date().toISOString(),
       usersDay,