@bopen-io/wallet-toolbox 1.7.18

package/test/Wallet/local/localWallet2.man.test.ts

@@ -0,0 +1,277 @@
+import { Beef, PrivateKey, SignActionArgs, WalletOutput, Validation } from '@bsv/sdk'
+import { sdk, Setup, TableUser } from '../../../src'
+import { _tu } from '../../utils/TestUtilsWalletStorage'
+import { specOpInvalidChange, WERR_REVIEW_ACTIONS } from '../../../src/sdk'
+import {
+  burnOneSatTestOutput,
+  createMainReviewSetup,
+  createOneSatTestOutput,
+  createSetup,
+  doubleSpendOldChange,
+  LocalWalletTestOptions,
+  recoverOneSatTestOutputs
+} from '../../utils/localWalletMethods'
+
+import * as dotenv from 'dotenv'
+dotenv.config()
+
+const chain: sdk.Chain = 'main'
+
+const options: LocalWalletTestOptions = {
+  setActiveClient: true,
+  useMySQLConnectionForClient: true,
+  useTestIdentityKey: false,
+  useIdentityKey2: false
+}
+
+describe('localWallet2 tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 monitor runOnce', async () => {
+    const setup = await createSetup(chain, options)
+    //const log = await setup.monitor.runTask('UnFail')
+    //if (log) console.log(log)
+    await setup.monitor.runOnce()
+    await setup.wallet.destroy()
+  })
+
+  test('0a abort nosend', async () => {
+    const setup = await createSetup(chain, options)
+    await setup.wallet.listNoSendActions({ labels: [] }, true)
+    await setup.wallet.destroy()
+  })
+
+  test('1 recover 1 sat outputs', async () => {
+    const setup = await createSetup(chain, options)
+    await recoverOneSatTestOutputs(setup, 1)
+    await setup.wallet.destroy()
+  })
+
+  test('2 create 1 sat delayed', async () => {
+    const setup = await createSetup(chain, options)
+    const car = await createOneSatTestOutput(setup, {}, 1)
+    //await trackReqByTxid(setup, car.txid!)
+    await setup.wallet.destroy()
+  })
+
+  test('2a create 1 sat immediate', async () => {
+    const setup = await createSetup(chain, options)
+    const car = await createOneSatTestOutput(setup, { acceptDelayedBroadcast: false }, 1)
+    await setup.wallet.destroy()
+  })
+
+  test('2c burn 1 sat output', async () => {
+    const setup = await createSetup(chain, options)
+    await burnOneSatTestOutput(setup, {}, 1)
+    await setup.wallet.destroy()
+  })
+
+  test('2d doubleSpend old change', async () => {
+    const setup = await createSetup(chain, options)
+    try {
+      await doubleSpendOldChange(setup, {
+        acceptDelayedBroadcast: false
+      })
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu) as WERR_REVIEW_ACTIONS
+      expect(e.code).toBe('WERR_REVIEW_ACTIONS')
+      expect(e.reviewActionResults?.length === 1).toBe(true)
+      const rar = e.reviewActionResults![0]!
+      expect(rar.status).toBe('doubleSpend')
+      expect(rar.competingTxs?.length).toBe(1)
+    }
+    await setup.wallet.destroy()
+  })
+
+  test('4 review change utxos', async () => {
+    const setup = await createSetup(chain, options)
+    const lor = await setup.wallet.listOutputs({
+      basket: specOpInvalidChange,
+      tags: ['all']
+    })
+    if (lor.totalOutputs > 0) {
+      debugger
+      const lor = await setup.wallet.listOutputs({
+        basket: specOpInvalidChange,
+        tags: ['all', 'release']
+      })
+    }
+    await setup.wallet.destroy()
+  })
+
+  test('5 review and release all production invalid change utxos', async () => {
+    const { env, storage } = await createMainReviewSetup()
+    const users = await storage.findUsers({ partial: {} })
+    const withInvalid: Record<number, { user: TableUser; outputs: WalletOutput[]; total: number }> = {}
+    // [76, 48, 166, 94, 110, 111, 81]
+    const vargs: Validation.ValidListOutputsArgs = {
+      basket: specOpInvalidChange,
+      tags: [],
+      tagQueryMode: 'all',
+      includeLockingScripts: false,
+      includeTransactions: false,
+      includeCustomInstructions: false,
+      includeTags: false,
+      includeLabels: false,
+      limit: 0,
+      offset: 0,
+      seekPermission: false,
+      knownTxids: []
+    }
+    for (const user of users) {
+      const { userId } = user
+      const auth = { userId, identityKey: '' }
+      let r = await storage.listOutputs(auth, vargs)
+      if (r.totalOutputs > 0) {
+        const total: number = r.outputs.reduce((s, o) => (s += o.satoshis), 0)
+        console.log(`userId ${userId}: ${r.totalOutputs} unspendable utxos, total ${total}, ${user.identityKey}`)
+        withInvalid[userId] = { user, outputs: r.outputs, total }
+      }
+    }
+    if (Object.keys(withInvalid).length > 0) {
+      debugger
+      // Release invalids
+      for (const { user, outputs } of Object.values(withInvalid)) {
+        const { userId } = user
+        const auth = { userId, identityKey: '' }
+        await storage.listOutputs(auth, { ...vargs, tags: ['release'] })
+      }
+      // Verify
+      for (const { user, outputs } of Object.values(withInvalid)) {
+        const { userId } = user
+        const auth = { userId, identityKey: '' }
+        const r = await storage.listOutputs(auth, vargs)
+        expect(r.totalOutputs).toBe(0)
+      }
+    }
+    await storage.destroy()
+  })
+
+  test('6 review and unfail false doubleSpends', async () => {
+    const { env, storage, services } = await createMainReviewSetup()
+    let offset = 1100
+    const limit = 100
+    let allUnfails: number[] = []
+    for (;;) {
+      let log = ''
+      const unfails: number[] = []
+      const reqs = await storage.findProvenTxReqs({ partial: { status: 'doubleSpend' }, paged: { limit, offset } })
+      for (const req of reqs) {
+        const gsr = await services.getStatusForTxids([req.txid])
+        if (gsr.results[0].status !== 'unknown') {
+          log += `unfail ${req.provenTxReqId} ${req.txid}\n`
+          unfails.push(req.provenTxReqId)
+        }
+      }
+      console.log(`OFFSET: ${offset} ${unfails.length} unfails\n${log}`)
+      allUnfails = allUnfails.concat(unfails)
+      if (reqs.length < limit) break
+      offset += reqs.length
+    }
+    debugger
+    for (const id of allUnfails) {
+      await storage.updateProvenTxReq(id, { status: 'unfail' })
+    }
+    await storage.destroy()
+  })
+
+  test('7 review and unfail false invalids', async () => {
+    const { env, storage, services } = await createMainReviewSetup()
+    let offset = 1000
+    const limit = 100
+    let allUnfails: number[] = []
+    for (;;) {
+      let log = ''
+      const unfails: number[] = []
+      const reqs = await storage.findProvenTxReqs({ partial: { status: 'invalid' }, paged: { limit, offset } })
+      for (const req of reqs) {
+        if (!req.txid || !req.rawTx) continue
+        const gsr = await services.getStatusForTxids([req.txid])
+        if (gsr.results[0]?.status !== 'unknown') {
+          log += `unfail ${req.provenTxReqId} ${req.txid}\n`
+          unfails.push(req.provenTxReqId)
+        }
+      }
+      console.log(`OFFSET: ${offset} ${unfails.length} unfails\n${log}`)
+      allUnfails = allUnfails.concat(unfails)
+      if (reqs.length < limit) break
+      offset += reqs.length
+    }
+    debugger
+    for (const id of allUnfails) {
+      await storage.updateProvenTxReq(id, { status: 'unfail' })
+    }
+    await storage.destroy()
+  })
+
+  test('8 Beef verifier', async () => {
+    const setup = await createSetup(chain, options)
+    // replace bb with beef to test
+    const bb = new Beef().toBinary()
+    const beef = Beef.fromBinary(bb)
+    console.log(beef.toLogString())
+    const ok = await beef.verify(await setup.services.getChainTracker())
+    await setup.wallet.destroy()
+  })
+
+  test.skip('9 received payment from wif and outpoint', async () => {
+    const setup = await createSetup(chain, options)
+    console.log(`active store ${setup.wallet.storage.getActiveStore()}`)
+    if (!setup.wallet.storage.isActiveEnabled) throw new Error('Active storage is not enabled.')
+
+    const pk = PrivateKey.fromWif('L4ZRWA...Nw4Brt8rvJLRZegPF2oiBKJaxUgr4e')
+    const outpoint = { txid: '5e2965a50618425af21bebddb9aa60c3e12f64c8e1eb44b6589273455a9760e9', vout: 0 }
+    const address = pk.toAddress()
+    console.log(`address: ${address.toString()}`)
+
+    const inputBEEF = await setup.activeStorage.getBeefForTransaction(outpoint.txid, { ignoreStorage: true })
+    const btx = inputBEEF.findTxid(outpoint.txid)
+    const satoshis = btx!.tx!.outputs[0]!.satoshis!
+
+    const unlock = Setup.getUnlockP2PKH(pk, satoshis)
+
+    const label = 'inputBrayden257'
+
+    const car = await setup.wallet.createAction({
+      inputBEEF: inputBEEF.toBinary(),
+      inputs: [
+        {
+          outpoint: `${outpoint.txid}.${outpoint.vout}`,
+          unlockingScriptLength: 108,
+          inputDescription: label
+        }
+      ],
+      labels: [label],
+      description: label
+    })
+
+    const st = car.signableTransaction!
+    const beef = Beef.fromBinary(st.tx)
+    const tx = beef.findAtomicTransaction(beef.txs.slice(-1)[0].txid)!
+    tx.inputs[0].unlockingScriptTemplate = unlock
+    await tx.sign()
+    const unlockingScript = tx.inputs[0].unlockingScript!.toHex()
+
+    const signArgs: SignActionArgs = {
+      reference: st.reference,
+      spends: { 0: { unlockingScript } },
+      options: {
+        acceptDelayedBroadcast: false
+      }
+    }
+
+    const sar = await setup.wallet.signAction(signArgs)
+
+    {
+      const beef = Beef.fromBinary(sar.tx!)
+      const txid = sar.txid!
+
+      console.log(`
+BEEF
+${beef.toHex()}
+${beef.toLogString()}
+`)
+    }
+    await setup.wallet.destroy()
+  })
+})

package/test/Wallet/signAction/mountaintop.man.test.ts

@@ -0,0 +1,130 @@
+import {
+  Beef,
+  BigNumber,
+  Hash,
+  P2PKH,
+  PublicKey,
+  Signature,
+  Transaction,
+  TransactionSignature,
+  UnlockingScript,
+  Utils,
+  Validation
+} from '@bsv/sdk'
+import { Setup, verifyInteger, verifyTruthy, Wallet } from '../../../src'
+const parseWalletOutpoint = Validation.parseWalletOutpoint
+
+describe('mountaintop tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 signature validity', async () => {
+    // obtain the secrets environment for the testnet network.
+    const env = Setup.getEnv('main')
+    const setup = await Setup.createWalletClient({ env })
+
+    const privKey = await setup.wallet.keyDeriver.derivePrivateKey([1, 'mountaintops'], '1', 'anyone')
+    const a2 = privKey.toAddress()
+
+    const { publicKey } = await setup.wallet.getPublicKey({
+      protocolID: [1, 'mountaintops'],
+      keyID: '1',
+      counterparty: 'anyone',
+      forSelf: true
+    })
+    const address = PublicKey.fromString(publicKey).toAddress()
+    expect(address).toBe('1BSMQ1PxMbzMqjB47EYaSNBAD7Qme1dXuk')
+    expect(a2).toBe(address)
+
+    const msg = [
+      111, 16, 29, 104, 166, 199, 108, 36, 242, 153, 242, 104, 10, 198, 151, 176, 170, 69, 98, 209, 88, 105, 113, 199,
+      124, 56, 189, 3, 104, 214, 94, 76
+    ]
+    const msgHash = new BigNumber(msg, 16)
+    const h1 = msgHash.toHex()
+    const msgHash2 = new BigNumber(msg)
+    const h2 = msgHash2.toHex()
+
+    const beef = Beef.fromString(beef0, 'hex')
+    const o = parseWalletOutpoint(outpoints[0])
+    const tx = new Transaction()
+    tx.addInput({
+      sourceOutputIndex: o.vout,
+      sourceTXID: o.txid,
+      sourceTransaction: beef.findAtomicTransaction(o.txid)
+    })
+
+    const p2pkh = new P2PKH().unlock(privKey, 'all')
+    tx.inputs[0].unlockingScript = await p2pkh.sign(tx, 0)
+    const ok2 = await tx.verify('scripts only')
+    expect(ok2).toBe(true)
+
+    tx.inputs[0].unlockingScript = await sign(setup.wallet, tx, 0)
+    const ok = await tx.verify('scripts only')
+    expect(ok).toBe(true)
+  })
+})
+
+const outpoints = [
+  '30c83f8b84864fd4497414980faadf074192e7193602ef96ca18705876ce74b1.0',
+  '797bd197f2328931231f2834c5dc8036fe9990981c368df27d3b55fa926863be.0',
+  '08d47d844e81d751691f6b4a39ce378e9d0f70a3a0606c87995f0f28399552e2.0'
+]
+const beef0 =
+  '0200beef01fe068d0d0008027a001b501758910c83d8e2c839cfc133245510f5ddbbd28202c331bb9feccc261c287b02b174ce76587018ca96ef023619e7924107dfaa0f98147449d44f86848b3fc830013c006174b69497f770d46604b177a98ff8b8a693a5cec19cd145b3b32abab71676f8011f001f86947779e8e749fd439f037d93733c2ea0734a17cdf1c32f87278b80c7ff72010e00161e280d8481978b9d2696c58d634beda36265ceef9faaa351566afc2c8ab2f0010600e250ce168ac74d432a14df5669f337cd44a8c2cfc8709b955174dd57e2354399010200fd976461d8c0ed097e32ae79afefb35e89daa7289daf7b01bde8bb1481762f590100005fb474d7ddaf5a299509a165cabfe0b6dbea56ed56d1f0d3acf1d3d89531a21e01010029f89d48414f66b9bfd8d711f51d6db0a712cfff2d641f66f83dd2e5e452e5c601010001000000014289ced528197deb6980d634200d333d9983c45ef46893affd027914fdc02cf7000000006a473044022019e70e4325f95b3d5f9f0569123b23c6bff7ef4197fcb15fa50ac3537b8546de0220100d181429245e0349903a0784ad61bfa022d864fca8ce6ba13b0de99fd39eb641210327c7cb8afcd1adce5b26055d70cad9fb1045976a6f99b2ee61ed36295d5802a7ffffffff020a000000000000001976a914727caee3e1178da2ca0b48786171f23695a4ccd088ac1d000000000000001976a9148419faaf7a5e97dcc62002e2415cb51bdb91937e88ac00000000'
+
+async function sign(client: Wallet, tx: Transaction, inputIndex: number): Promise<UnlockingScript> {
+  let signatureScope = TransactionSignature.SIGHASH_FORKID
+  signatureScope |= TransactionSignature.SIGHASH_ALL
+  const input = tx.inputs[inputIndex]
+  const otherInputs = tx.inputs.filter((_, index) => index !== inputIndex)
+  const sourceTXID = input.sourceTXID ?? input.sourceTransaction?.id('hex')
+  if (sourceTXID == null || sourceTXID === undefined) {
+    throw new Error('The input sourceTXID or sourceTransaction is required for transaction signing.')
+  }
+  if (sourceTXID === '') {
+    throw new Error('The input sourceTXID or sourceTransaction is required for transaction signing.')
+  }
+  const sourceSatoshis = input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+  if (sourceSatoshis == null || sourceSatoshis === undefined) {
+    throw new Error('The sourceSatoshis or input sourceTransaction is required for transaction signing.')
+  }
+  const lockingScript = input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript
+  if (lockingScript == null) {
+    throw new Error('The lockingScript or input sourceTransaction is required for transaction signing.')
+  }
+
+  const preimage = TransactionSignature.format({
+    sourceTXID,
+    sourceOutputIndex: verifyInteger(input.sourceOutputIndex),
+    sourceSatoshis,
+    transactionVersion: tx.version,
+    otherInputs,
+    inputIndex,
+    outputs: tx.outputs,
+    inputSequence: verifyTruthy(input.sequence),
+    subscript: lockingScript,
+    lockTime: tx.lockTime,
+    scope: signatureScope
+  })
+
+  const { signature } = await client.createSignature({
+    hashToDirectlySign: Hash.sha256(Hash.sha256(preimage)),
+    protocolID: [1, 'mountaintops'],
+    keyID: '1',
+    counterparty: 'anyone'
+  })
+  const rawSignature = Signature.fromDER(signature)
+  const sig = new TransactionSignature(rawSignature.r, rawSignature.s, signatureScope)
+  const sigForScript = sig.toChecksigFormat()
+  const { publicKey } = await client.getPublicKey({
+    protocolID: [1, 'mountaintops'],
+    keyID: '1',
+    counterparty: 'anyone',
+    forSelf: true
+  })
+  const pubkeyForScript = Utils.toArray(publicKey, 'hex')
+  return new UnlockingScript([
+    { op: sigForScript.length, data: sigForScript },
+    { op: pubkeyForScript.length, data: pubkeyForScript }
+  ])
+}

package/test/Wallet/specOps/specOps.man.test.ts

@@ -0,0 +1,220 @@
+import { WalletClient } from '@bsv/sdk'
+import { sdk, verifyOne } from '../../../src'
+import {
+  specOpInvalidChange,
+  specOpSetWalletChangeParams,
+  specOpThrowReviewActions,
+  specOpWalletBalance
+} from '../../../src/sdk'
+import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+describe('specOps tests', () => {
+  jest.setTimeout(99999999)
+
+  test('00', () => {})
+  if (_tu.noTestEnv('test')) return
+  if (_tu.noTestEnv('main')) return
+
+  test('0 wallet balance specOp', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.listOutputs({ basket: specOpWalletBalance })
+
+    expect(r.totalOutputs > 0).toBe(true)
+    expect(r.outputs.length === 0).toBe(true)
+
+    await setup.wallet.destroy()
+  })
+
+  test('0a wallet balance method', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.balance()
+
+    expect(r > 0).toBe(true)
+
+    await setup.wallet.destroy()
+  })
+
+  test('0b wallet balanceAndUtxos method', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.balanceAndUtxos('default')
+
+    expect(r.total > 0).toBe(true)
+    expect(r.utxos.length === 0).toBe(true)
+
+    await setup.wallet.destroy()
+  })
+
+  test('1 wallet invalid change outputs specOp', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.listOutputs({
+      basket: specOpInvalidChange
+      //tags: ['release', 'all']
+    })
+
+    expect(r.totalOutputs).toBe(0)
+    expect(r.outputs.length).toBe(0)
+
+    await setup.wallet.destroy()
+  })
+
+  test('1a wallet reviewSpendableOutputs method', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.reviewSpendableOutputs(false, false, {})
+
+    expect(r.totalOutputs).toBe(0)
+    expect(r.outputs.length).toBe(0)
+
+    await setup.wallet.destroy()
+  })
+
+  test('2 update default basket params specOp', async () => {
+    const setup = await createSetup('test')
+
+    const before = verifyOne(
+      await setup.activeStorage.findOutputBaskets({
+        partial: { userId: setup.userId, name: 'default' }
+      })
+    )
+
+    const r = await setup.wallet.listOutputs({
+      basket: specOpSetWalletChangeParams,
+      tags: ['33', '6']
+    })
+
+    const after = verifyOne(
+      await setup.activeStorage.findOutputBaskets({
+        partial: { userId: setup.userId, name: 'default' }
+      })
+    )
+
+    expect(r.totalOutputs).toBe(0)
+    expect(r.outputs.length).toBe(0)
+    expect(after.minimumDesiredUTXOValue).toBe(6)
+    expect(after.numberOfDesiredUTXOs).toBe(33)
+
+    // Restore original values...
+    await setup.wallet.listOutputs({
+      basket: specOpSetWalletChangeParams,
+      tags: [before.numberOfDesiredUTXOs.toString(), before.minimumDesiredUTXOValue.toString()]
+    })
+
+    await setup.wallet.destroy()
+  })
+
+  test('2a update default basket params specOp', async () => {
+    const setup = await createSetup('test')
+
+    const before = verifyOne(
+      await setup.activeStorage.findOutputBaskets({
+        partial: { userId: setup.userId, name: 'default' }
+      })
+    )
+
+    await setup.wallet.setWalletChangeParams(33, 6)
+
+    const after = verifyOne(
+      await setup.activeStorage.findOutputBaskets({
+        partial: { userId: setup.userId, name: 'default' }
+      })
+    )
+
+    expect(after.minimumDesiredUTXOValue).toBe(6)
+    expect(after.numberOfDesiredUTXOs).toBe(33)
+
+    // Restore original values...
+    await setup.wallet.setWalletChangeParams(before.numberOfDesiredUTXOs, before.minimumDesiredUTXOValue)
+
+    await setup.wallet.destroy()
+  })
+
+  test('3 wallet listNoSendActions method', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.listNoSendActions({
+      labels: [
+        // 'abort'
+      ]
+    })
+
+    expect(r.totalActions).toBeGreaterThanOrEqual(0)
+    expect(r.actions.length).toBe(r.totalActions)
+
+    await setup.wallet.destroy()
+  })
+
+  test('4 wallet listFailedActions method', async () => {
+    const setup = await createSetup('test')
+
+    const r = await setup.wallet.listFailedActions({
+      labels: [
+        // 'unfail'
+      ],
+      limit: 1000
+    })
+
+    expect(r.totalActions).toBeGreaterThanOrEqual(0)
+    expect(r.actions.length).toBe(r.totalActions)
+
+    await setup.wallet.destroy()
+  })
+
+  test('5 Wallet specOpThrowReviewActions', async () => {
+    const setup = await createSetup('test')
+
+    try {
+      const r = await setup.wallet.createAction({
+        labels: [specOpThrowReviewActions],
+        description: 'must throw'
+      })
+      expect(true).toBe(false)
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu) as sdk.WERR_REVIEW_ACTIONS
+      expect(e.code).toBe('WERR_REVIEW_ACTIONS')
+      expect(e.reviewActionResults).toBeTruthy()
+    }
+
+    await setup.wallet.destroy()
+  })
+
+  test('6 WalletClient specOpThrowReviewActions', async () => {
+    const wallet = new WalletClient(undefined, '6.specOps.man.test')
+
+    try {
+      const r = await wallet.createAction({
+        labels: [specOpThrowReviewActions],
+        description: 'must throw'
+      })
+      expect(true).toBe(false)
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu) as sdk.WERR_REVIEW_ACTIONS
+      expect(e.code).toBe('WERR_REVIEW_ACTIONS')
+      expect(e.reviewActionResults).toBeTruthy()
+    }
+  })
+})
+
+async function createSetup(chain: sdk.Chain): Promise<TestWalletNoSetup> {
+  const env = _tu.getEnv(chain)
+  const identityKey = chain === 'test' ? env.testIdentityKey : env.identityKey
+  const filePath = chain === 'test' ? env.testFilePath : env.filePath
+  if (!identityKey) throw new sdk.WERR_INVALID_PARAMETER('identityKey', 'valid for chain ' + chain)
+  if (!filePath) throw new sdk.WERR_INVALID_PARAMETER('filePath', 'valid for chain ' + chain)
+
+  const setup = await _tu.createTestWallet({
+    chain,
+    rootKeyHex: env.devKeys[identityKey],
+    filePath,
+    setActiveClient: false,
+    addLocalBackup: false,
+    useMySQLConnectionForClient: false
+  })
+
+  console.log(`ACTIVE STORAGE: ${setup.storage.getActiveStoreName()}`)
+
+  return setup
+}

package/test/Wallet/support/janitor.man.test.ts

@@ -0,0 +1,40 @@
+import { Services, StorageKnex } from '../../../src'
+import { _tu } from '../../utils/TestUtilsWalletStorage'
+
+describe('janitor tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 review utxos by identity key', async () => {
+    const env = _tu.getEnv('main')
+    if (!env.cloudMySQLConnection) return
+
+    const connection = JSON.parse(env.cloudMySQLConnection)
+    const storage = new StorageKnex({
+      ...StorageKnex.defaultOptions(),
+      knex: _tu.createMySQLFromConnection(connection),
+      chain: env.chain
+    })
+    await storage.makeAvailable()
+
+    const services = new Services(env.chain)
+
+    /*
+    const identityKey = '0304985aa632dde471d3bf1ffb030d0af253fe65f5d186bb4cf878ca0fbee54c1c'
+    const { invalidSpendableOutputs: notUtxos } = await confirmSpendableOutputs(storage, services, identityKey)
+    const outputsToUpdate = notUtxos.map(o => ({
+      id: o.outputId,
+      satoshis: o.satoshis
+    }))
+
+    const total: number = outputsToUpdate.reduce((t, o) => t + o.satoshis, 0)
+
+    debugger
+    // *** About set spendable = false for outputs ***
+    for (const o of outputsToUpdate) {
+      await storage.updateOutput(o.id, { spendable: false })
+    }
+    */
+
+    await storage.destroy()
+  })
+})