@bsv/wallet-toolbox 1.3.2 → 1.3.4

package/test/storage/idb/idbSpeed.test.ts

@@ -0,0 +1,34 @@
+import { ListActionsArgs } from '@bsv/sdk'
+import { _tu, logger } from '../../utils/TestUtilsWalletStorage'
+
+import 'fake-indexeddb/auto'
+
+describe('idbSpeed tests', () => {
+  jest.setTimeout(99999999)
+
+  const testName = () => expect.getState().currentTestName || 'test'
+
+  /**
+   * Starting speed 2025-04-18 07:58 was 66+ seconds
+   */
+  test('0 copy legacy wallet', async () => {
+    const databaseName = testName()
+    const setup = await _tu.createIdbLegacyWalletCopy(databaseName)
+    expect(setup.activeStorage).toBeTruthy()
+
+    const stats = _tu.wrapProfiling(setup.activeStorage, 'StorageIdb')
+
+    const args: ListActionsArgs = {
+      includeLabels: true,
+      labels: ['babbage_protocol_perm']
+    }
+    const r = await setup.wallet.listActions(args)
+    expect(r.actions.length).toBe(args.limit || 10)
+
+    let log = 'function,count,totalMsecs,avgMsecs\n'
+    for (const [key, value] of Object.entries(stats)) {
+      log += `${key},${value.count},${value.totalMsecs},${value.totalMsecs / value.count}\n`
+    }
+    logger(log)
+  })
+})

package/test/storage/idb/insert.test.ts

@@ -0,0 +1,268 @@
+import { _tu } from '../../utils/TestUtilsWalletStorage'
+import {
+  randomBytesBase64,
+  randomBytesHex,
+  sdk,
+  StorageProvider,
+  StorageProviderOptions,
+  TableCommission
+} from '../../../src/index.client'
+import { StorageIdb } from '../../../src/storage/StorageIdb'
+
+import 'fake-indexeddb/auto'
+import { openDB } from 'idb'
+
+describe('idb insert tests', () => {
+  jest.setTimeout(99999999)
+
+  let storages: StorageProvider[] = []
+  const chain: sdk.Chain = 'test'
+  const env = _tu.getEnv(chain)
+
+  beforeEach(async () => {
+    storages = []
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions(chain)
+    storages.push(new StorageIdb(options))
+
+    for (const storage of storages) {
+      await storage.dropAllData()
+      await storage.migrate('insert tests', '1'.repeat(64))
+    }
+  })
+
+  afterEach(async () => {
+    for (const storage of storages) {
+      await storage.destroy()
+      await new Promise(resolve => setTimeout(resolve, 0)) // Allow fake-indexeddb to clean up
+    }
+  })
+
+  test('0 insert ProvenTx', async () => {
+    for (const storage of storages) {
+      const ptx = await _tu.insertTestProvenTx(storage)
+      expect(ptx.provenTxId).toBe(1)
+      ptx.provenTxId = 0
+      // duplicate must throw
+      await expect(storage.insertProvenTx(ptx)).rejects.toThrow()
+      ptx.provenTxId = 0
+      ptx.txid = '4'.repeat(64)
+      ptx.provenTxId = await storage.insertProvenTx(ptx)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(ptx.provenTxId).toBeGreaterThan(1)
+    }
+  })
+
+  test('1 insert ProvenTxReq', async () => {
+    for (const storage of storages) {
+      const ptxreq = await _tu.insertTestProvenTxReq(storage)
+      expect(ptxreq.provenTxReqId).toBe(1)
+      ptxreq.provenTxReqId = 0
+      // duplicate must throw
+      await expect(storage.insertProvenTxReq(ptxreq)).rejects.toThrow()
+      ptxreq.provenTxReqId = 0
+      ptxreq.txid = '4'.repeat(64)
+      const id = await storage.insertProvenTxReq(ptxreq)
+      expect(id).toBe(2)
+    }
+  })
+
+  test('2 insert User', async () => {
+    for (const storage of storages) {
+      const e = await _tu.insertTestUser(storage)
+      const id = e.userId
+      expect(id).toBeGreaterThan(0)
+      e.userId = 0
+      // duplicate must throw
+      await expect(storage.insertUser(e)).rejects.toThrow()
+      e.userId = 0
+      e.identityKey = randomBytesHex(33)
+      await storage.insertUser(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.userId).toBeGreaterThan(id)
+    }
+  })
+
+  test('3 insert Certificate', async () => {
+    for (const storage of storages) {
+      const e = await _tu.insertTestCertificate(storage)
+      const id = e.certificateId
+      expect(id).toBeGreaterThan(0)
+      // duplicate must throw
+      await expect(storage.insertCertificate(e)).rejects.toThrow()
+      e.certificateId = 0
+      e.serialNumber = randomBytesBase64(33)
+      await storage.insertCertificate(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.certificateId).toBeGreaterThan(id)
+    }
+  })
+
+  test('4 insert CertificateField', async () => {
+    for (const storage of storages) {
+      const c = await _tu.insertTestCertificate(storage)
+      const e = await _tu.insertTestCertificateField(storage, c, 'prize', 'starship')
+      expect(e.certificateId).toBe(c.certificateId)
+      expect(e.userId).toBe(c.userId)
+      expect(e.fieldName).toBe('prize')
+      // duplicate must throw
+      await expect(storage.insertCertificateField(e)).rejects.toThrow()
+      e.fieldName = 'address'
+      await storage.insertCertificateField(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.fieldName).toBe('address')
+    }
+  })
+
+  test('5 insert OutputBasket', async () => {
+    for (const storage of storages) {
+      const e = await _tu.insertTestOutputBasket(storage)
+      const id = e.basketId
+      expect(id).toBeGreaterThan(0)
+      e.basketId = 0
+      // duplicate must throw
+      await expect(storage.insertOutputBasket(e)).rejects.toThrow()
+      e.basketId = 0
+      e.name = randomBytesHex(10)
+      await storage.insertOutputBasket(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.basketId).toBeGreaterThan(id)
+    }
+  })
+
+  test('6 insert Transaction', async () => {
+    for (const storage of storages) {
+      const { tx: e, user } = await _tu.insertTestTransaction(storage)
+      const id = e.transactionId
+      expect(id).toBeGreaterThan(0)
+      e.transactionId = 0
+      // duplicate must throw
+      await expect(storage.insertTransaction(e)).rejects.toThrow()
+      e.transactionId = 0
+      e.reference = randomBytesBase64(10)
+      await storage.insertTransaction(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.transactionId).toBeGreaterThan(id)
+    }
+  })
+
+  test('7 insert Commission', async () => {
+    for (const storage of storages) {
+      const { tx: t, user } = await _tu.insertTestTransaction(storage)
+      const e: TableCommission = await _tu.insertTestCommission(storage, t)
+      const id = e.commissionId
+      expect(id).toBeGreaterThan(0)
+      e.commissionId = 0
+      // duplicate must throw
+      await expect(storage.insertCommission(e)).rejects.toThrow()
+      e.commissionId = 0
+      const { tx: t2 } = await _tu.insertTestTransaction(storage)
+      e.transactionId = t2.transactionId
+      e.userId = t2.userId
+      await storage.insertCommission(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.commissionId).toBeGreaterThan(id)
+    }
+  })
+
+  test('8 insert Output', async () => {
+    for (const storage of storages) {
+      const { tx: t, user } = await _tu.insertTestTransaction(storage)
+      const e = await _tu.insertTestOutput(storage, t, 0, 101)
+      const id = e.outputId
+      expect(id).toBeGreaterThan(0)
+      expect(e.userId).toBe(t.userId)
+      expect(e.transactionId).toBe(t.transactionId)
+      expect(e.vout).toBe(0)
+      expect(e.satoshis).toBe(101)
+      e.outputId = 0
+      // duplicate must throw
+      await expect(storage.insertOutput(e)).rejects.toThrow()
+      e.vout = 1
+      await storage.insertOutput(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.outputId).toBeGreaterThan(id)
+    }
+  })
+
+  test('9 insert OutputTag', async () => {
+    for (const storage of storages) {
+      const u = await _tu.insertTestUser(storage)
+      const e = await _tu.insertTestOutputTag(storage, u)
+      const id = e.outputTagId
+      expect(id).toBeGreaterThan(0)
+      expect(e.userId).toBe(u.userId)
+      expect(e.tag).toBeTruthy()
+      e.outputTagId = 0
+      // duplicate must throw
+      await expect(storage.insertOutputTag(e)).rejects.toThrow()
+      e.tag = randomBytesHex(6)
+      await storage.insertOutputTag(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.outputTagId).toBeGreaterThan(id)
+    }
+  })
+
+  test('10 insert OutputTagMap', async () => {
+    for (const storage of storages) {
+      const { tx, user } = await _tu.insertTestTransaction(storage)
+      const o = await _tu.insertTestOutput(storage, tx, 0, 101)
+      const tag = await _tu.insertTestOutputTag(storage, user)
+      const e = await _tu.insertTestOutputTagMap(storage, o, tag)
+      expect(e.outputId).toBe(o.outputId)
+      expect(e.outputTagId).toBe(tag.outputTagId)
+      // duplicate must throw
+      await expect(storage.insertOutputTagMap(e)).rejects.toThrow()
+      const tag2 = await _tu.insertTestOutputTag(storage, user)
+      const e2 = await _tu.insertTestOutputTagMap(storage, o, tag2)
+    }
+  })
+
+  test('11 insert TxLabel', async () => {
+    for (const storage of storages) {
+      const u = await _tu.insertTestUser(storage)
+      const e = await _tu.insertTestTxLabel(storage, u)
+      const id = e.txLabelId
+      expect(id).toBeGreaterThan(0)
+      expect(e.userId).toBe(u.userId)
+      expect(e.label).toBeTruthy()
+      e.txLabelId = 0
+      // duplicate must throw
+      await expect(storage.insertTxLabel(e)).rejects.toThrow()
+      e.label = randomBytesHex(6)
+      await storage.insertTxLabel(e)
+      // MySQL counts the failed insertion as a used id, SQLite does not.
+      expect(e.txLabelId).toBeGreaterThan(id)
+    }
+  })
+
+  test('12 insert TxLabelMap', async () => {
+    for (const storage of storages) {
+      const { tx, user } = await _tu.insertTestTransaction(storage)
+      const label = await _tu.insertTestTxLabel(storage, user)
+      const e = await _tu.insertTestTxLabelMap(storage, tx, label)
+      expect(e.transactionId).toBe(tx.transactionId)
+      expect(e.txLabelId).toBe(label.txLabelId)
+      // duplicate must throw
+      await expect(storage.insertTxLabelMap(e)).rejects.toThrow()
+      const label2 = await _tu.insertTestTxLabel(storage, user)
+      const e2 = await _tu.insertTestTxLabelMap(storage, tx, label2)
+    }
+  })
+
+  test('13 insert MonitorEvent', async () => {
+    for (const storage of storages) {
+      const e = await _tu.insertTestMonitorEvent(storage)
+      const id = e.id
+      expect(id).toBeGreaterThan(0)
+    }
+  })
+
+  test('14 insert SyncState', async () => {
+    for (const storage of storages) {
+      const u = await _tu.insertTestUser(storage)
+      const e = await _tu.insertTestSyncState(storage, u)
+      const id = e.syncStateId
+      expect(id).toBeGreaterThan(0)
+    }
+  })
+})

package/test/storage/idb/transactionAbort.test.ts

@@ -0,0 +1,108 @@
+import { _tu, logger } from '../../utils/TestUtilsWalletStorage'
+import {
+  randomBytesBase64,
+  randomBytesHex,
+  sdk,
+  StorageProvider,
+  StorageProviderOptions,
+  TableCommission
+} 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)
+
+  let storages: StorageProvider[] = []
+  const chain: sdk.Chain = 'test'
+  const env = _tu.getEnv(chain)
+
+  beforeEach(async () => {
+    storages = []
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions(chain)
+    storages.push(new StorageIdb(options))
+
+    for (const storage of storages) {
+      await storage.dropAllData()
+      await storage.migrate('insert tests', '1'.repeat(64))
+    }
+  })
+
+  afterEach(async () => {
+    for (const storage of storages) {
+      await storage.destroy()
+      await new Promise(resolve => setTimeout(resolve, 0)) // Allow fake-indexeddb to clean up
+    }
+  })
+
+  test('0 unaborted case', async () => {
+    for (const storage of storages) {
+      let aborted = false
+      let count = await storage.countProvenTxs({ partial: {} })
+      expect(count).toBe(0)
+      try {
+        const r = await storage.transaction(async tx => {
+          const r12 = await _tu.insertTestProvenTx(storage, '12'.repeat(32), tx)
+          const r23 = await _tu.insertTestProvenTx(storage, '23'.repeat(32), tx)
+          //tx['abort']()
+          return [r12.provenTxId, r23.provenTxId]
+        })
+        expect(r).toEqual([1, 2])
+      } catch (e) {
+        aborted = true
+        logger('Transaction aborted', e?.['name'])
+      }
+      expect(aborted).toBe(false)
+      count = await storage.countProvenTxs({ partial: {} })
+      expect(count).toBe(2)
+    }
+  })
+
+  test('1 call abort case', async () => {
+    for (const storage of storages) {
+      let aborted = false
+      let count = await storage.countProvenTxs({ partial: {} })
+      expect(count).toBe(0)
+      try {
+        const r = await storage.transaction(async tx => {
+          const r12 = await _tu.insertTestProvenTx(storage, '12'.repeat(32), tx)
+          const r23 = await _tu.insertTestProvenTx(storage, '23'.repeat(32), tx)
+          tx['abort']()
+          return [r12.provenTxId, r23.provenTxId]
+        })
+        expect(r).toEqual([1, 2])
+      } catch (e) {
+        aborted = true
+        logger('Transaction aborted', e?.['name'])
+      }
+      expect(aborted).toBe(true)
+      count = await storage.countProvenTxs({ partial: {} })
+      expect(count).toBe(0)
+    }
+  })
+
+  test('2 throw error case', async () => {
+    for (const storage of storages) {
+      let aborted = false
+      let count = await storage.countProvenTxs({ partial: {} })
+      expect(count).toBe(0)
+      try {
+        const r = await storage.transaction(async tx => {
+          const r12 = await _tu.insertTestProvenTx(storage, '12'.repeat(32), tx)
+          const r23 = await _tu.insertTestProvenTx(storage, '23'.repeat(32), tx)
+          throw new Error('Test error')
+          return [r12.provenTxId, r23.provenTxId]
+        })
+        expect(r).toEqual([1, 2])
+      } catch (e) {
+        aborted = true
+        logger('Transaction aborted', e?.['name'])
+      }
+      expect(aborted).toBe(true)
+      count = await storage.countProvenTxs({ partial: {} })
+      expect(count).toBe(0)
+    }
+  })
+})