@bsv/wallet-toolbox 1.3.2 → 1.3.4

package/test/storage/update.test.ts

@@ -21,7 +21,7 @@ import {
 
 setLogging(false)
 
-describe('update tests', () => {
+describe('idb update tests', () => {
   jest.setTimeout(99999999)
 
   const chain: sdk.Chain = 'test'
@@ -57,7 +57,7 @@ describe('update tests', () => {
     }
     for (const storage of storages) {
       await storage.dropAllData()
-      await storage.migrate('insert tests', '1'.repeat(64))
+      await storage.migrate('update tests', '1'.repeat(64))
       await storage.makeAvailable()
       setups.push({ storage, setup: await _tu.createTestSetup1(storage) })
     }

package/test/utils/TestUtilsWalletStorage.ts

@@ -58,7 +58,8 @@ import {
 import { Knex, knex as makeKnex } from 'knex'
 
 import * as dotenv from 'dotenv'
-import { WalletServicesOptions } from '../../src/sdk'
+import { TrxToken, WalletServicesOptions } from '../../src/sdk'
+import { StorageIdb } from '../../src/storage/StorageIdb'
 dotenv.config()
 
 const localMySqlConnection = process.env.MYSQL_CONNECTION || ''
@@ -830,6 +831,170 @@ export abstract class TestUtilsWalletStorage {
     return r
   }
 
+  static wrapProfiling(o: Object, name: string): Record<string, { count: number; totalMsecs: number }> {
+    const getFunctionsNames = (obj: Object) => {
+      let fNames: string[] = []
+      do {
+        fNames = fNames.concat(
+          Object.getOwnPropertyNames(obj).filter(p => p !== 'constructor' && typeof obj[p] === 'function')
+        )
+      } while ((obj = Object.getPrototypeOf(obj)) && obj !== Object.prototype)
+
+      return fNames
+    }
+
+    const notifyPerformance = (fn, performanceDetails) => {
+      setTimeout(() => {
+        let { functionName, args, startTime, endTime } = performanceDetails
+        let _args = args
+        if (Array.isArray(args)) {
+          _args = args.map(arg => {
+            if (typeof arg === 'function') {
+              let fName = arg.name
+              if (!fName) {
+                fName = 'function'
+              } else if (fName === 'callbackWrapper') {
+                fName = 'callback'
+              }
+              arg = `[${fName} Function]`
+            }
+            return arg
+          })
+        }
+        fn({ functionName, args: _args, startTime, endTime })
+      }, 0)
+    }
+
+    const stats: Record<string, { count: number; totalMsecs: number }> = {}
+
+    function logger(args: { functionName: string; args: any; startTime: number; endTime: number }) {
+      let s = stats[args.functionName]
+      if (!s) {
+        s = { count: 0, totalMsecs: 0 }
+        stats[args.functionName] = s
+      }
+      s.count++
+      s.totalMsecs += args.endTime - args.startTime
+    }
+
+    const performanceWrapper = (obj: Object, objectName: string, performanceNotificationCallback: any) => {
+      let _notifyPerformance = notifyPerformance.bind(null, performanceNotificationCallback)
+      let fNames = getFunctionsNames(obj)
+      for (let fName of fNames) {
+        let originalFunction = obj[fName]
+        let wrapperFunction = (...args) => {
+          let callbackFnIndex = -1
+          let startTime = Date.now()
+          let _callBack = args.filter((arg, i) => {
+            let _isFunction = typeof arg === 'function'
+            if (_isFunction) {
+              callbackFnIndex = i
+            }
+            return _isFunction
+          })[0]
+          if (_callBack) {
+            let callbackWrapper = (...callbackArgs) => {
+              let endTime = Date.now()
+              _notifyPerformance({ functionName: `${objectName}.${fName}`, args, startTime, endTime })
+              _callBack.apply(null, callbackArgs)
+            }
+            args[callbackFnIndex] = callbackWrapper
+          }
+          let originalReturnObject = originalFunction.apply(obj, args)
+          let isPromiseType =
+            originalReturnObject &&
+            typeof originalReturnObject.then === 'function' &&
+            typeof originalReturnObject.catch === 'function'
+          if (isPromiseType) {
+            return originalReturnObject
+              .then(resolveArgs => {
+                let endTime = Date.now()
+                _notifyPerformance({ functionName: `${objectName}.${fName}`, args, startTime, endTime })
+                return Promise.resolve(resolveArgs)
+              })
+              .catch((...rejectArgs) => {
+                let endTime = Date.now()
+                _notifyPerformance({ functionName: `${objectName}.${fName}`, args, startTime, endTime })
+                return Promise.reject(...rejectArgs)
+              })
+          }
+          if (!_callBack && !isPromiseType) {
+            let endTime = Date.now()
+            _notifyPerformance({ functionName: `${objectName}.${fName}`, args, startTime, endTime })
+          }
+          return originalReturnObject
+        }
+        obj[fName] = wrapperFunction
+      }
+
+      return obj
+    }
+
+    const functionNames = getFunctionsNames(o)
+
+    performanceWrapper(o, name, logger)
+
+    return stats
+  }
+
+  static async createIdbLegacyWalletCopy(databaseName: string): Promise<TestWalletProviderNoSetup> {
+    const chain: sdk.Chain = 'test'
+
+    const readerFile = await _tu.existingDataFile(`walletLegacyTestData.sqlite`)
+    const readerKnex = _tu.createLocalSQLite(readerFile)
+    const reader = new StorageKnex({
+      chain,
+      knex: readerKnex,
+      commissionSatoshis: 0,
+      commissionPubKeyHex: undefined,
+      feeModel: { model: 'sat/kb', value: 1 }
+    })
+    await reader.makeAvailable()
+
+    const rootKeyHex = _tu.legacyRootKeyHex
+    const identityKey = '03ac2d10bdb0023f4145cc2eba2fcd2ad3070cb2107b0b48170c46a9440e4cc3fe'
+    const rootKey = PrivateKey.fromHex(rootKeyHex)
+    const keyDeriver = new KeyDeriver(rootKey)
+
+    const activeStorage = new StorageIdb({
+      chain,
+      commissionSatoshis: 0,
+      commissionPubKeyHex: undefined,
+      feeModel: { model: 'sat/kb', value: 1 }
+    })
+
+    await activeStorage.dropAllData()
+    await activeStorage.migrate(databaseName, randomBytesHex(33))
+    await activeStorage.makeAvailable()
+
+    const storage = new WalletStorageManager(identityKey, activeStorage)
+    await storage.makeAvailable()
+
+    await storage.syncFromReader(identityKey, new StorageSyncReader({ identityKey }, reader))
+
+    await reader.destroy()
+
+    const services = new Services(chain)
+    const monopts = Monitor.createDefaultWalletMonitorOptions(chain, storage, services)
+    const monitor = new Monitor(monopts)
+    const wallet = new Wallet({ chain, keyDeriver, storage, services, monitor })
+    const userId = verifyTruthy(await activeStorage.findUserByIdentityKey(identityKey)).userId
+    const r: TestWalletProvider<{}> = {
+      rootKey,
+      identityKey,
+      keyDeriver,
+      chain,
+      activeStorage,
+      storage,
+      setup: {},
+      services,
+      monitor,
+      wallet,
+      userId
+    }
+    return r
+  }
+
   static makeSampleCert(subject?: string): {
     cert: WalletCertificate
     subject: string
@@ -854,7 +1019,7 @@ export abstract class TestUtilsWalletStorage {
     return { cert, subject, certifier }
   }
 
-  static async insertTestProvenTx(storage: StorageProvider, txid?: string) {
+  static async insertTestProvenTx(storage: StorageProvider, txid?: string, trx?: TrxToken) {
     const now = new Date()
     const ptx: TableProvenTx = {
       created_at: now,
@@ -868,7 +1033,7 @@ export abstract class TestUtilsWalletStorage {
       blockHash: randomBytesHex(32),
       merkleRoot: randomBytesHex(32)
     }
-    await storage.insertProvenTx(ptx)
+    await storage.insertProvenTx(ptx, trx)
     return ptx
   }
 
@@ -1038,7 +1203,7 @@ export abstract class TestUtilsWalletStorage {
       senderIdentityKey: requiredOnly ? undefined : randomBytesHex(32),
       derivationPrefix: requiredOnly ? undefined : randomBytesHex(16),
       derivationSuffix: requiredOnly ? undefined : randomBytesHex(16),
-      spentBy: undefined, // must be a valid transsactionId
+      spentBy: undefined, // must be a valid transactionId
       sequenceNumber: requiredOnly ? undefined : 42,
       spendingDescription: requiredOnly ? undefined : randomBytesHex(16),
       scriptLength: requiredOnly ? undefined : 36,
@@ -1640,6 +1805,24 @@ export interface MockData {
 
 export interface TestSetup2 extends MockData {}
 
+export interface TestWalletProvider<T> extends TestWalletOnly {
+  activeStorage: StorageProvider
+  setup?: T
+  userId: number
+
+  rootKey: PrivateKey
+  identityKey: string
+  keyDeriver: KeyDeriver
+  chain: sdk.Chain
+  storage: WalletStorageManager
+  services: Services
+  monitor: Monitor
+  wallet: Wallet
+  localStorageIdentityKey?: string
+  clientStorageIdentityKey?: string
+  localBackupStorageIdentityKey?: string
+}
+
 export interface TestWallet<T> extends TestWalletOnly {
   activeStorage: StorageKnex
   setup?: T
@@ -1676,6 +1859,7 @@ async function insertEmptySetup(storage: StorageKnex, identityKey: string): Prom
 export type TestSetup2Wallet = TestWallet<TestSetup2>
 export type TestSetup1Wallet = TestWallet<TestSetup1>
 export type TestWalletNoSetup = TestWallet<{}>
+export type TestWalletProviderNoSetup = TestWalletProvider<{}>
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function expectToThrowWERR<R>(

package/test/wallet/list/listActions.test.ts

@@ -1,6 +1,15 @@
 import { ListActionsArgs } from '@bsv/sdk'
 import { sdk, StorageProvider } from '../../../src/index.client'
-import { _tu, expectToThrowWERR, TestSetup1, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+import {
+  _tu,
+  expectToThrowWERR,
+  TestSetup1,
+  TestWalletNoSetup,
+  TestWalletProviderNoSetup
+} from '../../utils/TestUtilsWalletStorage'
+import path from 'path'
+
+import 'fake-indexeddb/auto'
 
 describe('listActions tests', () => {
   jest.setTimeout(99999999)
@@ -10,15 +19,16 @@ describe('listActions tests', () => {
   const setups: { setup: TestSetup1; storage: StorageProvider }[] = []
 
   const env = _tu.getEnv('test')
-  const ctxs: TestWalletNoSetup[] = []
+  const ctxs: TestWalletProviderNoSetup[] = []
   const testName = () => expect.getState().currentTestName || 'test'
-  const name = testName.name
+  const databaseName = path.parse(expect.getState().testPath!).name
 
   beforeAll(async () => {
     if (env.runMySQL) {
-      ctxs.push(await _tu.createLegacyWalletMySQLCopy(name))
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy(databaseName))
     }
-    ctxs.push(await _tu.createLegacyWalletSQLiteCopy(name))
+    ctxs.push(await _tu.createIdbLegacyWalletCopy(databaseName))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy(databaseName))
   })
 
   afterAll(async () => {