@bsv/wallet-toolbox 1.1.0

package/test/Wallet/certificate/listCertificates.test.ts

@@ -0,0 +1,352 @@
+import { OriginatorDomainNameStringUnder250Bytes } from '@bsv/sdk'
+import { listCertificates } from '../../../src/storage/methods/listCertificates'
+import { StorageProvider } from '../../../src/storage/StorageProvider'
+import { sdk, table } from '../../../src/index.all'
+import { TrxToken } from '../../../src/sdk'
+
+jest.mock('../../../src/storage/StorageProvider')
+
+describe('listCertificates', () => {
+  let mockStorage: jest.Mocked<StorageProvider>
+  let auth: sdk.AuthId
+
+  // This is a valid, minimal set of arguments for listCertificates
+  let vargs: sdk.ValidListCertificatesArgs
+  let originator: OriginatorDomainNameStringUnder250Bytes | undefined
+
+  // Helper so we can easily mock the transaction call
+  const mockTransaction = async <T>(
+    callback: (trx: TrxToken) => Promise<T>
+  ): Promise<T> => {
+    // We simulate the transaction by simply calling back immediately
+    // with an empty object as trx token.
+    return callback({} as unknown as TrxToken)
+  }
+
+  beforeEach(() => {
+    // Create a fresh mock of the storage
+    mockStorage = {
+      // We only need to mock the methods that are actually used by listCertificates
+      transaction: jest.fn().mockImplementation(mockTransaction),
+      findCertificates: jest.fn(),
+      findCertificateFields: jest.fn(),
+      countCertificates: jest.fn()
+    } as unknown as jest.Mocked<StorageProvider>
+
+    // Auth with a valid user ID
+    auth = {
+      identityKey: 'myIdentityKey',
+      userId: 123
+    }
+
+    // Minimal valid vargs with default limit=10, offset=0, no partial filter
+    vargs = {
+      partial: undefined,
+      certifiers: [],
+      types: [],
+      limit: 10,
+      offset: 0,
+      privileged: false
+    }
+
+    // By default we set it to undefined
+    originator = undefined
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should return an empty result when no certificates are found', async () => {
+    // Setup mocks
+    mockStorage.findCertificates.mockResolvedValueOnce([]) // no certs returned
+
+    // Execute
+    const result = await listCertificates(mockStorage, auth, vargs, originator)
+
+    // Verify
+    expect(mockStorage.transaction).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificates).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificateFields).not.toHaveBeenCalled()
+    expect(mockStorage.countCertificates).not.toHaveBeenCalled() // no need to call if 0 < limit
+
+    expect(result).toEqual({
+      totalCertificates: 0,
+      certificates: []
+    })
+  })
+
+  test('should return exactly the number of certificates if they are fewer than the limit', async () => {
+    // Suppose we have 2 certificates
+    const fakeCerts: table.Certificate[] = [
+      {
+        certificateId: 1,
+        userId: 123,
+        type: 'base64Type1',
+        serialNumber: 'serial1',
+        certifier: 'abcdef01',
+        subject: '12345678',
+        verifier: undefined,
+        revocationOutpoint: 'abcd1234.0',
+        signature: 'deadbeef01',
+        isDeleted: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      },
+      {
+        certificateId: 2,
+        userId: 123,
+        type: 'base64Type2',
+        serialNumber: 'serial2',
+        certifier: 'abcdef02',
+        subject: '23456789',
+        verifier: undefined,
+        revocationOutpoint: 'abcd5678.1',
+        signature: 'deadbeef02',
+        isDeleted: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      }
+    ]
+
+    // Suppose each cert has some fields
+    const fakeFieldsForCert1: table.CertificateField[] = [
+      {
+        certificateId: 1,
+        userId: 123,
+        fieldName: 'field1',
+        fieldValue: 'value1',
+        masterKey: 'mkey1',
+        created_at: new Date(),
+        updated_at: new Date()
+      }
+    ]
+
+    const fakeFieldsForCert2: table.CertificateField[] = [
+      {
+        certificateId: 2,
+        userId: 123,
+        fieldName: 'fieldA',
+        fieldValue: 'valueA',
+        masterKey: 'mkeyA',
+        created_at: new Date(),
+        updated_at: new Date()
+      }
+    ]
+
+    mockStorage.findCertificates.mockResolvedValueOnce(fakeCerts)
+    // Make sure we return correct fields for each certificate
+    mockStorage.findCertificateFields.mockImplementation(
+      async (args: sdk.FindCertificateFieldsArgs) => {
+        if (args.partial?.certificateId === 1) return fakeFieldsForCert1
+        if (args.partial?.certificateId === 2) return fakeFieldsForCert2
+        return []
+      }
+    )
+
+    // The returned certs are length=2, which is < limit(10). So we do not call countCertificates
+    // Setup a spied or mocked value just in case
+    mockStorage.countCertificates.mockResolvedValueOnce(10)
+
+    // Execute
+    const result = await listCertificates(mockStorage, auth, vargs)
+
+    // Verify
+    expect(mockStorage.transaction).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificates).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificateFields).toHaveBeenCalledTimes(2)
+    expect(mockStorage.countCertificates).not.toHaveBeenCalled() // Because 2 < 10
+
+    expect(result.certificates.length).toBe(2)
+    expect(result.totalCertificates).toBe(2)
+
+    // Ensure the fields are included
+    expect(result.certificates[0]).toEqual({
+      type: 'base64Type1',
+      subject: '12345678',
+      serialNumber: 'serial1',
+      certifier: 'abcdef01',
+      revocationOutpoint: 'abcd1234.0',
+      signature: 'deadbeef01',
+      verifier: undefined,
+      fields: { field1: 'value1' },
+      keyring: { field1: 'mkey1' }
+    })
+    expect(result.certificates[1]).toEqual({
+      type: 'base64Type2',
+      subject: '23456789',
+      serialNumber: 'serial2',
+      certifier: 'abcdef02',
+      revocationOutpoint: 'abcd5678.1',
+      signature: 'deadbeef02',
+      verifier: undefined,
+      fields: { fieldA: 'valueA' },
+      keyring: { fieldA: 'mkeyA' }
+    })
+  })
+
+  test('should call countCertificates when the returned certificates length is equal to limit', async () => {
+    // We want exactly 'limit' items returned, so the function calls countCertificates
+    vargs.limit = 2 // set limit to 2
+    const fakeCerts: table.Certificate[] = [
+      {
+        certificateId: 11,
+        userId: 123,
+        type: 'base64Type',
+        serialNumber: 'sn',
+        certifier: 'abcdef01',
+        subject: 'deadbeef01',
+        verifier: undefined,
+        revocationOutpoint: '0000.0',
+        signature: 'abcdabcd',
+        isDeleted: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      },
+      {
+        certificateId: 22,
+        userId: 123,
+        type: 'base64Type',
+        serialNumber: 'sn2',
+        certifier: 'abcdef02',
+        subject: 'deadbeef02',
+        verifier: undefined,
+        revocationOutpoint: '0001.0',
+        signature: 'ef01ef01',
+        isDeleted: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      }
+    ]
+
+    // Suppose each cert has no fields
+    mockStorage.findCertificateFields.mockResolvedValue([])
+
+    // We return exactly 2 certs, which is == limit
+    mockStorage.findCertificates.mockResolvedValueOnce(fakeCerts)
+
+    // So the code should call countCertificates
+    mockStorage.countCertificates.mockResolvedValueOnce(25)
+
+    // Execute
+    const result = await listCertificates(mockStorage, auth, vargs)
+
+    // Verify
+    expect(mockStorage.findCertificates).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificateFields).toHaveBeenCalledTimes(2)
+    expect(mockStorage.countCertificates).toHaveBeenCalledTimes(1)
+
+    // We expect totalCertificates = 25 from countCertificates
+    expect(result.totalCertificates).toBe(25)
+    expect(result.certificates.length).toBe(2)
+  })
+
+  test('should handle transaction failure by throwing an error', async () => {
+    // If the transaction or the underlying findCertificates call fails, we rethrow
+    const error = new Error('Database error')
+    mockStorage.transaction.mockRejectedValueOnce(error)
+
+    await expect(listCertificates(mockStorage, auth, vargs)).rejects.toThrow(
+      'Database error'
+    )
+
+    // Verify mocks
+    expect(mockStorage.transaction).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificates).not.toHaveBeenCalled()
+    expect(mockStorage.findCertificateFields).not.toHaveBeenCalled()
+    expect(mockStorage.countCertificates).not.toHaveBeenCalled()
+  })
+
+  test('should handle scenario userId is undefined', async () => {
+    // Although typically userId is required, let's see what happens
+    // If userId is undefined, partial: { userId: undefined, isDeleted: false } is used
+    // The storage call might or might not blow up. We'll test that the code still calls the transaction
+    // We rely on the underlying findCertificates to throw or return an empty array.
+    auth.userId = undefined
+
+    mockStorage.findCertificates.mockResolvedValueOnce([])
+
+    const result = await listCertificates(mockStorage, auth, vargs)
+    expect(result).toEqual({
+      totalCertificates: 0,
+      certificates: []
+    })
+
+    // We see a normal call
+    expect(mockStorage.transaction).toHaveBeenCalledTimes(1)
+    expect(mockStorage.findCertificates).toHaveBeenCalledTimes(1)
+    // The partial would have userId: undefined
+    const arg0 = mockStorage.findCertificates.mock.calls[0][0]
+    expect(arg0.partial).toEqual({
+      userId: undefined,
+      isDeleted: false
+    })
+  })
+
+  test('if returned certificate count is bigger than limit, still only returns limit items but sets total using countCertificates', async () => {
+    // For completeness, if the storage findCertificates method returns exactly "limit" items,
+    // we do a count. But let's pretend it can return exactly limit or a bit more (some storages might do that incorrectly).
+    // We'll only test the scenario that triggers the "else" path. Already tested an =limit scenario above,
+    // but let's confirm the coverage if the function doesn't rely on partial storage returning partial results.
+    vargs.limit = 2
+
+    const cA: table.Certificate = {
+      certificateId: 100,
+      userId: 123,
+      type: 'zzz',
+      serialNumber: 'snA',
+      certifier: 'cA',
+      subject: 'sA',
+      verifier: undefined,
+      revocationOutpoint: 'nope.0',
+      signature: 'sigA',
+      isDeleted: false,
+      created_at: new Date(),
+      updated_at: new Date()
+    }
+    const cB: table.Certificate = {
+      certificateId: 101,
+      userId: 123,
+      type: 'yyy',
+      serialNumber: 'snB',
+      certifier: 'cB',
+      subject: 'sB',
+      verifier: undefined,
+      revocationOutpoint: 'nope.1',
+      signature: 'sigB',
+      isDeleted: false,
+      created_at: new Date(),
+      updated_at: new Date()
+    }
+    const cC: table.Certificate = {
+      certificateId: 102,
+      userId: 123,
+      type: 'xxx',
+      serialNumber: 'snC',
+      certifier: 'cC',
+      subject: 'sC',
+      verifier: undefined,
+      revocationOutpoint: 'nope.2',
+      signature: 'sigC',
+      isDeleted: false,
+      created_at: new Date(),
+      updated_at: new Date()
+    }
+
+    // Suppose the storage returned 3 items even though we only want 2.
+    // The code uses them all in memory, but sees length=3 which is > limit=2
+    // The line checks if (r.certificates.length < paged.limit). That is false, so it calls countCertificates.
+    mockStorage.findCertificates.mockResolvedValueOnce([cA, cB, cC])
+
+    // Fields are none
+    mockStorage.findCertificateFields.mockResolvedValue([])
+
+    // We want to see it call countCertificates
+    mockStorage.countCertificates.mockResolvedValueOnce(999)
+
+    const result = await listCertificates(mockStorage, auth, vargs)
+
+    expect(result.certificates.length).toBe(3)
+    expect(result.totalCertificates).toBe(999) // from countCertificates
+  })
+})

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

@@ -0,0 +1,79 @@
+import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+describe('getHeaderForHeight tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    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 })
+
+      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'
+
+describe('getHeight tests', () => {
+  jest.setTimeout(99999999)
+
+  const ctxs: any[] = []
+  const env = _tu.getEnv('test')
+
+  beforeAll(async () => {
+    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,90 @@
+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,28 @@
+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,28 @@
+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' })
+    }
+  })
+})