@bsv/sdk 2.0.11 → 2.0.13

package/src/remittance/__tests/BasicBRC29.additional.test.ts

@@ -0,0 +1,657 @@
+import type { ModuleContext } from '../types.js'
+import type { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import {
+  Brc29RemittanceModule,
+  DefaultNonceProvider,
+  DefaultLockingScriptProvider
+} from '../modules/BasicBRC29.js'
+
+const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { })
+
+const makeContext = (wallet: WalletInterface): ModuleContext => ({
+  wallet,
+  originator: 'example.com',
+  now: () => 123
+})
+
+const makeWallet = (overrides: Partial<WalletInterface> = {}): WalletInterface => ({
+  getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' })),
+  createAction: jest.fn(async () => ({ tx: [1, 2, 3] })),
+  internalizeAction: jest.fn(async () => ({ ok: true })),
+  ...overrides
+} as unknown as WalletInterface)
+
+const validSettlement = {
+  customInstructions: { derivationPrefix: 'prefix', derivationSuffix: 'suffix' },
+  transaction: [1, 2, 3],
+  amountSatoshis: 1000
+}
+
+// ---------------------------------------------------------------------------
+// buildSettlement – option validation edge cases
+// ---------------------------------------------------------------------------
+
+describe('Brc29RemittanceModule – buildSettlement option validation', () => {
+  it('terminates when option is null', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: null as any },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.invalid_option')
+    }
+  })
+
+  it('terminates when option is a non-object primitive', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: 'not-an-object' as any },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when amountSatoshis is a float (non-integer)', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 1.5, payee: 'payee' } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.invalid_option')
+    }
+  })
+
+  it('terminates when outputIndex is a negative integer', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', outputIndex: -1 } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when outputIndex is a float', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', outputIndex: 0.5 } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when protocolID is not an array', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', protocolID: 'bad' as any } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when protocolID has wrong array length', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', protocolID: [1] as any } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when protocolID has negative protocol number', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', protocolID: [-1, 'proto'] as any } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when protocolID string is empty', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', protocolID: [2, '   '] as any } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when labels contains an empty string', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', labels: ['valid', ''] } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when labels is not an array', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', labels: 'single-label' as any } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when description is an empty string', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk', description: '   ' } },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildSettlement – wallet-side failure paths
+// ---------------------------------------------------------------------------
+
+describe('Brc29RemittanceModule – buildSettlement wallet failures', () => {
+  it('terminates when getPublicKey returns an empty publicKey string', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '' }))
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: { createNonce: jest.fn().mockResolvedValue('nonce') },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '76a914abcd88ac') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 1000, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.public_key_missing')
+    }
+  })
+
+  it('terminates when getPublicKey returns a whitespace-only publicKey', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '   ' }))
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: { createNonce: jest.fn().mockResolvedValue('nonce') },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => 'script') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 1000, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.public_key_missing')
+    }
+  })
+
+  it('terminates when lockingScriptProvider returns an empty string', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' }))
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: { createNonce: jest.fn().mockResolvedValue('nonce') },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 1000, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.locking_script_missing')
+    }
+  })
+
+  it('terminates when lockingScriptProvider returns a whitespace-only string', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' }))
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: { createNonce: jest.fn().mockResolvedValue('nonce') },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '   ') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 1000, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.locking_script_missing')
+    }
+  })
+
+  it('settles successfully when createAction returns signableTransaction.tx instead of direct tx', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' })),
+      createAction: jest.fn(async () => ({
+        signableTransaction: { tx: [4, 5, 6], reference: 'cmVm' }
+      }))
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: {
+        createNonce: jest.fn()
+          .mockResolvedValueOnce('prefix')
+          .mockResolvedValueOnce('suffix')
+      },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '76a914deadbeef88ac') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 500, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    // signableTransaction.tx = [4, 5, 6] is a valid atomic BEEF array
+    expect(result.action).toBe('settle')
+    if (result.action === 'settle') {
+      expect(result.artifact.transaction).toEqual([4, 5, 6])
+    }
+  })
+
+  it('terminates when tx is not a valid byte array (contains non-byte values)', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' })),
+      createAction: jest.fn(async () => ({ tx: [256, 1, 2] })) // 256 is out of byte range
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: {
+        createNonce: jest.fn()
+          .mockResolvedValueOnce('p')
+          .mockResolvedValueOnce('s')
+      },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '76a914abcd88ac') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.invalid_tx')
+    }
+  })
+
+  it('terminates when tx is an empty array', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' })),
+      createAction: jest.fn(async () => ({ tx: [] })) // empty
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: {
+        createNonce: jest.fn()
+          .mockResolvedValueOnce('p')
+          .mockResolvedValueOnce('s')
+      },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '76a914abcd88ac') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.invalid_tx')
+    }
+  })
+
+  it('terminates when createAction throws an unexpected error', async () => {
+    const wallet = makeWallet({
+      getPublicKey: jest.fn(async () => ({ publicKey: '02deadbeef' })),
+      createAction: jest.fn(async () => { throw new Error('unexpected wallet error') })
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: {
+        createNonce: jest.fn()
+          .mockResolvedValueOnce('p')
+          .mockResolvedValueOnce('s')
+      },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '76a914abcd88ac') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 100, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.build_failed')
+      expect(result.termination.message).toContain('unexpected wallet error')
+    }
+  })
+
+  it('terminates when createNonce throws', async () => {
+    const wallet = makeWallet()
+    const module = new Brc29RemittanceModule({
+      nonceProvider: {
+        createNonce: jest.fn(async () => { throw new Error('nonce error') })
+      },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => 'script') }
+    })
+
+    const result = await module.buildSettlement(
+      { threadId: 'tid', option: { amountSatoshis: 500, payee: 'pk' } },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.build_failed')
+    }
+  })
+
+  it('uses option-level protocolID, labels, and description overrides', async () => {
+    const wallet = makeWallet({
+      createAction: jest.fn(async () => ({ tx: [7, 8, 9] }))
+    })
+    const module = new Brc29RemittanceModule({
+      nonceProvider: {
+        createNonce: jest.fn()
+          .mockResolvedValueOnce('pref')
+          .mockResolvedValueOnce('suf')
+      },
+      lockingScriptProvider: { pubKeyToP2PKHLockingScript: jest.fn(async () => '76a914abcd88ac') }
+    })
+
+    const result = await module.buildSettlement(
+      {
+        threadId: 'tid',
+        option: {
+          amountSatoshis: 777,
+          payee: 'pk',
+          protocolID: [1, 'custom-proto'],
+          labels: ['my-label'],
+          description: 'Custom description',
+          outputIndex: 2
+        }
+      },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('settle')
+    if (result.action === 'settle') {
+      expect(result.artifact.outputIndex).toBe(2)
+      expect(result.artifact.amountSatoshis).toBe(777)
+    }
+
+    // Verify getPublicKey was called with the option's protocolID
+    expect(wallet.getPublicKey).toHaveBeenCalledWith(
+      expect.objectContaining({ protocolID: [1, 'custom-proto'] }),
+      'example.com'
+    )
+
+    // Verify createAction was called with option's labels and description
+    const createArgs = (wallet.createAction as jest.Mock).mock.calls[0][0]
+    expect(createArgs.labels).toEqual(['my-label'])
+    expect(createArgs.description).toBe('Custom description')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// acceptSettlement – settlement validation edge cases
+// ---------------------------------------------------------------------------
+
+describe('Brc29RemittanceModule – acceptSettlement validation', () => {
+  it('terminates when settlement is null', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      { threadId: 'tid', settlement: null as any, sender: 'pk' },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+    if (result.action === 'terminate') {
+      expect(result.termination.code).toBe('brc29.internalize_failed')
+    }
+  })
+
+  it('terminates when settlement is a non-object primitive', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      { threadId: 'tid', settlement: 'not-an-object' as any, sender: 'pk' },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when customInstructions is missing', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: { transaction: [1, 2, 3], amountSatoshis: 100 } as any,
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when derivationPrefix is empty', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: '', derivationSuffix: 'suffix' },
+          transaction: [1, 2, 3],
+          amountSatoshis: 100
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when derivationSuffix is empty', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: 'prefix', derivationSuffix: '' },
+          transaction: [1, 2, 3],
+          amountSatoshis: 100
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when amountSatoshis is zero', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: 'p', derivationSuffix: 's' },
+          transaction: [1, 2, 3],
+          amountSatoshis: 0
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when amountSatoshis is negative', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: 'p', derivationSuffix: 's' },
+          transaction: [1, 2, 3],
+          amountSatoshis: -1
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when outputIndex is negative', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: 'p', derivationSuffix: 's' },
+          transaction: [1, 2, 3],
+          amountSatoshis: 1000,
+          outputIndex: -2
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when transaction is not a byte array (invalid bytes)', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: 'p', derivationSuffix: 's' },
+          transaction: [256, 0, 1], // 256 is out of range
+          amountSatoshis: 1000
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('terminates when transaction is an empty array', async () => {
+    const module = new Brc29RemittanceModule()
+    const result = await module.acceptSettlement(
+      {
+        threadId: 'tid',
+        settlement: {
+          customInstructions: { derivationPrefix: 'p', derivationSuffix: 's' },
+          transaction: [],
+          amountSatoshis: 1000
+        },
+        sender: 'pk'
+      },
+      makeContext(makeWallet())
+    )
+    expect(result.action).toBe('terminate')
+  })
+
+  it('uses outputIndex=0 by default when outputIndex is undefined', async () => {
+    const internalizeAction = jest.fn(async () => ({ accepted: true as const }))
+    const wallet = makeWallet({ internalizeAction })
+    const module = new Brc29RemittanceModule()
+
+    const result = await module.acceptSettlement(
+      { threadId: 'tid', settlement: { ...validSettlement }, sender: 'sender-key' },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('accept')
+    expect(internalizeAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        outputs: [expect.objectContaining({ outputIndex: 0 })]
+      }),
+      'example.com'
+    )
+  })
+
+  it('uses basket insertion internalizeProtocol when configured', async () => {
+    const internalizeAction = jest.fn(async () => ({ accepted: true as const }))
+    const wallet = makeWallet({ internalizeAction })
+    const module = new Brc29RemittanceModule({ internalizeProtocol: 'basket insertion' })
+
+    const result = await module.acceptSettlement(
+      { threadId: 'tid', settlement: { ...validSettlement }, sender: 'sender-key' },
+      makeContext(wallet)
+    )
+    expect(result.action).toBe('accept')
+    expect(internalizeAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        outputs: [expect.objectContaining({ protocol: 'basket insertion' })]
+      }),
+      'example.com'
+    )
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Constructor defaults
+// ---------------------------------------------------------------------------
+
+describe('Brc29RemittanceModule – constructor defaults', () => {
+  it('has expected default property values', () => {
+    const module = new Brc29RemittanceModule()
+    expect(module.id).toBe('brc29.p2pkh')
+    expect(module.name).toBe('BSV (BRC-29 derived P2PKH)')
+    expect(module.allowUnsolicitedSettlements).toBe(true)
+    expect((module as any).protocolID).toEqual([2, '3241645161d8'])
+    expect((module as any).labels).toEqual(['brc29'])
+    expect((module as any).description).toBe('BRC-29 payment')
+    expect((module as any).outputDescription).toBe('Payment for remittance invoice')
+    expect((module as any).refundFeeSatoshis).toBe(1000)
+    expect((module as any).minRefundSatoshis).toBe(1000)
+    expect((module as any).internalizeProtocol).toBe('wallet payment')
+  })
+
+  it('accepts config overrides for all properties', () => {
+    const customNonce = { createNonce: jest.fn() }
+    const customScript = { pubKeyToP2PKHLockingScript: jest.fn() }
+    const module = new Brc29RemittanceModule({
+      protocolID: [1, 'custom'],
+      labels: ['lbl'],
+      description: 'desc',
+      outputDescription: 'out-desc',
+      refundFeeSatoshis: 500,
+      minRefundSatoshis: 200,
+      internalizeProtocol: 'basket insertion',
+      nonceProvider: customNonce,
+      lockingScriptProvider: customScript
+    })
+    expect((module as any).protocolID).toEqual([1, 'custom'])
+    expect((module as any).labels).toEqual(['lbl'])
+    expect((module as any).description).toBe('desc')
+    expect((module as any).outputDescription).toBe('out-desc')
+    expect((module as any).refundFeeSatoshis).toBe(500)
+    expect((module as any).minRefundSatoshis).toBe(200)
+    expect((module as any).internalizeProtocol).toBe('basket insertion')
+    expect((module as any).nonceProvider).toBe(customNonce)
+    expect((module as any).lockingScriptProvider).toBe(customScript)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// DefaultNonceProvider and DefaultLockingScriptProvider are exported;
+// test that they satisfy the interfaces (smoke tests only – actual crypto
+// tested elsewhere).
+// ---------------------------------------------------------------------------
+
+describe('DefaultNonceProvider and DefaultLockingScriptProvider', () => {
+  it('DefaultNonceProvider.createNonce delegates to createNonce util', async () => {
+    const fakeWallet = {
+      createHmac: jest.fn(async () => ({ data: new Array(32).fill(0) }))
+    } as unknown as WalletInterface
+    // createNonce will fail without real wallet; just ensure the function exists and is async
+    await expect(
+      DefaultNonceProvider.createNonce(fakeWallet, 'self', 'example.com')
+    ).rejects.toBeDefined() // real createNonce needs full wallet
+  })
+
+  it('DefaultLockingScriptProvider has pubKeyToP2PKHLockingScript method', () => {
+    expect(typeof DefaultLockingScriptProvider.pubKeyToP2PKHLockingScript).toBe('function')
+  })
+})