@bopen-io/wallet-toolbox 1.7.18

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

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

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

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