@bsv/wallet-toolbox 1.3.2 → 1.3.4

package/test/Wallet/support/{opers1.man.test.ts → operations.man.test.ts}

@@ -1,15 +1,8 @@
 import { WalletOutput } from '@bsv/sdk'
 import { sdk, Services, Setup, StorageKnex, TableOutput, TableUser, verifyOne, verifyOneOrNone } from '../../../src'
 import { _tu, TuEnv } from '../../utils/TestUtilsWalletStorage'
-import { specOpInvalidChange, ValidListOutputsArgs, WERR_REVIEW_ACTIONS } from '../../../src/sdk'
-import {
-  burnOneSatTestOutput,
-  createOneSatTestOutput,
-  createSetup,
-  doubleSpendOldChange,
-  LocalWalletTestOptions,
-  recoverOneSatTestOutputs
-} from '../../utils/localWalletMethods'
+import { specOpInvalidChange, ValidListOutputsArgs } from '../../../src/sdk'
+import { LocalWalletTestOptions } from '../../utils/localWalletMethods'
 
 import * as dotenv from 'dotenv'
 dotenv.config()
@@ -23,7 +16,7 @@ const options: LocalWalletTestOptions = {
   useIdentityKey2: false
 }
 
-describe('operations1 tests', () => {
+describe('operations.man tests', () => {
   jest.setTimeout(99999999)
 
   test('0 review and release all production invalid change utxos', async () => {
@@ -62,9 +55,45 @@ describe('operations1 tests', () => {
     await storage.destroy()
   })
 
-  test('6 review and unfail false doubleSpends', async () => {
+  test.skip('0a review all spendable outputs for userId', async () => {
+    const { env, storage } = await createMainReviewSetup()
+    const users = await storage.findUsers({ partial: {} })
+    const withInvalid: Record<number, { user: TableUser; outputs: WalletOutput[]; total: number }> = {}
+    const vargs: ValidListOutputsArgs = {
+      basket: specOpInvalidChange,
+      tags: ['release', 'all'],
+      tagQueryMode: 'all',
+      includeLockingScripts: false,
+      includeTransactions: false,
+      includeCustomInstructions: false,
+      includeTags: false,
+      includeLabels: false,
+      limit: 0,
+      offset: 0,
+      seekPermission: false,
+      knownTxids: []
+    }
+    let log = ''
+    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)
+        log += `userId ${userId}: ${r.totalOutputs} unspendable utxos, total ${total}, ${user.identityKey}\n`
+        for (const o of r.outputs) {
+          log += `  ${o.outpoint} ${o.satoshis}\n`
+        }
+        withInvalid[userId] = { user, outputs: r.outputs, total }
+      }
+    }
+    console.log(log || 'Found zero invalid change outputs.')
+    await storage.destroy()
+  })
+
+  test('1 review and unfail false doubleSpends', async () => {
     const { env, storage, services } = await createMainReviewSetup()
-    let offset = 2200
+    let offset = 2400
     const limit = 100
     let allUnfails: number[] = []
     for (;;) {
@@ -89,9 +118,9 @@ describe('operations1 tests', () => {
     await storage.destroy()
   })
 
-  test('7 review and unfail false invalids', async () => {
+  test('2 review and unfail false invalids', async () => {
     const { env, storage, services } = await createMainReviewSetup()
-    let offset = 500
+    let offset = 600
     const limit = 100
     let allUnfails: number[] = []
     for (;;) {

package/test/storage/find.test.ts

@@ -34,7 +34,7 @@ describe('find tests', () => {
 
     for (const storage of storages) {
       await storage.dropAllData()
-      await storage.migrate('insert tests', '1'.repeat(64))
+      await storage.migrate('find tests', '1'.repeat(64))
       await storage.makeAvailable()
       setups.push({ storage, setup: await _tu.createTestSetup1(storage) })
     }

package/test/storage/idb/allocateChange.test.ts

@@ -0,0 +1,251 @@
+import { _tu, logger, TestSetup1 } from '../../utils/TestUtilsWalletStorage'
+import {
+  randomBytesBase64,
+  randomBytesHex,
+  sdk,
+  StorageProvider,
+  StorageProviderOptions,
+  TableCommission,
+  TableOutput,
+  TableTransaction
+} from '../../../src/index.client'
+import { StorageIdb } from '../../../src/storage/StorageIdb'
+
+import 'fake-indexeddb/auto'
+import { openDB } from 'idb'
+
+describe('idb transactionAbort tests', () => {
+  jest.setTimeout(99999999)
+
+  const chain: sdk.Chain = 'test'
+  const env = _tu.getEnv(chain)
+  let setups: { setup: TestSetup2; storage: StorageProvider }[] = []
+
+  beforeEach(async () => {
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions(chain)
+    const storage = new StorageIdb(options)
+    await storage.dropAllData()
+    await storage.migrate('idb find tests', '1'.repeat(64))
+    await storage.makeAvailable()
+    const setup1 = await _tu.createTestSetup1(storage)
+    const u1tx2 = (await _tu.insertTestTransaction(storage, setup1.u1, false, { status: 'completed' })).tx
+    const setup2: TestSetup2 = {
+      ...setup1,
+      u1tx2,
+      u1tx2o0: await _tu.insertTestOutput(storage, u1tx2, 0, 3, setup1.u1basket1),
+      u1tx2o1: await _tu.insertTestOutput(storage, u1tx2, 1, 13, setup1.u1basket1),
+      u1tx2o2: await _tu.insertTestOutput(storage, u1tx2, 2, 113, setup1.u1basket1),
+      u1tx2o3: await _tu.insertTestOutput(storage, u1tx2, 3, 1113, setup1.u1basket1),
+      u1tx2o4: await _tu.insertTestOutput(storage, u1tx2, 4, 11113, setup1.u1basket1),
+      u1tx2o5: await _tu.insertTestOutput(storage, u1tx2, 5, 111113, setup1.u1basket1),
+      u1tx2o6: await _tu.insertTestOutput(storage, u1tx2, 6, 1111113, setup1.u1basket1),
+      u1tx2o7: await _tu.insertTestOutput(storage, u1tx2, 7, 11111113, setup1.u1basket1),
+      u1tx2o8: await _tu.insertTestOutput(storage, u1tx2, 8, 111111113, setup1.u1basket1),
+      u1tx3: (await _tu.insertTestTransaction(storage, setup1.u1, false, { status: 'completed' })).tx,
+      u1tx4: (await _tu.insertTestTransaction(storage, setup1.u1, false, { status: 'unproven' })).tx,
+      u1tx5: (await _tu.insertTestTransaction(storage, setup1.u1, false, { status: 'sending' })).tx
+    }
+    setups = [{ setup: setup2, storage }]
+  })
+
+  afterEach(async () => {
+    for (const { storage } of setups) {
+      await storage.destroy()
+    }
+  })
+
+  test('0 basket with no outputs', async () => {
+    for (const { storage, setup } of setups) {
+      const r = await storage.allocateChangeInput(setup.u1.userId, 42, 11113, 11113, true, setup.u1tx3.transactionId)
+      expect(r).toBeUndefined()
+    }
+  })
+
+  test('1 exactSatoshis', async () => {
+    for (const { storage, setup } of setups) {
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        11113,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o4.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        11113,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o5.outputId)
+    }
+  })
+
+  test('2 targetSatoshis exact', async () => {
+    for (const { storage, setup } of setups) {
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o4.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o5.outputId)
+    }
+  })
+
+  test('2a targetSatoshis exact unproven', async () => {
+    for (const { storage, setup } of setups) {
+      await storage.updateTransaction(setup.u1tx2.transactionId, { status: 'unproven' })
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o4.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o5.outputId)
+    }
+  })
+
+  test('2b targetSatoshis exact sending', async () => {
+    for (const { storage, setup } of setups) {
+      await storage.updateTransaction(setup.u1tx2.transactionId, { status: 'sending' })
+      const r3 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r3).toBeUndefined()
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        false,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o4.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11113,
+        undefined,
+        false,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o5.outputId)
+    }
+  })
+
+  test('3 targetSatoshis high', async () => {
+    for (const { storage, setup } of setups) {
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11114,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o5.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11114,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o6.outputId)
+    }
+  })
+
+  test('4 targetSatoshis low', async () => {
+    for (const { storage, setup } of setups) {
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11112,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o4.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        11112,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o5.outputId)
+    }
+  })
+
+  test('5 targetSatoshis above max', async () => {
+    for (const { storage, setup } of setups) {
+      const r = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        111111114,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r?.outputId).toBe(setup.u1tx2o8.outputId)
+      const r2 = await storage.allocateChangeInput(
+        setup.u1.userId,
+        setup.u1basket1.basketId,
+        111111114,
+        undefined,
+        true,
+        setup.u1tx3.transactionId
+      )
+      expect(r2?.outputId).toBe(setup.u1tx2o7.outputId)
+    }
+  })
+})
+
+interface TestSetup2 extends TestSetup1 {
+  u1tx2: TableTransaction
+  u1tx2o0: TableOutput
+  u1tx2o1: TableOutput
+  u1tx2o2: TableOutput
+  u1tx2o3: TableOutput
+  u1tx2o4: TableOutput
+  u1tx2o5: TableOutput
+  u1tx2o6: TableOutput
+  u1tx2o7: TableOutput
+  u1tx2o8: TableOutput
+  u1tx3: TableTransaction
+  u1tx4: TableTransaction
+  u1tx5: TableTransaction
+}

package/test/storage/idb/count.test.ts

@@ -0,0 +1,158 @@
+import { _tu, TestSetup1 } from '../../utils/TestUtilsWalletStorage'
+import { sdk, StorageProvider, StorageProviderOptions } from '../../../src/index.client'
+import { StorageIdb } from '../../../src/storage/StorageIdb'
+
+import 'fake-indexeddb/auto'
+
+describe('idb count tests', () => {
+  jest.setTimeout(99999999)
+
+  const chain: sdk.Chain = 'test'
+  const env = _tu.getEnv(chain)
+  let setups: { setup: TestSetup1; storage: StorageProvider }[] = []
+
+  beforeEach(async () => {
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions(chain)
+    const storage = new StorageIdb(options)
+    await storage.dropAllData()
+    await storage.migrate('idb find tests', '1'.repeat(64))
+    await storage.makeAvailable()
+    const setup = await _tu.createTestSetup1(storage)
+    setups = [{ setup, storage }]
+  })
+
+  afterEach(async () => {
+    for (const { storage } of setups) {
+      await storage.destroy()
+    }
+  })
+
+  test('0 count ProvenTx', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countProvenTxs({ partial: {} })).toBe(1)
+    }
+  })
+
+  test('1 count ProvenTxReq', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countProvenTxReqs({ partial: {} })).toBe(2)
+    }
+  })
+
+  test('2 count User', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countUsers({ partial: {} })).toBe(2)
+    }
+  })
+
+  test('3 count Certificate', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countCertificates({ partial: {} })).toBe(3)
+      expect(
+        await storage.countCertificates({
+          partial: {},
+          certifiers: [setup.u1cert1.certifier]
+        })
+      ).toBe(1)
+      expect(await storage.countCertificates({ partial: {}, certifiers: ['none'] })).toBe(0)
+      expect(
+        await storage.countCertificates({
+          partial: {},
+          types: [setup.u1cert2.type]
+        })
+      ).toBe(1)
+      expect(await storage.countCertificates({ partial: {}, types: ['oblongata'] })).toBe(0)
+    }
+  })
+
+  test('4 count CertificateField', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countCertificateFields({ partial: {} })).toBe(3)
+      expect(
+        await storage.countCertificateFields({
+          partial: { userId: setup.u1.userId }
+        })
+      ).toBe(3)
+      expect(
+        await storage.countCertificateFields({
+          partial: { userId: setup.u2.userId }
+        })
+      ).toBe(0)
+      expect(await storage.countCertificateFields({ partial: { userId: 99 } })).toBe(0)
+      expect(await storage.countCertificateFields({ partial: { fieldName: 'name' } })).toBe(2)
+      expect(await storage.countCertificateFields({ partial: { fieldName: 'bob' } })).toBe(1)
+      expect(
+        await storage.countCertificateFields({
+          partial: { fieldName: 'bob42' }
+        })
+      ).toBe(0)
+    }
+  })
+
+  test('5 count OutputBasket', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countOutputBaskets({ partial: {} })).toBe(3)
+      expect(
+        await storage.countOutputBaskets({
+          partial: {},
+          since: setup.u1.created_at
+        })
+      ).toBe(3)
+      expect(await storage.countOutputBaskets({ partial: {}, since: new Date() })).toBe(0)
+    }
+  })
+
+  test('6 count Transaction', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countTransactions({ partial: {} })).toBe(3)
+    }
+  })
+
+  test('7 count Commission', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countCommissions({ partial: {} })).toBe(3)
+    }
+  })
+
+  test('8 count Output', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countOutputs({ partial: {} })).toBe(3)
+    }
+  })
+
+  test('9 count OutputTag', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countOutputTags({ partial: {} })).toBe(2)
+    }
+  })
+
+  test('10 count OutputTagMap', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countOutputTagMaps({ partial: {} })).toBe(3)
+    }
+  })
+
+  test('11 count TxLabel', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countTxLabels({ partial: {} })).toBe(3)
+    }
+  })
+
+  test('12 count TxLabelMap', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countTxLabelMaps({ partial: {} })).toBe(3)
+    }
+  })
+
+  test('13 count MonitorEvent', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countMonitorEvents({ partial: {} })).toBe(1)
+    }
+  })
+
+  test('14 count SyncState', async () => {
+    for (const { storage, setup } of setups) {
+      expect(await storage.countSyncStates({ partial: {} })).toBe(1)
+    }
+  })
+})

package/test/storage/idb/find.test.ts

@@ -0,0 +1,177 @@
+import { _tu, TestSetup1 } from '../../utils/TestUtilsWalletStorage'
+import { sdk, StorageProvider, StorageProviderOptions } from '../../../src/index.client'
+
+import { StorageIdb } from '../../../src/storage/StorageIdb'
+
+import 'fake-indexeddb/auto'
+
+describe('idb find tests', () => {
+  jest.setTimeout(99999999)
+
+  const chain: sdk.Chain = 'test'
+  const env = _tu.getEnv(chain)
+  let setups: { setup: TestSetup1; storage: StorageProvider }[] = []
+
+  beforeEach(async () => {
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions(chain)
+    const storage = new StorageIdb(options)
+    await storage.dropAllData()
+    await storage.migrate('idb find tests', '1'.repeat(64))
+    await storage.makeAvailable()
+    const setup = await _tu.createTestSetup1(storage)
+    setups = [{ setup, storage }]
+  })
+
+  afterEach(async () => {
+    for (const { storage } of setups) {
+      await storage.destroy()
+    }
+  })
+
+  test('0 find ProvenTx', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findProvenTxs({ partial: {} })).length).toBe(1)
+    }
+  })
+
+  test('1 find ProvenTxReq', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findProvenTxReqs({ partial: {} })).length).toBe(2)
+    }
+  })
+
+  test('2 find User', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findUsers({ partial: {} })).length).toBe(2)
+    }
+  })
+
+  test('3 find Certificate', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findCertificates({ partial: {} })).length).toBe(3)
+      expect(
+        (
+          await storage.findCertificates({
+            partial: {},
+            certifiers: [setup.u1cert1.certifier]
+          })
+        ).length
+      ).toBe(1)
+      expect((await storage.findCertificates({ partial: {}, certifiers: ['none'] })).length).toBe(0)
+      expect(
+        (
+          await storage.findCertificates({
+            partial: {},
+            types: [setup.u1cert2.type]
+          })
+        ).length
+      ).toBe(1)
+      expect((await storage.findCertificates({ partial: {}, types: ['oblongata'] })).length).toBe(0)
+    }
+  })
+
+  test('4 find CertificateField', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findCertificateFields({ partial: {} })).length).toBe(3)
+      expect(
+        (
+          await storage.findCertificateFields({
+            partial: { userId: setup.u1.userId }
+          })
+        ).length
+      ).toBe(3)
+      expect(
+        (
+          await storage.findCertificateFields({
+            partial: { userId: setup.u2.userId }
+          })
+        ).length
+      ).toBe(0)
+      expect((await storage.findCertificateFields({ partial: { userId: 99 } })).length).toBe(0)
+      expect(
+        (
+          await storage.findCertificateFields({
+            partial: { fieldName: 'name' }
+          })
+        ).length
+      ).toBe(2)
+      expect((await storage.findCertificateFields({ partial: { fieldName: 'bob' } })).length).toBe(1)
+      expect(
+        (
+          await storage.findCertificateFields({
+            partial: { fieldName: 'bob42' }
+          })
+        ).length
+      ).toBe(0)
+    }
+  })
+
+  test('5 find OutputBasket', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findOutputBaskets({ partial: {} })).length).toBe(3)
+      expect(
+        (
+          await storage.findOutputBaskets({
+            partial: {},
+            since: setup.u1.created_at
+          })
+        ).length
+      ).toBe(3)
+      expect((await storage.findOutputBaskets({ partial: {}, since: new Date() })).length).toBe(0)
+    }
+  })
+
+  test('6 find Transaction', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findTransactions({ partial: {} })).length).toBe(3)
+    }
+  })
+
+  test('7 find Commission', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findCommissions({ partial: {} })).length).toBe(3)
+    }
+  })
+
+  test('8 find Output', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findOutputs({ partial: {} })).length).toBe(3)
+    }
+  })
+
+  test('9 find OutputTag', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findOutputTags({ partial: {} })).length).toBe(2)
+    }
+  })
+
+  test('10 find OutputTagMap', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findOutputTagMaps({ partial: {} })).length).toBe(3)
+    }
+  })
+
+  test('11 find TxLabel', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findTxLabels({ partial: {} })).length).toBe(3)
+    }
+  })
+
+  test('12 find TxLabelMap', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findTxLabelMaps({ partial: {} })).length).toBe(3)
+    }
+  })
+
+  test('13 find MonitorEvent', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findMonitorEvents({ partial: {} })).length).toBe(1)
+    }
+  })
+
+  test('14 find SyncState', async () => {
+    for (const { storage, setup } of setups) {
+      expect((await storage.findSyncStates({ partial: {} })).length).toBe(1)
+    }
+  })
+})