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

package/src/storage/methods/__test/GenerateChange/randomValsUsed1.ts

@@ -1,20 +0,0 @@
-export const randomValsUsed1 = [
-  0.3145996888882596, 0.45719282963580565, 0.8555247776688835, 0.2649974738591665, 0.7381622959747749,
-  0.1945477495382142, 0.5032123391994598, 0.02861436749749835, 0.7999598138479351, 0.8979243255586506,
-  0.9034507043487272, 0.4280218402928029, 0.6358932443326806, 0.30173236243173585, 0.3598078135029954,
-  0.9870248947111777, 0.2675337664781172, 0.6050300757408575, 0.7391162382709817, 0.8727502788995358,
-  0.36799576712472737, 0.6604956576157504, 0.1702104642469362, 0.7797698104303106, 0.08655953134554961,
-  0.2847318171161146, 0.07534328732698126, 0.9009525464087105, 0.5264602243751411, 0.866180150709631,
-  0.5813059581773354, 0.3348084822567492, 0.5668720381665056, 0.03296403051210928, 0.8225656781470101,
-  0.5321943190815006, 0.7708306957508375, 0.13417838069050525, 0.7763632653423949, 0.08160553045351926,
-  0.45497831351884677, 0.13467302343886756, 0.21261951092011078, 0.04372527326966513, 0.7939708066933404,
-  0.31542646439897015, 0.23821328607534542, 0.29505981550698746, 0.436696157907251, 0.8692456197556584,
-  0.6851392295747836, 0.4203746637055583, 0.9959411956291628, 0.42200495673071803, 0.9174433944732405,
-  0.7758897322425307, 0.3453529493770806, 0.15520421082199776, 0.4883039767344435, 0.45987000169072356,
-  0.9146194455087437, 0.33743694585941686, 0.2725130478399085, 0.7058681732538112, 0.18975119489481007,
-  0.46483529505143717, 0.5650362982181798, 0.48841275156927955, 0.8012266835493618, 0.2952784976832741,
-  0.9823977685364349, 0.45683871241931007, 0.6008021097728846, 0.1405802039681765, 0.6968599380515865,
-  0.3016840411555928, 0.8652691542976458, 0.5733994909626297, 0.288364714649364, 0.28178697025295385,
-  0.02893432926139794, 0.6179746775758665, 0.35219485471542944, 0.97651703347549, 0.04012334579632282,
-  0.3582381346512069, 0.5756199598871186, 0.11453606927098825
-]

package/src/storage/methods/__test/offsetKey.test.ts

@@ -1,274 +0,0 @@
-import {
-  Beef,
-  BigNumber,
-  CreateActionArgs,
-  CreateActionInput,
-  CreateActionOptions,
-  Curve,
-  P2PKH,
-  PositiveIntegerOrZero,
-  PrivateKey,
-  SignActionArgs,
-  SignActionSpend,
-  Utils
-} from '@bsv/sdk'
-import { keyOffsetToHashedSecret, lockScriptWithKeyOffsetFromPubKey, offsetPrivKey, offsetPubKey } from '../offsetKey'
-import { _tu, TestWalletOnly } from '../../../../test/utils/TestUtilsWalletStorage'
-import { Setup } from '../../../Setup'
-import { StorageKnex } from '../../StorageKnex'
-import { FindCommissionsArgs, FindTransactionsArgs } from '../../../sdk'
-import { verifyOne, verifyTruthy } from '../../../utility/utilityHelpers'
-import { TableCommission } from '../../schema/tables/TableCommission'
-import { WalletStorageManager } from '../../WalletStorageManager'
-
-describe('offsetKey tests', () => {
-  jest.setTimeout(99999999)
-
-  test('1_offsetPrivKey', async () => {
-    const bn2 = BigNumber.fromHex('FFF0000000000000000000000000000000000000000000000000000000000100', 'big')
-
-    const priv2 = new PrivateKey(bn2)
-
-    const privKey2 = priv2.toWif()
-
-    const keyOffset = 'KyaVZ1AnxYN4oB8JnxYVyZ8xYC9ySpq2Umzx6jwzQGVo71k1EgSt'
-    const oPrivKey = 'KyMYVLNeyF4qQsgHW3N1eJv9WcRd2aZC8hw7iLgCojQsyizqKsV4'
-
-    const r12 = offsetPrivKey(privKey2, keyOffset)
-
-    expect(r12.keyOffset).toBe(keyOffset)
-
-    expect(r12.offsetPrivKey).toBe(oPrivKey)
-  })
-
-  test('2_offsetPubKey', async () => {
-    const bn2 = BigNumber.fromHex('FFF0000000000000000000000000000000000000000000000000000000000100', 'big')
-
-    const priv2 = new PrivateKey(bn2)
-
-    const pub2 = priv2.toPublicKey()
-
-    const keyOffset = 'KyaVZ1AnxYN4oB8JnxYVyZ8xYC9ySpq2Umzx6jwzQGVo71k1EgSt'
-    const oPrivKey = 'KyMYVLNeyF4qQsgHW3N1eJv9WcRd2aZC8hw7iLgCojQsyizqKsV4'
-    const oPubKey = '024b4362ce98e0afd22bf3319831cfaf691ad2f08471a3386bcda98d65435a0f24'
-
-    const r22 = offsetPubKey(pub2.toString(), keyOffset)
-
-    expect(r22.keyOffset).toBe(keyOffset)
-
-    expect(r22.offsetPubKey).toBe(oPubKey)
-
-    const pubKey2 = PrivateKey.fromWif(oPrivKey).toPublicKey().toString()
-
-    expect(pubKey2).toBe(oPubKey)
-  })
-
-  test('3_lockScriptWithKeyOffsetFromPubKey', async () => {
-    const pubKey = '0397742eaef6c7f08c4aa057397d45529f93ab90345b84ce5a5aac06ea9cdd132e'
-
-    const ko = 'Kx9MjojdkjL3bEo5tQwHpwT1voKN1z56NjpATsa2Sx6QTrVjgMQJ'
-    const script = '76a9149d09d0ee09b212c548f6b1a7835641f33654246788ac'
-
-    const r1 = lockScriptWithKeyOffsetFromPubKey(pubKey, ko)
-
-    expect(r1.script).toBe(script)
-    expect(r1.keyOffset).toBe(ko)
-
-    // And with a random keyOffset...
-    const r2 = lockScriptWithKeyOffsetFromPubKey(pubKey)
-
-    expect(r2.script).not.toBe(script)
-    expect(r2.keyOffset).not.toBe(ko)
-  })
-
-  test('4a_check keyOffset address', async () => {
-    if (_tu.noEnv('main')) return
-
-    const env = _tu.getEnv('main')
-    const privHex = env.devKeys[env.commissionsIdentity]!
-    const priv = PrivateKey.fromHex(privHex)
-    const pub = priv.toPublicKey()
-
-    const keyOffset = 'L2hMY5uW6Vh46DEFMzrYiKSFWDRSMGDTsaeDvhiKNNJGihwKD17w'
-
-    const r = offsetPrivKey(priv.toWif(), keyOffset)
-    const privO = PrivateKey.fromWif(r.offsetPrivKey)
-    const address = privO.toAddress()
-    expect(address).toBe('1EZz5oxwXoG6LgGLxeYPeg1NfzQrP1vL6M')
-  })
-
-  test('4_redeemServiceCharges', async () => {
-    if (_tu.noEnv('main')) return
-
-    const env = _tu.getEnv('main')
-    if (!env.devKeys[env.commissionsIdentity]) {
-      throw new Error('No dev key for commissions identity')
-    }
-
-    const knex = Setup.createMySQLKnex(process.env.MAIN_CLOUD_MYSQL_CONNECTION!)
-    const storage = new StorageKnex({
-      chain: env.chain,
-      knex: knex,
-      commissionSatoshis: 0,
-      commissionPubKeyHex: undefined,
-      feeModel: { model: 'sat/kb', value: 1 }
-    })
-
-    let setup: TestWalletOnly
-    await storage.makeAvailable()
-
-    setup = await _tu.createTestWalletWithStorageClient({
-      chain: 'main',
-      rootKeyHex: env.devKeys[env.commissionsIdentity]
-    })
-    storage.setServices(setup.services)
-
-    try {
-      // await setup.wallet.abortAction({ reference: 'e9c03bdf603e90ebe482044e8d0f7afbf2d6fe480a13dbd8689e2e5e5183bed4' })
-
-      // txid b6f72df4224efbacab42a16e1e88f48c217f03929c36987b9067d2556de47c10
-      // height 922107
-      // hash 00000000000000001957bfadf841d1709d5039b3243c33ba58e4a6a97b44d2a8
-      const sm = new WalletStorageManager(setup.identityKey, storage)
-      sm.setServices(setup.services)
-      await sm.reproveHeader('000000000000000014d97d19bf82956c1f7ce3977da10b7fbdab9a10653c02e7')
-
-      const comms: TableCommission[] = []
-      const beef = new Beef()
-      const chainTracker = await setup.services.getChainTracker()
-      const inputs: CreateActionInput[] = []
-
-      const fca: FindCommissionsArgs = {
-        partial: { isRedeemed: false },
-        paged: { limit: 200, offset: 0 }
-      }
-
-      for (; comms.length < fca.paged!.limit; ) {
-        const unredeemedComms = await storage.findCommissions(fca)
-        if (unredeemedComms.length === 0) break
-        for (const comm of unredeemedComms) {
-          const tt = verifyTruthy(await storage.findTransactionById(comm.transactionId, undefined, true))
-          if (tt.provenTxId && tt.txid) {
-            // Only add merge valid beefs...
-            try {
-              await storage.getBeefForTransaction(tt.txid, { mergeToBeef: beef, chainTracker })
-            } catch (e) {
-              // Ignore errors in merging beefs
-            }
-            const tx = verifyTruthy(beef.findTxid(tt.txid)).tx!
-            const commVOut = tx.outputs.findIndex(
-              o => o.satoshis === comm.satoshis && o.lockingScript.toHex() === Utils.toHex(comm.lockingScript)
-            )
-            const commOut = tx.outputs[commVOut]
-            const input: CreateActionInput = {
-              outpoint: `${tt.txid}.${commVOut}`,
-              inputDescription: `commId:${comm.commissionId}`,
-              unlockingScriptLength: 108
-            }
-            inputs.push(input)
-            comms.push(comm)
-            if (comms.length >= fca.paged!.limit) break
-          }
-        }
-        fca.paged!.offset! += unredeemedComms.length
-      }
-
-      if (comms.length > 0) {
-        console.log(beef.toLogString())
-        const verified = await beef.verify(await setup.services.getChainTracker(), false)
-        expect(verified).toBe(true)
-
-        const cao: CreateActionOptions = {
-          randomizeOutputs: false,
-          //signAndProcess: false,
-          noSend: true
-        }
-        const ca: CreateActionArgs = {
-          description: 'redeem commissions',
-          inputs: inputs,
-          inputBEEF: beef.toBinary(),
-          options: cao
-        }
-
-        const car = await setup.wallet.createAction(ca)
-        expect(car.signableTransaction).toBeTruthy()
-
-        const st = car.signableTransaction!
-        expect(st.reference).toBeTruthy()
-        const atomicBeef = Beef.fromBinary(st.tx)
-        const txid = atomicBeef.txs[atomicBeef.txs.length - 1].txid!
-        const tx = atomicBeef.findTransactionForSigning(txid)!
-
-        const priv = PrivateKey.fromHex(env.devKeys[env.commissionsIdentity])
-        const pub = priv.toPublicKey()
-        const curve = new Curve()
-        const p2pkh = new P2PKH()
-        const spends: Record<PositiveIntegerOrZero, SignActionSpend> = {}
-        let vin = 0
-        // set an unlockingScriptTemplate for each commission input being redeemed in unsigned tx
-        for (const comm of comms) {
-          const { hashedSecret } = keyOffsetToHashedSecret(pub, comm.keyOffset)
-          const bn = priv.add(hashedSecret).mod(curve.n)
-          const offsetPrivKey = new PrivateKey(bn)
-          const unlock = p2pkh.unlock(offsetPrivKey, 'all', false)
-          tx.inputs[vin].unlockingScriptTemplate = unlock
-          vin++
-        }
-
-        // sign each input
-        await tx.sign()
-
-        vin = 0
-        // extract all the signed unlocking scripts
-        for (const comm of comms) {
-          const script = tx.inputs[vin].unlockingScript!
-          const unlockingScript = script.toHex()
-          spends[vin] = { unlockingScript }
-          vin++
-        }
-
-        const signArgs: SignActionArgs = {
-          reference: st.reference,
-          spends,
-          options: {
-            returnTXIDOnly: true,
-            noSend: true
-          }
-        }
-
-        // Forward all the unlocking scripts to storage and create the ProvenTxReq for the noSend txid.
-        const sr = await setup.wallet.signAction(signArgs)
-        expect(sr.txid).toBeTruthy()
-
-        // Update the commissions as redeemed in storage
-        for (const comm of comms) {
-          await storage.updateCommission(comm.commissionId, { isRedeemed: true })
-        }
-
-        {
-          // Get the transaction broadcast
-          const createArgs: CreateActionArgs = {
-            description: `broadcasting noSend`,
-            options: {
-              acceptDelayedBroadcast: false,
-              sendWith: [sr.txid!]
-            }
-          }
-
-          const cr = await setup.wallet.createAction(createArgs)
-
-          expect(cr.noSendChange).not.toBeTruthy()
-          expect(cr.sendWithResults?.length).toBe(1)
-          const [swr] = cr.sendWithResults!
-          expect(swr.status !== 'failed').toBe(true)
-        }
-      }
-    } catch (err) {
-      console.error('Error in 4_redeemServiceCharges test:', err)
-      throw err
-    }
-
-    await storage.destroy()
-    await setup.wallet.destroy()
-  })
-})

package/src/storage/methods/attemptToPostReqsToNetwork.ts

@@ -1,389 +0,0 @@
-import { Beef, Transaction, WalletLoggerInterface } from '@bsv/sdk'
-import { StorageProvider } from '../StorageProvider'
-import { EntityProvenTxReq } from '../schema/entities'
-import * as sdk from '../../sdk'
-import { ReqHistoryNote } from '../../sdk'
-import { wait } from '../../utility/utilityHelpers'
-
-/**
- * Attempt to post one or more `ProvenTxReq` with status 'unsent'
- * to the bitcoin network.
- *
- * @param reqs
- */
-export async function attemptToPostReqsToNetwork(
-  storage: StorageProvider,
-  reqs: EntityProvenTxReq[],
-  trx?: sdk.TrxToken,
-  logger?: WalletLoggerInterface
-): Promise<PostReqsToNetworkResult> {
-  // initialize results, validate reqs ready to post, txids are of the transactions in the beef that we care about.
-
-  const { r, vreqs, txids } = await validateReqsAndMergeBeefs(storage, reqs, trx)
-  logger?.log(`validated request and merged beefs`)
-
-  const services = storage.getServices()
-
-  const pbrs = await services.postBeef(r.beef, txids, logger)
-
-  // post beef results (pbrs) is an array by service provider
-  // for each service provider, there's an aggregate result and individual results by txid.
-
-  await transferNotesToReqHistories(txids, vreqs, pbrs, storage, trx)
-
-  const apbrs = aggregatePostBeefResultsByTxid(txids, vreqs, pbrs)
-
-  await updateReqsFromAggregateResults(txids, r, apbrs, storage, services, trx, logger)
-
-  return r
-}
-
-async function validateReqsAndMergeBeefs(
-  storage: StorageProvider,
-  reqs: EntityProvenTxReq[],
-  trx?: sdk.TrxToken
-): Promise<{ r: PostReqsToNetworkResult; vreqs: PostReqsToNetworkDetails[]; txids: string[] }> {
-  const r: PostReqsToNetworkResult = {
-    status: 'success',
-    beef: new Beef(),
-    details: [],
-    log: ''
-  }
-
-  const vreqs: PostReqsToNetworkDetails[] = []
-
-  for (const req of reqs) {
-    try {
-      const noRawTx = !req.rawTx
-      const noTxIds = !req.notify.transactionIds || req.notify.transactionIds.length < 1
-      const noInputBEEF = !req.inputBEEF
-      if (noRawTx || noTxIds || noInputBEEF) {
-        // This should have happened earlier...
-        req.addHistoryNote({ when: new Date().toISOString(), what: 'validateReqFailed', noRawTx, noTxIds, noInputBEEF })
-        req.status = 'invalid'
-        await req.updateStorageDynamicProperties(storage, trx)
-        r.details.push({ txid: req.txid, req, status: 'invalid' })
-      } else {
-        const vreq: PostReqsToNetworkDetails = { txid: req.txid, req, status: 'unknown' }
-        await storage.mergeReqToBeefToShareExternally(req.api, r.beef, [], trx)
-        vreqs.push(vreq)
-        r.details.push(vreq)
-      }
-    } catch (eu: unknown) {
-      const { code, message } = sdk.WalletError.fromUnknown(eu)
-      req.addHistoryNote({ when: new Date().toISOString(), what: 'validateReqError', txid: req.txid, code, message })
-      req.attempts++
-      if (req.attempts > 6) {
-        req.status = 'invalid'
-        r.details.push({ txid: req.txid, req, status: 'invalid' })
-      }
-      await req.updateStorageDynamicProperties(storage, trx)
-    }
-  }
-  return { r, vreqs, txids: vreqs.map(r => r.txid) }
-}
-
-async function transferNotesToReqHistories(
-  txids: string[],
-  vreqs: PostReqsToNetworkDetails[],
-  pbrs: sdk.PostBeefResult[],
-  storage: StorageProvider,
-  trx?: sdk.TrxToken
-): Promise<void> {
-  for (const txid of txids) {
-    const vreq = vreqs.find(r => r.txid === txid)
-    if (!vreq) throw new sdk.WERR_INTERNAL()
-    const notes: sdk.ReqHistoryNote[] = []
-    for (const pbr of pbrs) {
-      notes.push(...(pbr.notes || []))
-      const r = pbr.txidResults.find(tr => tr.txid === txid)
-      if (r) notes.push(...(r.notes || []))
-    }
-    for (const n of notes) {
-      vreq.req.addHistoryNote(n)
-    }
-    await vreq.req.updateStorageDynamicProperties(storage, trx)
-  }
-}
-
-/**
- * For each txid, decide on the aggregate success or failure of attempting to broadcast it to the bitcoin processing network.
- *
- * Possible results:
- * 1. Success: At least one success, no double spends.
- * 2. DoubleSpend: One or more double spends.
- * 3. InvalidTransaction: No success, no double spend, one or more non-exception errors.
- * 4. Service Failure: No results or all results are exception errors.
- *
- * @param txids
- * @param reqs
- * @param pbrs
- * @param storage
- * @returns
- */
-function aggregatePostBeefResultsByTxid(
-  txids: string[],
-  vreqs: PostReqsToNetworkDetails[],
-  pbrs: sdk.PostBeefResult[]
-): Record<string, AggregatePostBeefTxResult> {
-  const r: Record<string, AggregatePostBeefTxResult> = {}
-
-  for (const txid of txids) {
-    const vreq = vreqs.find(r => r.txid === txid)!
-    const ar: AggregatePostBeefTxResult = {
-      txid,
-      vreq,
-      txidResults: [],
-      status: 'success',
-      successCount: 0,
-      doubleSpendCount: 0,
-      statusErrorCount: 0,
-      serviceErrorCount: 0,
-      competingTxs: []
-    }
-    r[txid] = ar
-    for (const pbr of pbrs) {
-      const tr = pbr.txidResults.find(tr => tr.txid === txid)
-      if (tr) {
-        ar.txidResults.push(tr)
-        if (tr.status === 'success') ar.successCount++
-        else if (tr.doubleSpend) {
-          ar.doubleSpendCount++
-          if (tr.competingTxs) {
-            ar.competingTxs = [...tr.competingTxs]
-          }
-        } else if (tr.serviceError) ar.serviceErrorCount++
-        else ar.statusErrorCount++
-      }
-      if (ar.competingTxs.length > 1) ar.competingTxs = [...new Set(ar.competingTxs)] // Remove duplicates
-    }
-
-    if (ar.successCount > 0 && ar.doubleSpendCount === 0) ar.status = 'success'
-    else if (ar.doubleSpendCount > 0) ar.status = 'doubleSpend'
-    else if (ar.statusErrorCount > 0) ar.status = 'invalidTx'
-    else ar.status = 'serviceError'
-  }
-
-  return r
-}
-
-/**
- * For each txid in submitted `txids`:
- *
- *   Based on its aggregate status, and whether broadcast happening in background (isDelayed) or immediately (!isDelayed),
- *   and iff current req.status is not 'unproven' or 'completed':
- *
- *     'success':
- *       req.status => 'unmined', tx.status => 'unproven'
- *     'doubleSpend':
- *       req.status => 'doubleSpend', tx.status => 'failed'
- *     'invalidTx':
- *       req.status => 'invalid', tx.status => 'failed'
- *     'serviceError':
- *       increment req.attempts
- *
- * @param txids
- * @param apbrs
- * @param storage
- * @param services if valid, doubleSpend results will be verified (but only if not within a trx. e.g. trx must be undefined)
- * @param trx
- */
-async function updateReqsFromAggregateResults(
-  txids: string[],
-  r: PostReqsToNetworkResult,
-  apbrs: Record<string, AggregatePostBeefTxResult>,
-  storage: StorageProvider,
-  services?: sdk.WalletServices,
-  trx?: sdk.TrxToken,
-  logger?: WalletLoggerInterface
-): Promise<void> {
-  logger?.group('update storage from aggregate results')
-  for (const txid of txids) {
-    const ar = apbrs[txid]!
-    const req = ar.vreq.req
-    await req.refreshFromStorage(storage, trx)
-
-    const { successCount, doubleSpendCount, statusErrorCount, serviceErrorCount } = ar
-    const note: ReqHistoryNote = {
-      when: new Date().toISOString(),
-      what: 'aggregateResults',
-      reqStatus: req.status,
-      aggStatus: ar.status,
-      attempts: req.attempts,
-      successCount,
-      doubleSpendCount,
-      statusErrorCount,
-      serviceErrorCount
-    }
-
-    if (['completed', 'unmined'].indexOf(req.status) >= 0)
-      // However it happened, don't degrade status if it is somehow already beyond broadcast stage
-      continue
-
-    if (ar.status === 'doubleSpend' && services && !trx) await confirmDoubleSpend(ar, r.beef, storage, services, logger)
-
-    let newReqStatus: sdk.ProvenTxReqStatus | undefined = undefined
-    let newTxStatus: sdk.TransactionStatus | undefined = undefined
-    switch (ar.status) {
-      case 'success':
-        newReqStatus = 'unmined'
-        newTxStatus = 'unproven'
-        break
-      case 'doubleSpend':
-        newReqStatus = 'doubleSpend'
-        newTxStatus = 'failed'
-        break
-      case 'invalidTx':
-        newReqStatus = 'invalid'
-        newTxStatus = 'failed'
-        break
-      case 'serviceError':
-        newReqStatus = 'sending'
-        newTxStatus = 'sending'
-        req.attempts++
-        break
-      default:
-        throw new sdk.WERR_INTERNAL(`unimplemented AggregateStatus ${ar.status}`)
-    }
-
-    note.newReqStatus = newReqStatus
-    note.newTxStatus = newTxStatus
-    note.newAttempts = req.attempts
-
-    if (newReqStatus) req.status = newReqStatus
-
-    req.addHistoryNote(note)
-    await req.updateStorageDynamicProperties(storage, trx)
-
-    if (newTxStatus) {
-      const ids = req.notify.transactionIds
-      if (ids) {
-        // Also set generated outputs to spendable false and consumed input outputs to spendable true (and clears their spentBy).
-        await storage.updateTransactionsStatus(ids, newTxStatus, trx)
-      }
-    }
-
-    // Transfer critical results to details going back to the user
-    const details = r.details.find(d => d.txid === txid)!
-    details.status = ar.status
-    details.competingTxs = ar.competingTxs
-    logger?.log(`updated ${txid}`)
-  }
-  logger?.group('update storage from aggregate results')
-}
-
-/**
- * Requires ar.status === 'doubleSpend'
- *
- * Parse the rawTx and review each input as a possible double spend.
- *
- * If all inputs appear to be unspent, update aggregate status to 'success' if successCount > 0, otherwise 'serviceError'.
- *
- * @param ar
- * @param storage
- * @param services
- */
-async function confirmDoubleSpend(
-  ar: AggregatePostBeefTxResult,
-  beef: Beef,
-  storage: StorageProvider,
-  services: sdk.WalletServices,
-  logger?: WalletLoggerInterface
-): Promise<void> {
-  const req = ar.vreq.req
-  const note: ReqHistoryNote = { when: new Date().toISOString(), what: 'confirmDoubleSpend' }
-
-  let known = false
-
-  for (let retry = 0; retry < 3; retry++) {
-    const gsr = await services.getStatusForTxids([req.txid])
-    note[`getStatus${retry}`] = `${gsr.status}${gsr.error ? `${gsr.error.code}` : ''},${gsr.results[0]?.status}`
-    if (gsr.status === 'success' && gsr.results[0].status !== 'unknown') {
-      known = true
-      break
-    } else {
-      await wait(1000)
-    }
-  }
-
-  if (known) {
-    // doubleSpend -> success
-    ar.status = 'success'
-    note.newStatus = ar.status
-  } else {
-    // Confirmed double spend, get txids of possible competing transactions.
-    const tx = Transaction.fromBinary(req.rawTx)
-    const competingTxids = new Set(ar.competingTxs)
-    for (const input of tx.inputs) {
-      const sourceTx = beef.findTxid(input.sourceTXID!)?.tx
-      if (!sourceTx) throw new sdk.WERR_INTERNAL(`beef lacks tx for ${input.sourceTXID}`)
-      const lockingScript = sourceTx.outputs[input.sourceOutputIndex].lockingScript.toHex()
-      const hash = services.hashOutputScript(lockingScript)
-      const shhrs = await services.getScriptHashHistory(hash, undefined, logger)
-      if (shhrs.status === 'success') {
-        for (const h of shhrs.history) {
-          // Neither the source of the input nor the current transaction are competition.
-          if (h.txid !== input.sourceTXID && h.txid !== ar.txid) competingTxids.add(h.txid)
-        }
-      }
-    }
-    ar.competingTxs = [...competingTxids].slice(-24) // keep at most 24, if they were sorted by time, keep newest
-    note.competingTxs = ar.competingTxs.join(',')
-  }
-  req.addHistoryNote(note)
-}
-
-type AggregateStatus = 'success' | 'doubleSpend' | 'invalidTx' | 'serviceError'
-
-interface AggregatePostBeefTxResult {
-  txid: string
-  txidResults: sdk.PostTxResultForTxid[]
-  status: AggregateStatus
-  vreq: PostReqsToNetworkDetails
-  successCount: number
-  doubleSpendCount: number
-  statusErrorCount: number
-  serviceErrorCount: number
-  /**
-   * Any competing double spend txids reported for this txid
-   */
-  competingTxs: string[]
-}
-
-/**
- * Indicates status of a new Action following a `createAction` or `signAction` in immediate mode:
- * When `acceptDelayedBroadcast` is falses.
- *
- * 'success': The action has been broadcast and accepted by the bitcoin processing network.
- * 'doulbeSpend': The action has been confirmed to double spend one or more inputs, and by the "first-seen-rule" is the loosing transaction.
- * 'invalidTx': The action was rejected by the processing network as an invalid bitcoin transaction.
- * 'serviceError': The broadcast services are currently unable to reach the bitcoin network. The action is now queued for delayed retries.
- *
- * 'invalid': The action was in an invalid state for processing, this status should never be seen by user code.
- * 'unknown': An internal processing error has occured, this status should never be seen by user code.
- *
- */
-export type PostReqsToNetworkDetailsStatus =
-  | 'success'
-  | 'doubleSpend'
-  | 'unknown'
-  | 'invalid'
-  | 'serviceError'
-  | 'invalidTx'
-
-export interface PostReqsToNetworkDetails {
-  txid: string
-  req: EntityProvenTxReq
-  status: PostReqsToNetworkDetailsStatus
-  /**
-   * Any competing double spend txids reported for this txid
-   */
-  competingTxs?: string[]
-}
-
-export interface PostReqsToNetworkResult {
-  status: 'success' | 'error'
-  beef: Beef
-  details: PostReqsToNetworkDetails[]
-  log: string
-}