@bsv/wallet-toolbox 1.3.24 → 1.3.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.3.24",
+  "version": "1.3.25",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -32,7 +32,7 @@
   "dependencies": {
     "@bsv/auth-express-middleware": "^1.1.2",
     "@bsv/payment-express-middleware": "^1.0.6",
-    "@bsv/sdk": "^1.4.24",
+    "@bsv/sdk": "^1.5.1",
     "express": "^4.21.2",
     "idb": "^8.0.2",
     "knex": "^3.1.0",

package/src/monitor/Monitor.ts

@@ -13,6 +13,7 @@ import { TaskFailAbandoned } from './tasks/TaskFailAbandoned'
 import { TaskCheckForProofs } from './tasks/TaskCheckForProofs'
 import { TaskClock } from './tasks/TaskClock'
 import { TaskNewHeader } from './tasks/TaskNewHeader'
+import { TaskServiceCallHistory } from './tasks/TaskServiceCallHistory'
 
 import { TaskSendWaiting } from './tasks/TaskSendWaiting'
 import { TaskCheckNoSends } from './tasks/TaskCheckNoSends'
@@ -110,6 +111,7 @@ export class Monitor {
   addAllTasksToOther(): void {
     this._otherTasks.push(new TaskClock(this))
     this._otherTasks.push(new TaskNewHeader(this))
+    this._otherTasks.push(new TaskServiceCallHistory(this))
     this._otherTasks.push(new TaskPurge(this, this.defaultPurgeParams))
     this._otherTasks.push(new TaskReviewStatus(this))
     this._otherTasks.push(new TaskSendWaiting(this))
@@ -128,6 +130,7 @@ export class Monitor {
   addDefaultTasks(): void {
     this._tasks.push(new TaskClock(this))
     this._tasks.push(new TaskNewHeader(this))
+    this._tasks.push(new TaskServiceCallHistory(this))
     this._tasks.push(new TaskSendWaiting(this, 8 * this.oneSecond, 7 * this.oneSecond)) // Check every 8 seconds but must be 7 seconds old
     this._tasks.push(new TaskCheckForProofs(this, 2 * this.oneHour)) // Every two hours if no block found
     this._tasks.push(new TaskCheckNoSends(this))
@@ -144,6 +147,7 @@ export class Monitor {
   addMultiUserTasks(): void {
     this._tasks.push(new TaskClock(this))
     this._tasks.push(new TaskNewHeader(this))
+    this._tasks.push(new TaskServiceCallHistory(this))
     this._tasks.push(new TaskSendWaiting(this, 8 * this.oneSecond, 7 * this.oneSecond)) // Check every 8 seconds but must be 7 seconds old
     this._tasks.push(new TaskCheckForProofs(this, 2 * this.oneHour)) // Every two hours if no block found
     this._tasks.push(new TaskCheckNoSends(this))

package/src/monitor/tasks/TaskServiceCallHistory.ts

@@ -0,0 +1,26 @@
+import { TableMonitorEvent } from '../../storage/index.client'
+import { Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+
+export class TaskServiceCallHistory extends WalletMonitorTask {
+  static taskName = 'ServiceCallHistory'
+
+  constructor(
+    monitor: Monitor,
+    public triggerMsecs = monitor.oneMinute * 12
+  ) {
+    super(monitor, TaskServiceCallHistory.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    return {
+      run: nowMsecsSinceEpoch > this.lastRunMsecsSinceEpoch + this.triggerMsecs
+    }
+  }
+
+  async runTask(): Promise<string> {
+    const r = await this.monitor.services.getServicesCallHistory(true)
+    const log = JSON.stringify(r)
+    return log
+  }
+}

package/src/sdk/WalletServices.interfaces.ts

@@ -200,6 +200,8 @@ export interface WalletServicesOptions {
   chaintracks?: ChaintracksServiceClient
   arcUrl: string
   arcConfig: ArcConfig
+  arcGorillaPoolUrl?: string
+  arcGorillaPoolConfig?: ArcConfig
 }
 
 export interface GetStatusForTxidsResult {

package/src/sdk/WalletStorage.interfaces.ts

@@ -189,6 +189,11 @@ export interface FindSincePagedArgs {
   since?: Date
   paged?: Paged
   trx?: TrxToken
+  /**
+   * Support for orderDescending is implemented in StorageKnex for basic table find methods,
+   * excluding certificate_fields table, map tables, and settings (singleton row table).
+   */
+  orderDescending?: boolean
 }
 
 export interface FindForUserSincePagedArgs extends FindSincePagedArgs {

package/src/services/ServiceCollection.ts

@@ -1,10 +1,16 @@
+import { WalletError } from "../sdk/WalletError";
+
 export class ServiceCollection<T> {
+  since: Date
   services: { name: string; service: T }[]
   _index: number
 
+  _callHistory: Record<string, ServiceCallHistory> = {}
+
   constructor(services?: { name: string; service: T }[]) {
     this.services = services || []
     this._index = 0
+    this.since = new Date()
   }
 
   add(s: { name: string; service: T }): ServiceCollection<T> {
@@ -24,6 +30,23 @@ export class ServiceCollection<T> {
     return this.services[this._index].service
   }
 
+  get serviceToCall(): ServiceToCall<T> {
+    const i = this._index
+    const name = this.services[i].name
+    const service = this.services[i].service
+    const call = { name, when: new Date(), durationMsecs: 0, success: false, result: undefined, error: undefined }
+    return { name, service, call }
+  }
+
+  get allServicesToCall(): ServiceToCall<T>[] {
+    const all: ServiceToCall<T>[] = []
+    for (let i = 0; i < this.services.length; i++) {
+      all.push(this.serviceToCall)
+      this.next()
+    }
+    return all
+  }
+
   get allServices() {
     return this.services.map(x => x.service)
   }
@@ -47,4 +70,102 @@ export class ServiceCollection<T> {
   clone(): ServiceCollection<T> {
     return new ServiceCollection([...this.services])
   }
+
+  _addServiceCall(name: string, call: ServiceCall): ServiceCallHistory {
+    let h = this._callHistory[name]
+    if (!h) {
+      h = { name, calls: [], count: 0, countError: 0, countFailure: 0, countSuccess: 0, since: this.since }
+      this._callHistory[name] = h
+    }
+    h.calls.push(call)
+    h.count++
+    h.calls = h.calls.slice(-32)
+    return h
+  }
+
+  addServiceCallSuccess(stc: ServiceToCall<T>, result?: string): void {
+    const call = stc.call
+    call.success = true
+    call.result = result
+    call.error = undefined
+    call.durationMsecs = new Date().getTime() - call.when.getTime()
+    this._addServiceCall(this.name, call).countSuccess++
+  }
+
+  addServiceCallFailure(stc: ServiceToCall<T>, result?: string): void {
+    const call = stc.call
+    call.success = false
+    call.result = result
+    call.error = undefined
+    call.durationMsecs = new Date().getTime() - call.when.getTime()
+    this._addServiceCall(this.name, call).countFailure++
+  }
+
+  addServiceCallError(stc: ServiceToCall<T>, error: WalletError): void {
+    const call = stc.call
+    call.success = false
+    call.result = undefined
+    call.error = error
+    call.durationMsecs = new Date().getTime() - call.when.getTime()
+    this._addServiceCall(this.name, call).countError++
+  }
+
+  /**
+   * @returns A copy of current service call history
+   */
+  getServiceCallHistory(reset?: boolean): Record<string, ServiceCallHistory> {
+    const histories: Record<string, ServiceCallHistory> = {}
+    for (const name of Object.keys(this._callHistory)) {
+      const h = this._callHistory[name]
+      histories[name] = {
+        name: h.name,
+        count: h.count,
+        countError: h.countError,
+        countFailure: h.countFailure,
+        countSuccess: h.countSuccess,
+        since: h.since,
+        calls: h.calls.map(c => ({
+          name: c.name,
+          when: c.when,
+          durationMsecs: c.durationMsecs,
+          success: c.success,
+          result: c.result,
+          error: c.error ? { message: c.error.message, code: c.error.code } : undefined
+        }))
+      }
+      if (reset) {
+        h.count = 0
+        h.countError = 0
+        h.countFailure = 0
+        h.countSuccess = 0
+        h.since = new Date()
+      }
+    }
+    return histories
+  }
 }
+
+export interface ServiceCall {
+  name: string
+  when: Date
+  durationMsecs: number
+  success: boolean
+  result?: string
+  error?: { message: string, code: string }
+}
+
+export interface ServiceCallHistory {
+  name: string
+  calls: ServiceCall[]
+  count: number
+  countSuccess: number
+  countFailure: number
+  countError: number
+  since: Date
+}
+
+export interface ServiceToCall<T> {
+  name: string
+  service: T
+  call: ServiceCall
+}

package/src/services/Services.ts

@@ -1,6 +1,6 @@
 import { Transaction as BsvTransaction, Beef, ChainTracker, Utils } from '@bsv/sdk'
 import { asArray, asString, doubleSha256BE, sdk, sha256Hash, TableOutput, wait } from '../index.client'
-import { ServiceCollection } from './ServiceCollection'
+import { ServiceCall, ServiceCollection } from './ServiceCollection'
 import { createDefaultWalletServicesOptions } from './createDefaultWalletServicesOptions'
 import { ChaintracksChainTracker } from './chaintracker'
 import { WhatsOnChain } from './providers/WhatsOnChain'
@@ -16,7 +16,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,7 +37,10 @@ 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)
 
@@ -49,11 +53,17 @@ export class Services implements sdk.WalletServices {
     this.getRawTxServices = new ServiceCollection<sdk.GetRawTxService>()
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain) })
 
-    //prettier-ignore
     this.postBeefServices = new ServiceCollection<sdk.PostBeefService>()
-      .add({ name: 'TaalArcBeef', service: this.arc.postBeef.bind(this.arc) })
+    if (this.arcGorillaPool) {
+      //prettier-ignore
+      this.postBeefServices.add({ name: 'GorillaPool', service: this.arcGorillaPool.postBeef.bind(this.arcGorillaPool) })
+    }
+    //prettier-ignore
+    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>()
@@ -73,6 +83,18 @@ export class Services implements sdk.WalletServices {
       .add({ name: 'exchangeratesapi', service: updateExchangeratesapi })
   }
 
+  getServicesCallHistory(reset?: boolean) {
+    return {
+      version: 1,
+      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)
+    }
+  }
+
   async getChainTracker(): Promise<ChainTracker> {
     if (!this.options.chaintracks)
       throw new sdk.WERR_INVALID_PARAMETER('options.chaintracks', `valid to enable 'getChainTracker' service.`)
@@ -123,11 +145,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 +207,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 +244,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 +272,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 +293,44 @@ 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
+          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 +377,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 +433,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'