@bsv/sdk 2.0.12 → 2.0.13

package/src/wallet/__tests/WalletClient.substrate.test.ts

@@ -0,0 +1,759 @@
+/**
+ * WalletClient substrate delegation tests.
+ *
+ * These tests exercise every public method that ultimately delegates to the
+ * substrate object (lines 215-370 and 446-499 of WalletClient.ts).  Each test
+ * bypasses the real `connectToSubstrate()` logic by pre-injecting a mock
+ * substrate directly onto the instance, which avoids any real network I/O.
+ */
+
+import WalletClient from '../WalletClient'
+import type { WalletInterface } from '../Wallet.interfaces'
+
+// ---------------------------------------------------------------------------
+// Helper: create a fully-mocked substrate and an already-connected WalletClient
+// ---------------------------------------------------------------------------
+
+function buildMockSubstrate (): jest.Mocked<WalletInterface> {
+  return {
+    createAction: jest.fn(),
+    signAction: jest.fn(),
+    abortAction: jest.fn(),
+    listActions: jest.fn(),
+    internalizeAction: jest.fn(),
+    listOutputs: jest.fn(),
+    relinquishOutput: jest.fn(),
+    getPublicKey: jest.fn(),
+    revealCounterpartyKeyLinkage: jest.fn(),
+    revealSpecificKeyLinkage: jest.fn(),
+    encrypt: jest.fn(),
+    decrypt: jest.fn(),
+    createHmac: jest.fn(),
+    verifyHmac: jest.fn(),
+    createSignature: jest.fn(),
+    verifySignature: jest.fn(),
+    acquireCertificate: jest.fn(),
+    listCertificates: jest.fn(),
+    proveCertificate: jest.fn(),
+    relinquishCertificate: jest.fn(),
+    discoverByIdentityKey: jest.fn(),
+    discoverByAttributes: jest.fn(),
+    isAuthenticated: jest.fn(),
+    waitForAuthentication: jest.fn(),
+    getHeight: jest.fn(),
+    getHeaderForHeight: jest.fn(),
+    getNetwork: jest.fn(),
+    getVersion: jest.fn(),
+  } as jest.Mocked<WalletInterface>
+}
+
+/** Creates a WalletClient whose substrate is already the given mock object. */
+function clientWith (mock: jest.Mocked<WalletInterface>, originator = 'test.origin'): WalletClient {
+  const client = new WalletClient(mock, originator)
+  return client
+}
+
+// ---------------------------------------------------------------------------
+// relinquishOutput
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.relinquishOutput – substrate delegation', () => {
+  it('delegates to substrate.relinquishOutput and returns its result', async () => {
+    const mock = buildMockSubstrate()
+    mock.relinquishOutput.mockResolvedValue({ relinquished: true })
+    const client = clientWith(mock)
+
+    const result = await client.relinquishOutput({
+      basket: 'default',
+      output: 'a'.repeat(64) + '.0',
+    })
+
+    expect(result).toEqual({ relinquished: true })
+    expect(mock.relinquishOutput).toHaveBeenCalledTimes(1)
+    expect(mock.relinquishOutput).toHaveBeenCalledWith(
+      { basket: 'default', output: 'a'.repeat(64) + '.0' },
+      'test.origin'
+    )
+  })
+
+  it('propagates errors thrown by the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.relinquishOutput.mockRejectedValue(new Error('substrate error'))
+    const client = clientWith(mock)
+
+    await expect(
+      client.relinquishOutput({ basket: 'default', output: 'a'.repeat(64) + '.0' })
+    ).rejects.toThrow('substrate error')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getPublicKey
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.getPublicKey – substrate delegation', () => {
+  it('returns the public key from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    const expectedKey = 'aa'.repeat(33)
+    mock.getPublicKey.mockResolvedValue({ publicKey: expectedKey })
+    const client = clientWith(mock)
+
+    const result = await client.getPublicKey({ identityKey: true })
+
+    expect(result).toEqual({ publicKey: expectedKey })
+    expect(mock.getPublicKey).toHaveBeenCalledWith({ identityKey: true }, 'test.origin')
+  })
+
+  it('passes protocolID and keyID through to the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.getPublicKey.mockResolvedValue({ publicKey: 'bb'.repeat(33) })
+    const client = clientWith(mock)
+
+    await client.getPublicKey({
+      protocolID: [2, 'my-protocol'],
+      keyID: '1',
+      counterparty: 'self',
+    })
+
+    expect(mock.getPublicKey).toHaveBeenCalledWith(
+      { protocolID: [2, 'my-protocol'], keyID: '1', counterparty: 'self' },
+      'test.origin'
+    )
+  })
+})
+
+// ---------------------------------------------------------------------------
+// revealCounterpartyKeyLinkage
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.revealCounterpartyKeyLinkage – substrate delegation', () => {
+  it('delegates and returns the linkage result', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = {
+      prover: 'aa'.repeat(33),
+      verifier: 'bb'.repeat(33),
+      counterparty: 'cc'.repeat(33),
+      revelationTime: '2024-01-01T00:00:00.000Z',
+      encryptedLinkage: [1, 2, 3],
+      encryptedLinkageProof: [4, 5, 6],
+    }
+    mock.revealCounterpartyKeyLinkage.mockResolvedValue(fakeResult)
+    const client = clientWith(mock)
+
+    const args = {
+      counterparty: 'cc'.repeat(33),
+      verifier: 'bb'.repeat(33),
+    }
+    const result = await client.revealCounterpartyKeyLinkage(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.revealCounterpartyKeyLinkage).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// revealSpecificKeyLinkage
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.revealSpecificKeyLinkage – substrate delegation', () => {
+  it('delegates and returns the specific linkage result', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = {
+      prover: 'aa'.repeat(33),
+      verifier: 'bb'.repeat(33),
+      counterparty: 'cc'.repeat(33),
+      protocolID: [1, 'proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+      encryptedLinkage: [1],
+      encryptedLinkageProof: [2],
+      proofType: 1,
+    }
+    mock.revealSpecificKeyLinkage.mockResolvedValue(fakeResult)
+    const client = clientWith(mock)
+
+    const args = {
+      counterparty: 'cc'.repeat(33),
+      verifier: 'bb'.repeat(33),
+      protocolID: [1, 'proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.revealSpecificKeyLinkage(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.revealSpecificKeyLinkage).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// encrypt / decrypt
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.encrypt – substrate delegation', () => {
+  it('returns ciphertext from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.encrypt.mockResolvedValue({ ciphertext: [9, 8, 7] })
+    const client = clientWith(mock)
+
+    const args = {
+      plaintext: [1, 2, 3],
+      protocolID: [1, 'enc-proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.encrypt(args)
+
+    expect(result).toEqual({ ciphertext: [9, 8, 7] })
+    expect(mock.encrypt).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+describe('WalletClient.decrypt – substrate delegation', () => {
+  it('returns plaintext from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.decrypt.mockResolvedValue({ plaintext: [42] })
+    const client = clientWith(mock)
+
+    const args = {
+      ciphertext: [9, 8, 7],
+      protocolID: [1, 'enc-proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.decrypt(args)
+
+    expect(result).toEqual({ plaintext: [42] })
+    expect(mock.decrypt).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// createHmac / verifyHmac
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.createHmac – substrate delegation', () => {
+  it('returns hmac bytes from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.createHmac.mockResolvedValue({ hmac: [0, 1, 2, 3] })
+    const client = clientWith(mock)
+
+    const args = {
+      data: [10, 20],
+      protocolID: [2, 'hmac-proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.createHmac(args)
+
+    expect(result).toEqual({ hmac: [0, 1, 2, 3] })
+    expect(mock.createHmac).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+describe('WalletClient.verifyHmac – substrate delegation', () => {
+  it('returns { valid: true } from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.verifyHmac.mockResolvedValue({ valid: true })
+    const client = clientWith(mock)
+
+    const args = {
+      data: [10, 20],
+      hmac: [0, 1, 2, 3],
+      protocolID: [2, 'hmac-proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.verifyHmac(args)
+
+    expect(result).toEqual({ valid: true })
+    expect(mock.verifyHmac).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// createSignature / verifySignature
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.createSignature – substrate delegation', () => {
+  it('returns signature bytes from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.createSignature.mockResolvedValue({ signature: [5, 6, 7] })
+    const client = clientWith(mock)
+
+    const args = {
+      data: [1, 2],
+      protocolID: [1, 'sig-proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.createSignature(args)
+
+    expect(result).toEqual({ signature: [5, 6, 7] })
+    expect(mock.createSignature).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+describe('WalletClient.verifySignature – substrate delegation', () => {
+  it('returns { valid: true } from the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.verifySignature.mockResolvedValue({ valid: true })
+    const client = clientWith(mock)
+
+    const args = {
+      data: [1, 2],
+      signature: [5, 6, 7],
+      protocolID: [1, 'sig-proto'] as [0 | 1 | 2, string],
+      keyID: '1',
+    }
+    const result = await client.verifySignature(args)
+
+    expect(result).toEqual({ valid: true })
+    expect(mock.verifySignature).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// acquireCertificate
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.acquireCertificate – substrate delegation', () => {
+  const baseCert = {
+    type: 'dHlwZQ==',
+    certifier: 'aa'.repeat(33),
+    fields: { name: 'alice' },
+    acquisitionProtocol: 'direct' as const,
+    serialNumber: 'c2VyaWFs',
+    revocationOutpoint: 'a'.repeat(64) + '.0',
+    signature: 'aabb',
+    keyringRevealer: 'certifier' as const,
+    keyringForSubject: {},
+  }
+
+  it('delegates direct acquisition to substrate and returns result', async () => {
+    const mock = buildMockSubstrate()
+    mock.acquireCertificate.mockResolvedValue({ ...baseCert } as any)
+    const client = clientWith(mock)
+
+    const result = await client.acquireCertificate(baseCert)
+
+    expect(result).toMatchObject({ type: 'dHlwZQ==' })
+    expect(mock.acquireCertificate).toHaveBeenCalledWith(baseCert, 'test.origin')
+  })
+
+  it('delegates issuance acquisition to substrate', async () => {
+    const mock = buildMockSubstrate()
+    const issuanceCert = {
+      type: 'dHlwZQ==',
+      certifier: 'aa'.repeat(33),
+      fields: {},
+      acquisitionProtocol: 'issuance' as const,
+      certifierUrl: 'https://certifier.example.com',
+    }
+    mock.acquireCertificate.mockResolvedValue(issuanceCert as any)
+    const client = clientWith(mock)
+
+    const result = await client.acquireCertificate(issuanceCert)
+
+    expect(mock.acquireCertificate).toHaveBeenCalledWith(issuanceCert, 'test.origin')
+    expect(result).toMatchObject({ acquisitionProtocol: 'issuance' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listCertificates
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.listCertificates – substrate delegation', () => {
+  it('delegates to substrate and returns the certificate list', async () => {
+    const mock = buildMockSubstrate()
+    const fakeList = { certificates: [], totalCertificates: 0 }
+    mock.listCertificates.mockResolvedValue(fakeList)
+    const client = clientWith(mock)
+
+    const args = { certifiers: ['aa'.repeat(33)], types: ['dHlwZQ=='] }
+    const result = await client.listCertificates(args)
+
+    expect(result).toEqual(fakeList)
+    expect(mock.listCertificates).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// proveCertificate
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.proveCertificate – substrate delegation', () => {
+  it('delegates to substrate and returns prove result', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { keyringForVerifier: {} }
+    mock.proveCertificate.mockResolvedValue(fakeResult as any)
+    const client = clientWith(mock)
+
+    const args = {
+      certificate: {
+        type: 'dHlwZQ==',
+        certifier: 'aa'.repeat(33),
+        serialNumber: 'c2VyaWFs',
+        fields: {},
+        subject: 'bb'.repeat(33),
+        revocationOutpoint: 'a'.repeat(64) + '.0',
+        signature: 'aabb',
+      } as any,
+      fieldsToReveal: ['name'],
+      verifier: 'cc'.repeat(33),
+    }
+    const result = await client.proveCertificate(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.proveCertificate).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// relinquishCertificate
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.relinquishCertificate – substrate delegation', () => {
+  it('delegates to substrate and returns relinquished result', async () => {
+    const mock = buildMockSubstrate()
+    mock.relinquishCertificate.mockResolvedValue({ relinquished: true })
+    const client = clientWith(mock)
+
+    const args = {
+      type: 'dHlwZQ==',
+      serialNumber: 'c2VyaWFs',
+      certifier: 'aa'.repeat(33),
+    }
+    const result = await client.relinquishCertificate(args)
+
+    expect(result).toEqual({ relinquished: true })
+    expect(mock.relinquishCertificate).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// discoverByIdentityKey
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.discoverByIdentityKey – substrate delegation', () => {
+  it('delegates to substrate and returns discovered certificates', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { certificates: [], totalCertificates: 0 }
+    mock.discoverByIdentityKey.mockResolvedValue(fakeResult)
+    const client = clientWith(mock)
+
+    const args = { identityKey: 'aa'.repeat(33) }
+    const result = await client.discoverByIdentityKey(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.discoverByIdentityKey).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// discoverByAttributes
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.discoverByAttributes – substrate delegation', () => {
+  it('delegates to substrate and returns discovered certificates', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { certificates: [], totalCertificates: 0 }
+    mock.discoverByAttributes.mockResolvedValue(fakeResult)
+    const client = clientWith(mock)
+
+    const args = { attributes: { name: 'alice' } }
+    const result = await client.discoverByAttributes(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.discoverByAttributes).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isAuthenticated
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.isAuthenticated – substrate delegation', () => {
+  it('delegates to substrate and returns authenticated status', async () => {
+    const mock = buildMockSubstrate()
+    mock.isAuthenticated.mockResolvedValue({ authenticated: true })
+    const client = clientWith(mock)
+
+    const result = await client.isAuthenticated({})
+
+    expect(result).toEqual({ authenticated: true })
+    expect(mock.isAuthenticated).toHaveBeenCalledWith({}, 'test.origin')
+  })
+
+  it('uses default empty object when no args provided', async () => {
+    const mock = buildMockSubstrate()
+    mock.isAuthenticated.mockResolvedValue({ authenticated: false } as any)
+    const client = clientWith(mock)
+
+    const result = await client.isAuthenticated()
+
+    expect(result).toEqual({ authenticated: false })
+    expect(mock.isAuthenticated).toHaveBeenCalledWith({}, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// waitForAuthentication
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.waitForAuthentication – substrate delegation', () => {
+  it('delegates to substrate and resolves when authenticated', async () => {
+    const mock = buildMockSubstrate()
+    mock.waitForAuthentication.mockResolvedValue({ authenticated: true })
+    const client = clientWith(mock)
+
+    const result = await client.waitForAuthentication({})
+
+    expect(result).toEqual({ authenticated: true })
+    expect(mock.waitForAuthentication).toHaveBeenCalledWith({}, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getHeight
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.getHeight – substrate delegation', () => {
+  it('returns current block height from substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.getHeight.mockResolvedValue({ height: 800000 })
+    const client = clientWith(mock)
+
+    const result = await client.getHeight({})
+
+    expect(result).toEqual({ height: 800000 })
+    expect(mock.getHeight).toHaveBeenCalledWith({}, 'test.origin')
+  })
+
+  it('uses default empty object when no args provided', async () => {
+    const mock = buildMockSubstrate()
+    mock.getHeight.mockResolvedValue({ height: 1 })
+    const client = clientWith(mock)
+
+    await client.getHeight()
+
+    expect(mock.getHeight).toHaveBeenCalledWith({}, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getHeaderForHeight
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.getHeaderForHeight – substrate delegation', () => {
+  it('returns block header hex from substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.getHeaderForHeight.mockResolvedValue({ header: 'deadbeef' })
+    const client = clientWith(mock)
+
+    const result = await client.getHeaderForHeight({ height: 800000 })
+
+    expect(result).toEqual({ header: 'deadbeef' })
+    expect(mock.getHeaderForHeight).toHaveBeenCalledWith({ height: 800000 }, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getNetwork
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.getNetwork – substrate delegation', () => {
+  it('returns mainnet from substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.getNetwork.mockResolvedValue({ network: 'mainnet' })
+    const client = clientWith(mock)
+
+    const result = await client.getNetwork({})
+
+    expect(result).toEqual({ network: 'mainnet' })
+    expect(mock.getNetwork).toHaveBeenCalledWith({}, 'test.origin')
+  })
+
+  it('returns testnet from substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.getNetwork.mockResolvedValue({ network: 'testnet' })
+    const client = clientWith(mock)
+
+    const result = await client.getNetwork()
+
+    expect(result).toEqual({ network: 'testnet' })
+    expect(mock.getNetwork).toHaveBeenCalledWith({}, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getVersion
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.getVersion – substrate delegation', () => {
+  it('returns version string from substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.getVersion.mockResolvedValue({ version: '1.0.0.0.0.0.0' })
+    const client = clientWith(mock)
+
+    const result = await client.getVersion({})
+
+    expect(result).toEqual({ version: '1.0.0.0.0.0.0' })
+    expect(mock.getVersion).toHaveBeenCalledWith({}, 'test.origin')
+  })
+
+  it('uses default empty object when no args provided', async () => {
+    const mock = buildMockSubstrate()
+    mock.getVersion.mockResolvedValue({ version: '2.0.0.0.0.0.0' })
+    const client = clientWith(mock)
+
+    await client.getVersion()
+
+    expect(mock.getVersion).toHaveBeenCalledWith({}, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// createAction – successful delegation
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.createAction – substrate delegation', () => {
+  it('delegates a valid createAction call to the substrate', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { txid: 'abc123', tx: [1, 2, 3] }
+    mock.createAction.mockResolvedValue(fakeResult as any)
+    const client = clientWith(mock)
+
+    const args = { description: 'hello world' }
+    const result = await client.createAction(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.createAction).toHaveBeenCalledWith(args, 'test.origin')
+  })
+
+  it('passes originator undefined when no originator was set', async () => {
+    const mock = buildMockSubstrate()
+    mock.createAction.mockResolvedValue({ txid: 'xyz' } as any)
+    // Create the client by passing the mock object directly (no originator)
+    const client = new WalletClient(mock)
+
+    await client.createAction({ description: 'hello world' })
+
+    expect(mock.createAction).toHaveBeenCalledWith({ description: 'hello world' }, undefined)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// signAction – successful delegation
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.signAction – substrate delegation', () => {
+  it('delegates a valid signAction call to the substrate', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { txid: 'signed123', tx: [1, 2, 3] }
+    mock.signAction.mockResolvedValue(fakeResult as any)
+    const client = clientWith(mock)
+
+    const args = { spends: {}, reference: 'cmVm' }
+    const result = await client.signAction(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.signAction).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// abortAction – successful delegation
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.abortAction – substrate delegation', () => {
+  it('delegates a valid abortAction call to the substrate', async () => {
+    const mock = buildMockSubstrate()
+    mock.abortAction.mockResolvedValue({ aborted: true })
+    const client = clientWith(mock)
+
+    const result = await client.abortAction({ reference: 'cmVm' })
+
+    expect(result).toEqual({ aborted: true })
+    expect(mock.abortAction).toHaveBeenCalledWith({ reference: 'cmVm' }, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listActions – successful delegation
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.listActions – substrate delegation', () => {
+  it('delegates to substrate and returns action list', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { actions: [], totalActions: 0 }
+    mock.listActions.mockResolvedValue(fakeResult)
+    const client = clientWith(mock)
+
+    const args = { labels: ['my-label'] }
+    const result = await client.listActions(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.listActions).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// internalizeAction – successful delegation
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.internalizeAction – substrate delegation', () => {
+  it('delegates to substrate and returns accepted result', async () => {
+    const mock = buildMockSubstrate()
+    mock.internalizeAction.mockResolvedValue({ accepted: true })
+    const client = clientWith(mock)
+
+    // Minimal valid AtomicBEEF: BEEF_V2 header + 0 bumps + 1 txid-only tx
+    // BEEF_V2 = 4022206466 (0xEFBE0002) in little-endian = [2, 0, 190, 239]
+    // TX_DATA_FORMAT.TXID_ONLY = 2, followed by 32-byte txid
+    const minimalBeef: number[] = [
+      2, 0, 190, 239,          // BEEF_V2 version LE
+      0,                        // 0 bumps (varint)
+      1,                        // 1 tx (varint)
+      2,                        // TX_DATA_FORMAT.TXID_ONLY
+      ...new Array(32).fill(0)  // 32-byte zero txid
+    ]
+    const args = {
+      tx: minimalBeef,
+      outputs: [{ outputIndex: 0, protocol: 'wallet payment' as const }],
+      description: 'Internalize tx',
+    }
+    const result = await client.internalizeAction(args)
+
+    expect(result).toEqual({ accepted: true })
+    expect(mock.internalizeAction).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listOutputs – successful delegation
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.listOutputs – substrate delegation', () => {
+  it('delegates to substrate and returns output list', async () => {
+    const mock = buildMockSubstrate()
+    const fakeResult = { outputs: [], totalOutputs: 0 }
+    mock.listOutputs.mockResolvedValue(fakeResult as any)
+    const client = clientWith(mock)
+
+    const args = { basket: 'default' }
+    const result = await client.listOutputs(args)
+
+    expect(result).toEqual(fakeResult)
+    expect(mock.listOutputs).toHaveBeenCalledWith(args, 'test.origin')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// connectToSubstrate – auto-selection error path
+// ---------------------------------------------------------------------------
+
+describe('WalletClient.connectToSubstrate – error when no substrate available', () => {
+  it('throws a descriptive error when auto-substrate fails to connect', async () => {
+    // The 'auto' substrate string means connectToSubstrate will try real substrates.
+    // All of them will fail in a test environment, so an error should be thrown.
+    const client = new WalletClient('auto', 'test.origin')
+    await expect(client.connectToSubstrate()).rejects.toThrow(
+      'No wallet available over any communication substrate'
+    )
+  }, 10000)
+})