@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/test/wallet/action/relinquishOutput.test.ts

@@ -1,37 +0,0 @@
-import { RelinquishOutputArgs } from '@bsv/sdk'
-import { sdk, StorageKnex } from '../../../src/index.all'
-import { _tu, expectToThrowWERR, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
-import { getBeefForTransaction } from '../../../src/storage/methods/getBeefForTransaction'
-
-describe('RelinquishOutputArgs tests', () => {
-  jest.setTimeout(99999999)
-
-  const env = _tu.getEnv('test')
-  const ctxs: TestWalletNoSetup[] = []
-
-  beforeAll(async () => {
-    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('relinquishActionTests'))
-    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('relinquishActionTests'))
-  })
-
-  afterAll(async () => {
-    for (const ctx of ctxs) {
-      await ctx.storage.destroy()
-    }
-  })
-
-  test('1_default', async () => {
-    const outputTxid = '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'
-    const expectedResult = { relinquished: true }
-
-    for (const { wallet, activeStorage: storage } of ctxs) {
-      const args: RelinquishOutputArgs = {
-        basket: 'default',
-        output: `${outputTxid}.0`
-      }
-
-      const r1 = await wallet.relinquishOutput(args)
-      await expect(Promise.resolve(r1)).resolves.toEqual(expectedResult)
-    }
-  })
-})

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

@@ -1,57 +0,0 @@
-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/list/listActions.test.ts

@@ -1,279 +0,0 @@
-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()
-          }
-        }
-      }
-    }
-  })
-})