@bopen-io/wallet-toolbox 1.7.18

package/test/storage/find.test.ts

@@ -0,0 +1,195 @@
+import { _tu, TestSetup1 } from '../utils/TestUtilsWalletStorage'
+import { sdk, StorageProvider } from '../../src/index.client'
+import { StorageKnex } from '../../src/storage/StorageKnex'
+
+describe('find tests', () => {
+  jest.setTimeout(99999999)
+
+  const storages: StorageProvider[] = []
+  const chain: sdk.Chain = 'test'
+  const setups: { setup: TestSetup1; storage: StorageProvider }[] = []
+  const env = _tu.getEnv(chain)
+
+  beforeAll(async () => {
+    const localSQLiteFile = await _tu.newTmpFile('storagefindtest.sqlite', false, false, true)
+    const knexSQLite = _tu.createLocalSQLite(localSQLiteFile)
+    storages.push(
+      new StorageKnex({
+        ...StorageKnex.defaultOptions(),
+        chain,
+        knex: knexSQLite
+      })
+    )
+
+    if (env.runMySQL) {
+      const knexMySQL = _tu.createLocalMySQL('storagefindtest')
+      storages.push(
+        new StorageKnex({
+          ...StorageKnex.defaultOptions(),
+          chain,
+          knex: knexMySQL
+        })
+      )
+    }
+
+    for (const storage of storages) {
+      await storage.dropAllData()
+      await storage.migrate('find tests', '1'.repeat(64))
+      await storage.makeAvailable()
+      setups.push({ storage, setup: await _tu.createTestSetup1(storage) })
+    }
+  })
+
+  afterAll(async () => {
+    for (const storage of storages) {
+      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)
+    }
+  })
+})

package/test/storage/findLegacy.test.ts

@@ -0,0 +1,67 @@
+import { _tu, TestWalletNoSetup } from '../utils/TestUtilsWalletStorage'
+
+describe('find tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('storagefindLegacytest'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('storagefindLegacytest'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0 find ProvenTx', async () => {
+    for (const { storage } of ctxs) {
+    }
+  })
+
+  test('1 find ProvenTxReq', async () => {
+    for (const { storage } of ctxs) {
+    }
+  })
+
+  test('2 find User', async () => {})
+
+  test('3 find Certificate', async () => {})
+
+  test('4 find CertificateField', async () => {})
+
+  test('5 find OutputBasket', async () => {})
+
+  test('6 find Transaction', async () => {})
+
+  test('7 find Commission', async () => {})
+
+  test('8 find Output', async () => {
+    for (const { storage } of ctxs) {
+      {
+        const r = await storage.findOutputs({
+          partial: { userId: 1, basketId: 1 },
+          txStatus: ['sending']
+        })
+        expect(r.length).toBe(1)
+        expect(r[0].txid).toBe('a3a8fe7f541c1383ff7b975af49b27284ae720af5f2705d8409baaf519190d26')
+        expect(r[0].vout).toBe(2)
+      }
+    }
+  })
+
+  test('9 find OutputTag', async () => {})
+
+  test('10 find OutputTagMap', async () => {})
+
+  test('11 find TxLabel', async () => {})
+
+  test('12 find TxLabelMap', async () => {})
+
+  test('13 find MonitorEvent', async () => {})
+
+  test('14 find SyncState', async () => {})
+})

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)
+    }
+  })
+})