@bopen-io/wallet-toolbox 1.7.18

package/src/storage/__test/StorageIdb.test.ts

@@ -0,0 +1,43 @@
+import { PrivateKey } from '@bsv/sdk'
+import { Setup } from '../../Setup'
+import { SetupClient } from '../../SetupClient'
+import { StorageIdb } from '../StorageIdb'
+import { StorageProvider, StorageProviderOptions } from '../StorageProvider'
+import 'fake-indexeddb/auto'
+
+describe('StorageIdb tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions('main')
+    const storage = new StorageIdb(options)
+    const r = await storage.migrate('storageIdbTest', `42`.repeat(32))
+    const db = storage.db!
+    expect(db).toBeTruthy()
+  })
+
+  test.skip('1', async () => {
+    // TODO: THIS TEST PASSES WHEN Describe is run alone, but fails to exit cleanly when run with `npm run test`
+    if (Setup.noEnv('test')) return
+    const env = Setup.getEnv('test')
+    const wallet = await SetupClient.createWalletClientNoEnv({
+      chain: env.chain,
+      rootKeyHex: env.devKeys[env.identityKey]
+    })
+    const stores = wallet.storage.getStores()
+    const options = StorageIdb.createStorageBaseOptions(wallet.chain)
+    const store = new StorageIdb(options)
+    await store.migrate(store.dbName, PrivateKey.fromRandom().toHex())
+    await store.makeAvailable()
+    await wallet.storage.addWalletStorageProvider(store)
+    await wallet.storage.setActive(stores[0].storageIdentityKey, s => {
+      console.log(s)
+      return s
+    })
+    await wallet.storage.updateBackups(undefined, s => {
+      console.log(s)
+      return s
+    })
+    await wallet.destroy()
+  })
+})

package/src/storage/__test/WalletStorageManager.test.ts

@@ -0,0 +1,275 @@
+import * as bsv from '@bsv/sdk'
+import { StorageKnex, wait, WalletStorageManager } from '../..'
+import { _tu, TestWalletNoSetup } from '../../../test/utils/TestUtilsWalletStorage'
+
+import * as dotenv from 'dotenv'
+
+dotenv.config()
+describe('WalletStorageManager tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnvFlags('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('walletStorageManagerTestSource'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('walletStorageManagerTestSource'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  const root = '02135476'
+  const kp = _tu.getKeyPair(root.repeat(8))
+  const fredsAddress = kp.address
+
+  test('1_runAsReader runAsWriter runAsSync interlock correctly', async () => {
+    const { storage } = await _tu.createSQLiteTestSetup1Wallet({
+      databaseName: 'syncTest1'
+    })
+
+    interface Result {
+      i: Number
+      t: 'reader' | 'writer' | 'sync'
+      start: number
+      end: number
+    }
+    const result: Result[] = []
+    const promises: Promise<Result>[] = []
+
+    const now = Date.now()
+
+    const makeReader = (i: number, duration: number): void => {
+      promises.push(
+        storage.runAsReader(async reader => {
+          const start = Date.now() - now
+          await wait(duration)
+          const end = Date.now() - now
+          const r: Result = { start, end, t: 'reader', i }
+          result.push(r)
+          return r
+        })
+      )
+    }
+
+    const makeWriter = (i: number, duration: number): void => {
+      promises.push(
+        storage.runAsWriter(async sync => {
+          const start = Date.now() - now
+          await wait(duration)
+          const end = Date.now() - now
+          const r: Result = { start, end, t: 'writer', i }
+          result.push(r)
+          return r
+        })
+      )
+    }
+
+    const makeSync = (i: number, duration: number): void => {
+      promises.push(
+        storage.runAsSync(async sync => {
+          const start = Date.now() - now
+          await wait(duration)
+          const end = Date.now() - now
+          const r: Result = { start, end, t: 'sync', i }
+          result.push(r)
+          return r
+        })
+      )
+    }
+
+    let i = 0
+    for (let j = 0; j < 5; j++) makeReader(i++, 10 + j * 10)
+    makeSync(i++, 5000)
+    for (let j = 0; j < 5; j++) {
+      makeReader(i++, 10 + j * 10)
+      makeWriter(i++, 30 + j * 500)
+    }
+    makeSync(i++, 5000)
+    for (let j = 0; j < 5; j++) makeReader(i++, 10 + j * 10)
+
+    await Promise.all(promises)
+    expect(result).toBeTruthy()
+
+    let log = ''
+    for (const r of result) {
+      const overlaps = result.filter(
+        r2 => r2.i != r.i && (r2.t != 'reader' || r.t != 'reader') && r.start > r2.start && r.start < r2.end
+      )
+      if (overlaps.length > 0) {
+        log += `${r.i} ${r.t} ${r.start} overlaps:\n`
+        for (const o of overlaps) log += `  ${o.i} ${o.t} ${o.start} ${o.end}\n`
+      }
+    }
+
+    if (log.length > 0) {
+      console.log(log)
+      expect(log.length).toBe(0)
+    }
+
+    await storage.destroy()
+  })
+
+  test('1a_runAsReader runAsWriter runAsSync interlock correctly with low durations', async () => {
+    const { storage } = await _tu.createSQLiteTestSetup1Wallet({
+      databaseName: 'syncTest1a'
+    })
+
+    interface Result {
+      i: Number
+      t: 'reader' | 'writer' | 'sync'
+      start: number
+      end: number
+    }
+    const result: Result[] = []
+    const promises: Promise<Result>[] = []
+
+    const now = Date.now()
+
+    const makeReader = (i: number, duration: number): void => {
+      promises.push(
+        storage.runAsReader(async reader => {
+          const start = Date.now() - now
+          await wait(duration)
+          const end = Date.now() - now
+          const r: Result = { start, end, t: 'reader', i }
+          result.push(r)
+          return r
+        })
+      )
+    }
+
+    const makeWriter = (i: number, duration: number): void => {
+      promises.push(
+        storage.runAsWriter(async sync => {
+          const start = Date.now() - now
+          await wait(duration)
+          const end = Date.now() - now
+          const r: Result = { start, end, t: 'writer', i }
+          result.push(r)
+          return r
+        })
+      )
+    }
+
+    const makeSync = (i: number, duration: number): void => {
+      promises.push(
+        storage.runAsSync(async sync => {
+          const start = Date.now() - now
+          await wait(duration)
+          const end = Date.now() - now
+          const r: Result = { start, end, t: 'sync', i }
+          result.push(r)
+          return r
+        })
+      )
+    }
+
+    let i = 0
+    for (let j = 0; j < 5; j++) makeReader(i++, j)
+    makeSync(i++, 5000)
+    for (let j = 0; j < 5; j++) {
+      makeReader(i++, j)
+      makeWriter(i++, j)
+    }
+    makeSync(i++, 5000)
+    for (let j = 0; j < 5; j++) makeReader(i++, j)
+
+    await Promise.all(promises)
+    expect(result).toBeTruthy()
+
+    let log = ''
+    for (const r of result) {
+      const overlaps = result.filter(
+        r2 => r2.i != r.i && (r2.t != 'reader' || r.t != 'reader') && r.start > r2.start && r.start < r2.end
+      )
+      if (overlaps.length > 0) {
+        log += `${r.i} ${r.t} ${r.start} overlaps:\n`
+        for (const o of overlaps) log += `  ${o.i} ${o.t} ${o.start} ${o.end}\n`
+      }
+    }
+
+    if (log.length > 0) {
+      console.log(log)
+      expect(log.length).toBe(0)
+    }
+
+    await storage.destroy()
+  })
+
+  test.skip('2_TODOTONE - AtomicBEEF error', async () => {
+    for (const { wallet } of ctxs) {
+      const fred = await _tu.createSQLiteTestWallet({
+        chain: 'test',
+        databaseName: 'syncTest2Fred',
+        rootKeyHex: '2'.repeat(64),
+        dropAll: true
+      })
+      const promises: Promise<number>[] = []
+      const result: { i: number; r: any }[] = []
+      const crs1: bsv.CreateActionResult[] = []
+      /*** maxI = 6 test PASS ***/
+      const maxI = 7
+
+      const makeWriter2 = async (
+        fred: TestWalletNoSetup,
+        cr: bsv.CreateActionResult,
+        i: number,
+        result: { i: number; r: any }[]
+      ): Promise<number> => {
+        logger(`writer${i}`)
+        const internalizeArgs: bsv.InternalizeActionArgs = {
+          tx: cr.tx!,
+          outputs: [
+            {
+              outputIndex: 0,
+              protocol: 'basket insertion',
+              insertionRemittance: {
+                basket: 'payments',
+                customInstructions: JSON.stringify({ root, repeat: 8 }),
+                tags: ['test', 'again']
+              }
+            }
+          ],
+          description: `paid ${i}`
+        }
+        const r = await fred.wallet.internalizeAction(internalizeArgs)
+        expect(r.accepted).toBe(true)
+        result.push({ r, i })
+        return i
+      }
+
+      for (let i = 0; i < maxI; i++) {
+        const createArgs: bsv.CreateActionArgs = {
+          description: `${kp.address} of ${root}`,
+          outputs: [
+            {
+              satoshis: 1,
+              lockingScript: _tu.getLockP2PKH(fredsAddress).toHex(),
+              outputDescription: 'pay fred'
+            }
+          ],
+          options: {
+            returnTXIDOnly: false,
+            randomizeOutputs: false,
+            signAndProcess: true,
+            noSend: true
+          }
+        }
+        const cr = await wallet.createAction(createArgs)
+        expect(cr.tx).toBeTruthy()
+        crs1.push(cr)
+      }
+      let j = 0
+      for (let i = 0; i < maxI; i++) promises.push(makeWriter2(fred, crs1[j++], i, result))
+      await Promise.all(promises)
+      expect(result).toBeTruthy()
+    }
+  })
+})
+function logger(s: string) {
+  process.stdout.write(`${s}\n`)
+}

package/src/storage/__test/adminStats.man.test.ts

@@ -0,0 +1,89 @@
+import { _tu, TestWalletOnly } from '../../../test/utils/TestUtilsWalletStorage'
+import { Setup } from '../../Setup'
+import { StorageKnex } from '../StorageKnex'
+import { AuthFetch } from '@bsv/sdk'
+import { StorageAdminStats } from '../index.client'
+import { Format } from '../../utility/Format'
+
+describe('storage adminStats tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('main')
+  const knex = Setup.createMySQLKnex(process.env.MAIN_CLOUD_MYSQL_CONNECTION!)
+  const storage = new StorageKnex({
+    chain: env.chain,
+    knex: knex,
+    commissionSatoshis: 0,
+    commissionPubKeyHex: undefined,
+    feeModel: { model: 'sat/kb', value: 1 }
+  })
+
+  let setup: TestWalletOnly
+  let nextId = 0
+
+  beforeAll(async () => {
+    await storage.makeAvailable()
+
+    setup = await _tu.createTestWalletWithStorageClient({
+      chain: 'main',
+      rootKeyHex: env.devKeys[env.identityKey]
+    })
+  })
+  afterAll(async () => {
+    await storage.destroy()
+    await setup.wallet.destroy()
+  })
+
+  test('0 adminStats StorageKnex', async () => {
+    storage.setServices(setup.services)
+    const r = await storage.adminStats(env.identityKey)
+    console.log(Format.toLogStringAdminStats(r))
+    expect(r.requestedBy).toBe(env.identityKey)
+    expect(r.usersTotal).toBeGreaterThan(0)
+    await storage.destroy()
+  })
+
+  test('1 adminStats StorageServer via RPC', async () => {
+    const authFetch = new AuthFetch(setup.wallet)
+    const endpointUrl =
+      setup.chain === 'main' ? 'https://storage.babbage.systems' : 'https://staging-storage.babbage.systems'
+
+    const id = nextId++
+    const body = {
+      jsonrpc: '2.0',
+      method: 'adminStats',
+      params: [env.identityKey],
+      id
+    }
+
+    let response: Response
+    try {
+      response = await authFetch.fetch(endpointUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+      })
+    } catch (eu: unknown) {
+      throw eu
+    }
+
+    if (!response.ok) {
+      throw new Error(`WalletStorageClient rpcCall: network error ${response.status} ${response.statusText}`)
+    }
+
+    const json = await response.json()
+    if (json.error) {
+      const { code, message, data } = json.error
+      const err = new Error(`RPC Error: ${message}`)
+      // You could attach more info here if you like:
+      ;(err as any).code = code
+      ;(err as any).data = data
+      throw err
+    }
+
+    const r = json.result as StorageAdminStats
+    console.log(Format.toLogStringAdminStats(r))
+    expect(r.requestedBy).toBe(env.identityKey)
+    expect(r.usersTotal).toBeGreaterThan(0)
+  })
+})