@bopen-io/wallet-toolbox 1.7.18

package/test/services/Services.test.ts

@@ -0,0 +1,263 @@
+import { Beef, Utils } from '@bsv/sdk'
+import { sdk, Services, sha256Hash, wait } from '../../src/index.all'
+import { _tu, TestSetup1Wallet } from '../utils/TestUtilsWalletStorage'
+
+const includeTestChaintracks = false
+
+describe('Wallet services tests', () => {
+  jest.setTimeout(99999999)
+
+  const ctxs: TestSetup1Wallet[] = []
+
+  beforeAll(async () => {
+    ctxs.push(
+      await _tu.createSQLiteTestSetup1Wallet({
+        databaseName: 'walletServicesMain',
+        chain: 'main',
+        rootKeyHex: '3'.repeat(64)
+      })
+    )
+    if (includeTestChaintracks) {
+      ctxs.push(
+        await _tu.createSQLiteTestSetup1Wallet({
+          databaseName: 'walletServicesTest',
+          chain: 'test',
+          rootKeyHex: '3'.repeat(64)
+        })
+      )
+    }
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0 getUtxoStatus', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const us = await wallet.services.getUtxoStatus(
+          '4104eca750b68551fb5aa893acb428b6a7d2d673498fd055cf2a8d402211b9500bdc27936846c2aa45cf82afe2f566b69cd7f7298154b0ffb25fbfa4fef8986191c4ac',
+          'script'
+        )
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(true)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        }
+      }
+    }
+  })
+
+  test('0a getUtxoStatus hashLE', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const script =
+          '4104eca750b68551fb5aa893acb428b6a7d2d673498fd055cf2a8d402211b9500bdc27936846c2aa45cf82afe2f566b69cd7f7298154b0ffb25fbfa4fef8986191c4ac'
+        const hash = Utils.toHex(sha256Hash(Utils.toArray(script, 'hex')))
+        const us = await wallet.services.getUtxoStatus(
+          hash
+          // 'hashLE'
+        )
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(true)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        }
+      }
+    }
+  })
+
+  test('0b getUtxoStatus hashBE', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const script =
+          '4104eca750b68551fb5aa893acb428b6a7d2d673498fd055cf2a8d402211b9500bdc27936846c2aa45cf82afe2f566b69cd7f7298154b0ffb25fbfa4fef8986191c4ac'
+        const hash = Utils.toHex(sha256Hash(Utils.toArray(script, 'hex')).reverse())
+        const us = await wallet.services.getUtxoStatus(hash, 'hashBE')
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(true)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        }
+      }
+    }
+  })
+
+  test('0c getUtxoStatus hashOutputScript method', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const script =
+          '4104eca750b68551fb5aa893acb428b6a7d2d673498fd055cf2a8d402211b9500bdc27936846c2aa45cf82afe2f566b69cd7f7298154b0ffb25fbfa4fef8986191c4ac'
+        const hash = wallet.services.hashOutputScript(script)
+        const us = await wallet.services.getUtxoStatus(hash)
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(true)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        }
+      }
+    }
+  })
+
+  test('0d getUtxoStatus outpoint', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const script =
+          '4104eca750b68551fb5aa893acb428b6a7d2d673498fd055cf2a8d402211b9500bdc27936846c2aa45cf82afe2f566b69cd7f7298154b0ffb25fbfa4fef8986191c4ac'
+        const hash = wallet.services.hashOutputScript(script)
+        const us = await wallet.services.getUtxoStatus(
+          hash,
+          undefined,
+          'e4154d8ab6993addc9b8705318cc8e971dfc0780e233038ecf44c601229d93ce.0'
+        )
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(true)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        }
+      }
+    }
+  })
+
+  test('0e getUtxoStatus invalid outpoint', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const script =
+          '4104eca750b68551fb5aa893acb428b6a7d2d673498fd055cf2a8d402211b9500bdc27936846c2aa45cf82afe2f566b69cd7f7298154b0ffb25fbfa4fef8986191c4ac'
+        const hash = wallet.services.hashOutputScript(script)
+        const us = await wallet.services.getUtxoStatus(
+          hash,
+          undefined,
+          'e4154d8ab6993addc9b8705318cc8e971dfc0780e233038ecf44c601229d93ce.1'
+        )
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.isUtxo).toBe(false)
+        }
+      }
+    }
+  })
+
+  // Underlying WoC service is rate limited
+  test.skip('1 getBsvExchangeRate', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+
+      {
+        const usdPerBsv = await wallet.services.getBsvExchangeRate()
+        expect(usdPerBsv).toBeGreaterThan(0) // and really so much more...
+      }
+    }
+  })
+
+  test('2 getFiatExchangeRate', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const eurPerUsd = await wallet.services.getFiatExchangeRate('EUR', 'USD')
+        expect(eurPerUsd).toBeGreaterThan(0)
+      }
+    }
+  })
+
+  test('3 getChainTracker', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+
+      {
+        const chaintracker = await wallet.services.getChainTracker()
+        const height = await chaintracker.currentHeight()
+        expect(height).toBeGreaterThan(800000)
+      }
+    }
+  })
+
+  test('4 getMerklePath', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+
+      {
+        const mp = await wallet.services.getMerklePath(
+          '9cce99686bc8621db439b7150dd5b3b269e4b0628fd75160222c417d6f2b95e4'
+        )
+        if (chain === 'main') expect(mp.merklePath?.blockHeight).toBe(877599)
+        else expect(mp.merklePath).not.toBeTruthy()
+      }
+
+      await wait(3000)
+    }
+  })
+
+  test('5 getRawTx', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        const rawTx = await wallet.services.getRawTx('9cce99686bc8621db439b7150dd5b3b269e4b0628fd75160222c417d6f2b95e4')
+        if (chain === 'main') expect(rawTx.rawTx!.length).toBe(176)
+        else expect(rawTx.rawTx).not.toBeTruthy()
+      }
+    }
+  })
+
+  test('6 getScriptHashHistory', async () => {
+    for (const { chain, wallet, services } of ctxs) {
+      if (!wallet.services || !services) throw new sdk.WERR_INTERNAL('test requires setup with services')
+      {
+        let hash = '86e41f4725135ca0db59d074e7d60daae7c1a87699013498bae52dc95cae1a52'
+        hash = Utils.toHex(Utils.toArray(hash, 'hex').reverse())
+        const us = await wallet.services.getScriptHashHistory(hash)
+        if (chain === 'main') {
+          expect(us.status).toBe('success')
+          expect(us.history.length).toBeGreaterThan(0)
+        } else {
+          expect(us.status).toBe('success')
+          expect(us.history.length).toBe(0)
+        }
+      }
+    }
+  })
+
+  // This test is failing from cloud deploy but passes when run locally...
+  test.skip('7 getStatusForTxids', async () => {
+    for (const { chain, services } of ctxs) {
+      {
+        const txids = ['32c691a077b0ce46051aa7a45fa3b131c71ff85950264575a32171086b02ad98']
+        const r = await services.getStatusForTxids(txids)
+        expect(r.results.length).toBe(1)
+        expect(r.results[0].txid).toBe(txids[0])
+        expect(r.name).toBeTruthy()
+        expect(r.status).toBe('success')
+        expect(r.error).toBe(undefined)
+        if (chain === 'main') {
+          expect(r.results[0].status).toBe('mined')
+          expect(r.results[0].depth).toBeGreaterThan(146)
+        } else {
+          expect(r.results[0].status).toBe('unknown')
+          expect(r.results[0].depth).toBe(undefined)
+        }
+        await wait(3000)
+      }
+    }
+  })
+})

package/test/storage/KnexMigrations.test.ts

@@ -0,0 +1,86 @@
+import { _tu } from '../utils/TestUtilsWalletStorage'
+import { KnexMigrations, StorageKnex, wait } from '../../src/index.all'
+import { Knex } from 'knex'
+
+describe('KnexMigrations tests', () => {
+  jest.setTimeout(99999999)
+
+  const knexs: Knex[] = []
+  const env = _tu.getEnvFlags('test')
+
+  beforeAll(async () => {
+    const localSQLiteFile = await _tu.newTmpFile('migratetest.sqlite', true, false, true)
+    const knexSQLite = _tu.createLocalSQLite(localSQLiteFile)
+    knexs.push(knexSQLite)
+
+    if (env.runMySQL) {
+      const knexMySQL = _tu.createLocalMySQL('migratetest')
+      knexs.push(knexMySQL)
+    }
+  })
+
+  afterAll(async () => {
+    for (const knex of knexs) {
+      await knex.destroy()
+    }
+  })
+
+  let done0 = false
+  const waitFor0 = async () => {
+    while (!done0) await wait(100)
+  }
+  let done1 = false
+  const waitFor1 = async () => {
+    while (!done1) await wait(100)
+  }
+
+  test('0 migragte down', async () => {
+    for (const knex of knexs) {
+      const config = {
+        migrationSource: new KnexMigrations('test', '0 migration test', '1'.repeat(64), 1000)
+      }
+      const count = Object.keys(config.migrationSource.migrations).length
+      for (let i = 0; i < count; i++) {
+        try {
+          const r = await knex.migrate.down(config)
+          expect(r).toBeTruthy()
+        } catch (eu: unknown) {
+          break
+        }
+      }
+    }
+    done0 = true
+  })
+
+  test('1 migragte to latest', async () => {
+    await waitFor0()
+    for (const knex of knexs) {
+      const config = {
+        migrationSource: new KnexMigrations('test', '0 migration test', '1'.repeat(64), 1000)
+      }
+      const latest = await KnexMigrations.latestMigration()
+      await knex.migrate.latest(config)
+      const version = await knex.migrate.currentVersion(config)
+
+      expect(version).toBe(latest.split('_')[0])
+    }
+    done1 = true
+  })
+
+  test('2 getSettings', async () => {
+    await waitFor1()
+    for (const knex of knexs) {
+      const storage = new StorageKnex({
+        ...StorageKnex.defaultOptions(),
+        chain: 'test',
+        knex
+      })
+      await storage.makeAvailable()
+      const r = await storage.getSettings()
+      expect(r.created_at instanceof Date).toBe(true)
+      expect(r.updated_at instanceof Date).toBe(true)
+      expect(r.chain).toBe('test')
+      expect(r.maxOutputScript).toBe(1000)
+    }
+  })
+})

package/test/storage/StorageMySQLDojoReader.man.test.ts

@@ -0,0 +1,60 @@
+// @ts-nocheck
+import { _tu } from '../utils/TestUtilsWalletStorage'
+import { entity, maxDate, sdk, StorageKnex, sync } from '../../src/index.all'
+import { StorageMySQLDojoReader } from '../../src/storage/sync/StorageMySQLDojoReader'
+
+import * as dotenv from 'dotenv'
+dotenv.config()
+
+describe('StorageMySQLDojoReader tests', () => {
+  jest.setTimeout(99999999)
+
+  const chain: sdk.Chain = 'test'
+  const env = _tu.getEnv(chain)
+  let reader: sdk.WalletStorageSyncReader
+  let writer: StorageKnex
+
+  beforeAll(async () => {
+    const connection = JSON.parse(
+      (chain === 'test' ? process.env.TEST_DOJO_CONNECTION : process.env.MAIN_DOJO_CONNECTION) || ''
+    )
+    const readerKnex = _tu.createMySQLFromConnection(connection)
+    reader = new StorageMySQLDojoReader({
+      ...StorageKnex.defaultOptions(),
+      chain,
+      knex: readerKnex
+    })
+
+    const writerKnex = env.runMySQL
+      ? _tu.createLocalMySQL('stagingdojotone')
+      : _tu.createLocalSQLite(await _tu.newTmpFile('stagingdojotone', false, false, true))
+    writer = new StorageKnex({
+      ...StorageKnex.defaultOptions(),
+      chain,
+      knex: writerKnex
+    })
+    await writer.dropAllData()
+    await writer.migrate('stagingdojotone', '1'.repeat(64))
+  })
+
+  afterAll(async () => {
+    await reader.destroy()
+    await writer.destroy()
+  })
+
+  test('0', async () => {
+    const readerSettings = await reader.getSettings()
+    const writerSettings = await writer.getSettings()
+
+    const identityKey = process.env.MY_TEST_IDENTITY || ''
+    const ss = await EntitySyncState.fromStorage(writer, identityKey, readerSettings)
+
+    for (;;) {
+      const args = ss.makeRequestSyncChunkArgs(identityKey, writerSettings.storageIdentityKey)
+      const chunk = await reader.getSyncChunk(args)
+      const r = await ss.processRequestSyncChunkResult(writer, args, chunk)
+      //console.log(`${r.maxUpdated_at} inserted ${r.inserts} updated ${r.updates}`)
+      if (r.done) break
+    }
+  })
+})

package/test/storage/count.test.ts

@@ -0,0 +1,177 @@
+import { _tu, TestSetup1 } from '../utils/TestUtilsWalletStorage'
+import { sdk, StorageProvider } from '../../src/index.client'
+import { StorageKnex } from '../../src/storage/StorageKnex'
+
+describe('count 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('storagecounttest.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('storagecounttest')
+      storages.push(
+        new StorageKnex({
+          ...StorageKnex.defaultOptions(),
+          chain,
+          knex: knexMySQL
+        })
+      )
+    }
+
+    for (const storage of storages) {
+      await storage.dropAllData()
+      await storage.migrate('insert 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 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)
+    }
+  })
+})