@bopen-io/wallet-toolbox 1.7.18

package/test/Wallet/construct/Wallet.constructor.test.ts

@@ -0,0 +1,57 @@
+import { sdk } from '../../../src/index.client'
+import { _tu, TestSetup1Wallet } from '../../utils/TestUtilsWalletStorage'
+
+describe('Wallet constructor tests', () => {
+  jest.setTimeout(99999999)
+
+  const chain: sdk.Chain = 'test'
+  const ctxs: TestSetup1Wallet[] = []
+  const env = _tu.getEnv(chain)
+
+  beforeAll(async () => {
+    if (env.runMySQL) {
+      ctxs.push(
+        await _tu.createMySQLTestSetup1Wallet({
+          databaseName: 'walletConstruct',
+          chain,
+          rootKeyHex: '1'.repeat(64)
+        })
+      )
+    }
+    ctxs.push(
+      await _tu.createSQLiteTestSetup1Wallet({
+        databaseName: 'walletConstruct',
+        chain,
+        rootKeyHex: '2'.repeat(64)
+      })
+    )
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0', async () => {
+    for (const { activeStorage: storage, userId, wallet } of ctxs) {
+      {
+        const labels = await storage.findTxLabels({ partial: { userId } })
+        const label = labels[0].label
+        const r = await wallet.listActions({
+          labels: [label]
+        })
+        expect(r.totalActions).toBe(1)
+      }
+
+      {
+        const baskets = await storage.findOutputBaskets({ partial: { userId } })
+        const basket = baskets[0].name
+        const r = await wallet.listOutputs({
+          basket
+        })
+        expect(r.totalOutputs).toBe(1)
+      }
+    }
+  })
+})

package/test/Wallet/get/getHeaderForHeight.test.ts

@@ -0,0 +1,82 @@
+import { Utils } from '@bsv/sdk'
+import {
+  blockHash,
+  deserializeBaseBlockHeader
+} from '../../../src/services/chaintracker/chaintracks/util/blockHeaderUtilities'
+import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+const includeTestChaintracks = false
+
+describe('getHeaderForHeight tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (includeTestChaintracks) {
+      if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('getHeaderForHeightTests'))
+      ctxs.push(await _tu.createLegacyWalletSQLiteCopy('getHeaderForHeightTests'))
+    }
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0 invalid params', async () => {
+    for (const { wallet } of ctxs) {
+      try {
+        await wallet.getHeaderForHeight({ height: -1 })
+        throw new Error('Expected error was not thrown')
+      } catch (e) {
+        const errorMessage = typeof e === 'object' && e !== null && 'message' in e ? (e as Error).message : String(e)
+        expect(errorMessage).toMatch(/Height -1 must be a non-negative integer/i)
+      }
+    }
+  })
+
+  test('1 valid block height', async () => {
+    for (const { wallet } of ctxs) {
+      // Query an existing valid block height
+      const height = 1 // Ensure this height exists in the test database
+      const result = await wallet.getHeaderForHeight({ height })
+      const headerHex = result.header
+      const headerA = Utils.toArray(headerHex, 'hex')
+      const hash = blockHash(headerA)
+      expect(hash).toBe('00000000b873e79784647a6c82962c70d228557d24a747ea4d1b8bbe878e1206')
+      const header = deserializeBaseBlockHeader(headerA)
+
+      expect(result).toHaveProperty('header')
+      expect(typeof result.header).toBe('string')
+      expect(result.header).not.toBe('')
+    }
+  })
+
+  test('2 unexpected service errors', async () => {
+    for (const { wallet } of ctxs) {
+      try {
+        // Query a height that doesn't exist or triggers an unexpected error
+        const invalidHeight = 999999
+        await wallet.getHeaderForHeight({ height: invalidHeight })
+        throw new Error('Expected error was not thrown')
+      } catch (e) {
+        const errorMessage = typeof e === 'object' && e !== null && 'message' in e ? (e as Error).message : String(e)
+        expect(errorMessage).toMatch(/error|not found/i)
+      }
+    }
+  })
+
+  test('3 valid block height always returns a header', async () => {
+    for (const { wallet } of ctxs) {
+      const height = 9999
+      const result = await wallet.getHeaderForHeight({ height })
+
+      expect(result).toHaveProperty('header')
+      expect(typeof result.header).toBe('string')
+      expect(result.header).not.toBe('')
+    }
+  })
+})

package/test/Wallet/get/getHeight.test.ts

@@ -0,0 +1,52 @@
+import { _tu, expectToThrowWERR } from '../../utils/TestUtilsWalletStorage'
+import { sdk } from '../../../src/index.client'
+
+const includeTestChaintracks = false
+
+describe('getHeight tests', () => {
+  jest.setTimeout(99999999)
+
+  const ctxs: any[] = []
+  const env = _tu.getEnv('test')
+
+  beforeAll(async () => {
+    if (includeTestChaintracks) {
+      ctxs.push(await _tu.createSQLiteTestWallet({ databaseName: 'getHeightTestsSQLite' }))
+      if (env.runMySQL) {
+        ctxs.push(await _tu.createMySQLTestWallet({ databaseName: 'getHeightTestsMySQL' }))
+      }
+    }
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0 valid height', async () => {
+    for (const { wallet } of ctxs) {
+      const result = await wallet.getHeight({})
+
+      // Validate the height (assuming it's a positive integer)
+      expect(result).toHaveProperty('height')
+      expect(result.height).toBeGreaterThan(0)
+    }
+  })
+
+  test('1 handles errors from services gracefully', async () => {
+    for (const { wallet } of ctxs) {
+      try {
+        // Trigger an invalid scenario that should throw an error
+        await wallet.getHeight({ invalidParam: true })
+      } catch (e) {
+        // Narrow the type of 'e' to 'Error'
+        if (e instanceof Error) {
+          expect(e.message).toContain('invalid')
+        } else {
+          throw new Error('Unexpected error type thrown')
+        }
+      }
+    }
+  })
+})

package/test/Wallet/get/getKnownTxids.test.ts

@@ -0,0 +1,86 @@
+import { _tu, expectToThrowWERR, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+import * as bsv from '@bsv/sdk'
+
+describe('getKnownTxids Tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) {
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy('getKnownTxidsTests'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('getKnownTxidsTests'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  /*********************************************************************************************************
+   * TODOTONE: Duplicates not being handled correctly.
+   **********************************************************************************************************/
+  test('0 should return an empty array when no txids are provided', async () => {
+    for (const { wallet } of ctxs) {
+      const result = wallet.getKnownTxids()
+      expect(result).toEqual([])
+    }
+  })
+
+  // Duplicate txids are not being handled correctly
+  test('1 should add new known txids', async () => {
+    for (const { wallet } of ctxs) {
+      const txids = ['txid1']
+      const resultBefore = wallet.getKnownTxids()
+      expect(resultBefore).toEqual([])
+
+      wallet.getKnownTxids(txids)
+      const resultAfter = wallet.getKnownTxids()
+      expect(resultAfter).toEqual(txids)
+    }
+  })
+
+  // Duplicate txids are not being handled correctly
+  test('2 should avoid duplicating txids', async () => {
+    for (const { wallet } of ctxs) {
+      const txids = ['txid1', 'txid2']
+      wallet.getKnownTxids(txids)
+
+      const resultBefore = wallet.getKnownTxids()
+      expect(resultBefore).toEqual(txids)
+
+      wallet.getKnownTxids(['txid2']) // Add duplicate txid
+      const resultAfter = wallet.getKnownTxids()
+      expect(resultAfter).toEqual(txids) // Ensure no duplicates are added
+    }
+  })
+
+  // Duplicate txids are not being handled correctly
+  test('3 should return sorted txids', async () => {
+    for (const { wallet } of ctxs) {
+      const unsortedTxids = ['txid3', 'txid1', 'txid2']
+      wallet.getKnownTxids(unsortedTxids)
+
+      const result = wallet.getKnownTxids()
+      expect(result).toEqual(['txid1', 'txid2', 'txid3']) // Ensure txids are sorted
+    }
+  })
+
+  test('4 should handle invalid txids gracefully', async () => {
+    for (const { wallet } of ctxs) {
+      const invalidTxids = ['invalid_txid']
+      const validTxids = ['txid1', 'txid2', 'txid3']
+      const inputTxids = [...validTxids, ...invalidTxids]
+
+      // Call the method with both valid and invalid txids
+      const result = wallet.getKnownTxids(inputTxids)
+
+      // Validate the result includes all txids
+      expect(Array.isArray(result)).toBe(true)
+      expect(result).toEqual(expect.arrayContaining(inputTxids))
+    }
+  })
+})

package/test/Wallet/get/getNetwork.test.ts

@@ -0,0 +1,27 @@
+import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+describe('Wallet getNetwork Tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('getNetworkTests'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('getNetworkTests'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('should return the correct network', async () => {
+    for (const { wallet } of ctxs) {
+      const result = await wallet.getNetwork({})
+      // Replace 'testnet' with the expected network for your test environment
+      expect(result).toEqual({ network: 'testnet' })
+    }
+  })
+})

package/test/Wallet/get/getVersion.test.ts

@@ -0,0 +1,27 @@
+import { sdk } from '../../../src/index.client'
+import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+describe('Wallet getVersion Tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('getVersionTests'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('getVersionTests'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('should return the correct wallet version', async () => {
+    for (const { wallet } of ctxs) {
+      const result = await wallet.getVersion({})
+      expect(result).toEqual({ version: 'wallet-brc100-1.0.0' })
+    }
+  })
+})

package/test/Wallet/list/listActions.test.ts

@@ -0,0 +1,279 @@
+import { ListActionsArgs } from '@bsv/sdk'
+import { sdk, StorageProvider } from '../../../src/index.client'
+import { _tu, expectToThrowWERR, TestSetup1, TestWalletProviderNoSetup } from '../../utils/TestUtilsWalletStorage'
+import path from 'path'
+
+import 'fake-indexeddb/auto'
+
+describe('listActions tests', () => {
+  jest.setTimeout(99999999)
+
+  const storages: StorageProvider[] = []
+  const chain: sdk.Chain = 'test'
+  const setups: { setup: TestSetup1; storage: StorageProvider }[] = []
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletProviderNoSetup[] = []
+  const testName = () => expect.getState().currentTestName || 'test'
+  const databaseName = path.parse(expect.getState().testPath!).name
+
+  beforeAll(async () => {
+    if (env.runMySQL) {
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy(databaseName))
+    }
+    ctxs.push(await _tu.createIdbLegacyWalletCopy(databaseName))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy(databaseName))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0 invalid params', async () => {
+    for (const { wallet } of ctxs) {
+      const invalidArgs: ListActionsArgs[] = [
+        { labels: ['toolong890'.repeat(31)] }
+        // Oh so many things to test...
+      ]
+
+      for (const args of invalidArgs) {
+        await expectToThrowWERR(sdk.WERR_INVALID_PARAMETER, () => wallet.listActions(args))
+      }
+    }
+  })
+
+  test('1 all actions', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeLabels: true,
+          labels: []
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBe(191)
+        expect(r.actions.length).toBe(10)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.inputs).toBeUndefined()
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.labels)).toBe(true)
+        }
+      }
+    }
+  })
+
+  test('2 non-existing label with any', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeLabels: true,
+          labels: ['xyzzy'],
+          labelQueryMode: 'any'
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBe(0)
+        expect(r.actions.length).toBe(0)
+      }
+    }
+  })
+
+  test('3_label babbage_protocol_perm', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeLabels: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBeGreaterThanOrEqual(r.actions.length)
+        expect(r.actions.length).toBe(args.limit || 10)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.inputs).toBeUndefined()
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.labels)).toBe(true)
+          expect(a.labels?.indexOf('babbage_protocol_perm')).toBeGreaterThan(-1)
+        }
+      }
+    }
+  })
+
+  test('4_label babbage_protocol_perm', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeLabels: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBeGreaterThanOrEqual(r.actions.length)
+        expect(r.actions.length).toBe(args.limit || 10)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.inputs).toBeUndefined()
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.labels)).toBe(true)
+          for (const label of args.labels) {
+            expect(a.labels?.indexOf(label)).toBeGreaterThan(-1)
+          }
+        }
+      }
+    }
+  })
+
+  test('5_label babbage_protocol_perm or babbage_basket_access', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeLabels: true,
+          labels: ['babbage_protocol_perm', 'babbage_basket_access']
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBeGreaterThanOrEqual(r.actions.length)
+        expect(r.actions.length).toBe(args.limit || 10)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.inputs).toBeUndefined()
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.labels)).toBe(true)
+          let count = 0
+          for (const label of args.labels) {
+            if (a.labels!.indexOf(label) > -1) count++
+          }
+          expect(count).toBeGreaterThan(0)
+        }
+      }
+    }
+  })
+
+  test('6_label babbage_protocol_perm and babbage_basket_access', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeLabels: true,
+          labels: ['babbage_protocol_perm', 'babbage_basket_access'],
+          labelQueryMode: 'all'
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBe(0)
+      }
+    }
+  })
+
+  test('7_includeOutputs', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeOutputs: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        expect(r.totalActions).toBeGreaterThanOrEqual(r.actions.length)
+        expect(r.actions.length).toBe(args.limit || 10)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.isOutgoing === true || a.isOutgoing === false).toBe(true)
+          expect(a.inputs).toBeUndefined()
+          expect(Array.isArray(a.outputs)).toBe(true)
+          expect(a.labels).toBeUndefined()
+          for (const o of a.outputs!) {
+            expect(o.outputIndex).toBeGreaterThanOrEqual(0)
+            expect(o.lockingScript).toBeUndefined()
+          }
+        }
+      }
+    }
+  })
+
+  test('8_includeOutputs and script', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeOutputs: true,
+          includeOutputLockingScripts: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        let i = 0
+        for (const a of r.actions) {
+          for (const o of a.outputs!) {
+            expect(o.lockingScript?.length).toBeGreaterThan(0)
+          }
+        }
+      }
+    }
+  })
+
+  test('9_includeInputs', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeInputs: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.isOutgoing === true || a.isOutgoing === false).toBe(true)
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.inputs)).toBe(true)
+          expect(a.labels).toBeUndefined()
+          for (const i of a.inputs!) {
+            expect(i.sourceLockingScript).toBeUndefined()
+            expect(i.unlockingScript).toBeUndefined()
+          }
+        }
+      }
+    }
+  })
+
+  test('10_includeInputs and unlock', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeInputs: true,
+          includeInputUnlockingScripts: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.isOutgoing === true || a.isOutgoing === false).toBe(true)
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.inputs)).toBe(true)
+          expect(a.labels).toBeUndefined()
+          for (const i of a.inputs!) {
+            expect(i.sourceLockingScript).toBeUndefined()
+            expect(i.unlockingScript?.length).toBeGreaterThan(0)
+          }
+        }
+      }
+    }
+  })
+
+  test('11_includeInputs and lock', async () => {
+    for (const { wallet } of ctxs) {
+      {
+        const args: ListActionsArgs = {
+          includeInputs: true,
+          includeInputSourceLockingScripts: true,
+          labels: ['babbage_protocol_perm']
+        }
+        const r = await wallet.listActions(args)
+        let i = 0
+        for (const a of r.actions) {
+          expect(a.isOutgoing === true || a.isOutgoing === false).toBe(true)
+          expect(a.outputs).toBeUndefined()
+          expect(Array.isArray(a.inputs)).toBe(true)
+          expect(a.labels).toBeUndefined()
+          for (const i of a.inputs!) {
+            expect(i.sourceLockingScript?.length).toBeGreaterThan(0)
+            expect(i.unlockingScript).toBeUndefined()
+          }
+        }
+      }
+    }
+  })
+})