@bopen-io/wallet-toolbox 1.7.18

package/test/Wallet/action/relinquishOutput.test.ts

@@ -0,0 +1,37 @@
+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/certificate/acquireCertificate.test.ts

@@ -0,0 +1,298 @@
+import {
+  AcquireCertificateArgs,
+  Certificate,
+  MasterCertificate,
+  ProtoWallet,
+  ProveCertificateArgs,
+  VerifiableCertificate
+} from '@bsv/sdk'
+import { _tu, expectToThrowWERR } from '../../utils/TestUtilsWalletStorage'
+import { sdk, Wallet } from '../../../src/index.all'
+
+describe('acquireCertificate tests', () => {
+  jest.setTimeout(99999999)
+
+  test('00', () => {})
+  if (_tu.noEnv('test')) return
+
+  const env = _tu.getEnv('test')
+
+  beforeAll(async () => {})
+
+  afterAll(async () => {})
+
+  test('1 invalid params', async () => {
+    const { wallet, storage } = await _tu.createLegacyWalletSQLiteCopy('acquireCertificate1')
+
+    const invalidArgs: AcquireCertificateArgs[] = [
+      {
+        type: '',
+        certifier: '',
+        acquisitionProtocol: 'direct',
+        fields: {}
+      }
+      // Oh so many things to test...
+    ]
+
+    for (const args of invalidArgs) {
+      await expectToThrowWERR(sdk.WERR_INVALID_PARAMETER, () => wallet.acquireCertificate(args))
+    }
+
+    await storage.destroy()
+  })
+
+  test('2 acquireCertificate listCertificate proveCertificate', async () => {
+    const { wallet, storage } = await _tu.createSQLiteTestWallet({
+      databaseName: 'acquireCertificate2',
+      dropAll: true
+    })
+
+    // Make a test certificate from a random certifier for the wallet's identityKey
+    const subject = wallet.keyDeriver.identityKey
+    const { cert: wcert, certifier } = _tu.makeSampleCert(subject)
+
+    // Act as the certifier: create a wallet for them...
+    const certifierWallet = new ProtoWallet(certifier)
+
+    const cert = new Certificate(
+      wcert.type,
+      wcert.serialNumber,
+      wcert.subject,
+      wcert.certifier,
+      wcert.revocationOutpoint,
+      wcert.fields
+    )
+
+    const r1 = await MasterCertificate.createCertificateFields(certifierWallet, subject, cert.fields)
+    const signedCert = new Certificate(
+      wcert.type,
+      wcert.serialNumber,
+      wcert.subject,
+      wcert.certifier,
+      wcert.revocationOutpoint,
+      r1.certificateFields
+    )
+    await signedCert.sign(certifierWallet)
+
+    const c = signedCert
+    // args object to create a new certificate via 'direct' protocol.
+    const args: AcquireCertificateArgs = {
+      serialNumber: c.serialNumber,
+      signature: c.signature,
+      privileged: false,
+      privilegedReason: undefined,
+
+      type: c.type,
+      certifier: c.certifier,
+      acquisitionProtocol: 'direct',
+      fields: c.fields,
+      keyringForSubject: r1.masterKeyring,
+      keyringRevealer: 'certifier',
+      revocationOutpoint: c.revocationOutpoint
+    }
+    // store the new signed certificate in user's wallet
+    const r = await wallet.acquireCertificate(args)
+    expect(r.serialNumber).toBe(c.serialNumber)
+
+    // Attempt to retrieve it... since
+    // the certifier is random this should
+    // always be unique :-)
+    const lcs = await wallet.listCertificates({
+      certifiers: [cert.certifier],
+      types: []
+    })
+    expect(lcs.certificates.length).toBe(1)
+    const lc = lcs.certificates[0]
+    // the result should be encrypted.
+    expect(lc.fields['name']).not.toBe('Alice')
+
+    // Use proveCertificate to obtain a decryption keyring:
+    const pkrArgs: ProveCertificateArgs = {
+      certificate: { serialNumber: lc.serialNumber },
+      fieldsToReveal: ['name'],
+      verifier: subject
+    }
+    const pkr = await wallet.proveCertificate(pkrArgs)
+
+    const veriCert = new VerifiableCertificate(
+      lc.type,
+      lc.serialNumber,
+      lc.subject,
+      lc.certifier,
+      lc.revocationOutpoint,
+      lc.fields,
+      pkr.keyringForVerifier,
+      lc.signature
+    )
+
+    const r4 = await veriCert.decryptFields(wallet)
+    expect(r4['name']).toBe('Alice')
+
+    const certs = await wallet.listCertificates({ types: [], certifiers: [] })
+    for (const cert of certs.certificates) {
+      const rr = await wallet.relinquishCertificate({
+        type: cert.type,
+        serialNumber: cert.serialNumber,
+        certifier: cert.certifier
+      })
+      expect(rr.relinquished).toBe(true)
+    }
+    await storage.destroy()
+  })
+
+  test('3 privileged acquireCertificate listCertificate proveCertificate', async () => {
+    const { wallet, storage } = await _tu.createSQLiteTestWallet({
+      databaseName: 'acquireCertificate3',
+      privKeyHex: '42'.repeat(32),
+      dropAll: true
+    })
+
+    // Make a test certificate from a random certifier for the wallet's identityKey
+
+    // Certificate issued to the privileged key must use the privilegedKeyManager's identityKey
+    const subject = (await wallet.privilegedKeyManager!.getPublicKey({ identityKey: true })).publicKey
+    const { cert: wcert, certifier } = _tu.makeSampleCert(subject)
+
+    // Act as the certifier: create a wallet for them...
+    const certifierWallet = new ProtoWallet(certifier)
+
+    const cert = new Certificate(
+      wcert.type,
+      wcert.serialNumber,
+      wcert.subject,
+      wcert.certifier,
+      wcert.revocationOutpoint,
+      wcert.fields
+    )
+
+    const r1 = await MasterCertificate.createCertificateFields(certifierWallet, subject, cert.fields)
+    const signedCert = new Certificate(
+      wcert.type,
+      wcert.serialNumber,
+      wcert.subject,
+      wcert.certifier,
+      wcert.revocationOutpoint,
+      r1.certificateFields
+    )
+    await signedCert.sign(certifierWallet)
+
+    const c = signedCert
+
+    // args object to create a new certificate via 'direct' protocol.
+    const args: AcquireCertificateArgs = {
+      serialNumber: c.serialNumber,
+      signature: c.signature,
+      privileged: true,
+      privilegedReason: 'access to my penthouse',
+
+      type: c.type,
+      certifier: c.certifier,
+      acquisitionProtocol: 'direct',
+      fields: c.fields,
+      keyringForSubject: r1.masterKeyring,
+      keyringRevealer: 'certifier',
+      revocationOutpoint: c.revocationOutpoint
+    }
+    // store the new signed certificate in user's wallet
+    const r = await wallet.acquireCertificate(args)
+    expect(r.serialNumber).toBe(c.serialNumber)
+
+    // Attempt to retrieve it... since
+    // the certifier is random this should
+    // always be unique :-)
+    const lcs = await wallet.listCertificates({
+      certifiers: [cert.certifier],
+      types: []
+    })
+    expect(lcs.certificates.length).toBe(1)
+    const lc = lcs.certificates[0]
+    // the result should be encrypted.
+    expect(lc.fields['name']).not.toBe('Alice')
+
+    // Use proveCertificate to obtain a decryption keyring:
+    const pkrArgs: ProveCertificateArgs = {
+      certificate: { serialNumber: lc.serialNumber },
+      fieldsToReveal: ['name'],
+      verifier: subject,
+      privileged: true,
+      privilegedReason: 'more cheese'
+    }
+    const pkr = await wallet.proveCertificate(pkrArgs)
+
+    const veriCert = new VerifiableCertificate(
+      lc.type,
+      lc.serialNumber,
+      lc.subject,
+      lc.certifier,
+      lc.revocationOutpoint,
+      lc.fields,
+      pkr.keyringForVerifier,
+      lc.signature
+    )
+
+    const r4 = await veriCert.decryptFields(wallet, true, 'more cheese')
+    expect(r4['name']).toBe('Alice')
+
+    const certs = await wallet.listCertificates({ types: [], certifiers: [] })
+    for (const cert of certs.certificates) {
+      const rr = await wallet.relinquishCertificate({
+        type: cert.type,
+        serialNumber: cert.serialNumber,
+        certifier: cert.certifier
+      })
+      expect(rr.relinquished).toBe(true)
+    }
+
+    // Also cleans up the privilegedKeyManager
+    await wallet.destroy()
+  })
+
+  /**
+   * NOTE: This test requires a generic-certifier-backend to be running
+   * with the following configuration:
+   *
+   *  type: 'h53Tvo8w3nqeF2cPyuRUc/B+gjPXJ3gPS2PKFBZfpDw=',
+   *  certifierIdentityKey: '02be1093d98689b5a5bb49cefff5d98a390213cc5b0a5cd57459407f86a963325f',
+   */
+  test.skip('acquireCertificate via issuance', async () => {
+    const { wallet, storage } = await _tu.createSQLiteTestWallet({
+      databaseName: 'acquireCertificate2',
+      dropAll: true
+    })
+    // Attributes to get certified
+    const fields = {
+      name: 'Bob',
+      email: 'bob@projectbabbage.com'
+    }
+
+    // args object to create a new certificate via 'issuance' protocol.
+    const args: AcquireCertificateArgs = {
+      type: 'h53Tvo8w3nqeF2cPyuRUc/B+gjPXJ3gPS2PKFBZfpDw=',
+      certifier: '02be1093d98689b5a5bb49cefff5d98a390213cc5b0a5cd57459407f86a963325f',
+      certifierUrl: 'http://localhost:3998',
+      acquisitionProtocol: 'issuance',
+      fields: fields
+    }
+    // store the new signed certificate in user's wallet
+    const r = await wallet.acquireCertificate(args)
+    const certificatesFound = await wallet.listCertificates({
+      certifiers: [args.certifier],
+      types: []
+    })
+    expect(certificatesFound.certificates.length).toBe(1)
+    const lc = certificatesFound.certificates[0]
+    // the result should be encrypted.
+    expect(lc.fields['name']).not.toBe('Alice')
+
+    // const certs = await wallet.listCertificates({ types: [], certifiers: [] })
+    for (const cert of certificatesFound.certificates) {
+      const rr = await wallet.relinquishCertificate({
+        type: cert.type,
+        serialNumber: cert.serialNumber,
+        certifier: cert.certifier
+      })
+      expect(rr.relinquished).toBe(true)
+    }
+    await storage.destroy()
+  })
+})

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

@@ -0,0 +1,346 @@
+import { OriginatorDomainNameStringUnder250Bytes, Validation } from '@bsv/sdk'
+import { listCertificates } from '../../../src/storage/methods/listCertificates'
+import { StorageProvider } from '../../../src/storage/StorageProvider'
+import { sdk, TableCertificate, TableCertificateField } 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: Validation.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: TableCertificate[] = [
+      {
+        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: TableCertificateField[] = [
+      {
+        certificateId: 1,
+        userId: 123,
+        fieldName: 'field1',
+        fieldValue: 'value1',
+        masterKey: 'mkey1',
+        created_at: new Date(),
+        updated_at: new Date()
+      }
+    ]
+
+    const fakeFieldsForCert2: TableCertificateField[] = [
+      {
+        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: TableCertificate[] = [
+      {
+        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: TableCertificate = {
+      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: TableCertificate = {
+      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: TableCertificate = {
+      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
+  })
+})