@bsv/sdk 2.0.11 → 2.0.13

package/src/registry/__tests/RegistryClient.additional.test.ts

@@ -0,0 +1,750 @@
+/**
+ * RegistryClient additional tests.
+ *
+ * Focuses on branches not covered by the primary test file:
+ *  - updateDefinition (all paths)
+ *  - removeDefinition itemIdentifier for unknown definitionType
+ *  - listOwnRegistryEntries: non-spendable skip, parse errors, empty BEEF
+ *  - resolve: protocol and certificate parsing, JSON parse error in certificate fields
+ *  - deserializeWalletProtocol: all validation error paths
+ *  - getIdentityKey: caching behaviour
+ *  - getNetwork: caching behaviour
+ */
+
+import { RegistryClient, deserializeWalletProtocol } from '../RegistryClient'
+import { WalletInterface } from '../../wallet/index.js'
+import { TopicBroadcaster, LookupResolver } from '../../overlay-tools/index.js'
+import { PushDrop } from '../../script/index.js'
+import {
+  DefinitionType,
+  DefinitionData,
+  ProtocolDefinitionData,
+  CertificateDefinitionData,
+  RegistryRecord,
+  CertificateFieldDescriptor
+} from '../types/index.js'
+
+// -------------------- Module-level mocks -------------------- //
+
+const mockBroadcast = jest.fn().mockResolvedValue('broadcastSuccess')
+
+jest.mock('../../overlay-tools/index.js', () => ({
+  TopicBroadcaster: jest.fn().mockImplementation(() => ({
+    broadcast: mockBroadcast
+  })),
+  LookupResolver: jest.fn().mockImplementation(() => ({
+    query: jest.fn()
+  }))
+}))
+
+jest.mock('../../script/index.js', () => {
+  const actual = jest.requireActual('../../script/index.js')
+  return {
+    ...actual,
+    PushDrop: Object.assign(
+      jest.fn().mockImplementation(() => ({
+        lock: jest.fn().mockResolvedValue({ toHex: () => 'mockLockHex' }),
+        unlock: jest.fn().mockReturnValue({
+          sign: jest.fn().mockResolvedValue({ toHex: () => 'mockUnlockHex' })
+        })
+      })),
+      { decode: jest.fn() }
+    ),
+    LockingScript: {
+      fromHex: jest.fn().mockImplementation((hex: string) => ({ hex }))
+    }
+  }
+})
+
+jest.mock('../../transaction/index.js', () => ({
+  Transaction: {
+    fromAtomicBEEF: jest.fn().mockImplementation(() => ({
+      outputs: [
+        { lockingScript: 'mockLS0' },
+        { lockingScript: 'mockLS1' }
+      ]
+    })),
+    fromBEEF: jest.fn().mockImplementation(() => ({
+      outputs: [
+        { lockingScript: { toHex: () => 'mockLSHex0' } },
+        { lockingScript: { toHex: () => 'mockLSHex1' } },
+        { lockingScript: { toHex: () => 'mockLSHex2' } }
+      ]
+    }))
+  }
+}))
+
+jest.mock('../../primitives/index.js', () => ({
+  Utils: {
+    toArray: jest.fn().mockImplementation((str: string) =>
+      Array.from(str).map((c) => c.charCodeAt(0))
+    ),
+    toUTF8: jest.fn().mockImplementation((arr: number[] | string) => {
+      if (Array.isArray(arr)) return arr.map((n) => String.fromCharCode(n)).join('')
+      return arr
+    })
+  }
+}))
+
+// -------------------- Test helpers -------------------- //
+
+const TEST_ORIGINATOR = 'test.additional.origin'
+const MOCK_PUB_KEY = 'mockPublicKey'
+
+function buildWalletMock (): jest.Mocked<Partial<WalletInterface>> {
+  return {
+    getPublicKey: jest.fn().mockResolvedValue({ publicKey: MOCK_PUB_KEY }),
+    createAction: jest.fn().mockResolvedValue({
+      tx: [1, 2, 3],
+      signableTransaction: { tx: [1, 2, 3], reference: 'ref123' }
+    }),
+    signAction: jest.fn().mockResolvedValue({ tx: [7, 8, 9] }),
+    listOutputs: jest.fn().mockResolvedValue({ outputs: [], BEEF: [] }),
+    getNetwork: jest.fn().mockResolvedValue({ network: 'testnet' })
+  }
+}
+
+function buildClient (wallet: Partial<WalletInterface>): RegistryClient {
+  const client = new RegistryClient(wallet as WalletInterface, {}, TEST_ORIGINATOR)
+  ;(client as any).resolver = {
+    query: jest.fn().mockResolvedValue({ type: 'output-list', outputs: [] })
+  }
+  return client
+}
+
+const baseRegistryRecord: RegistryRecord = {
+  definitionType: 'basket',
+  basketID: 'testBasket',
+  name: 'Test Basket',
+  iconURL: 'https://icon.com',
+  description: 'A basket',
+  documentationURL: 'https://docs.com',
+  txid: 'txid123',
+  outputIndex: 0,
+  satoshis: 1,
+  lockingScript: 'lockhex',
+  registryOperator: MOCK_PUB_KEY,
+  beef: [1, 2, 3]
+}
+
+// -------------------- deserializeWalletProtocol -------------------- //
+
+describe('deserializeWalletProtocol', () => {
+  it('parses a valid protocol string', () => {
+    const result = deserializeWalletProtocol(JSON.stringify([1, 'my-protocol']))
+    expect(result).toEqual([1, 'my-protocol'])
+  })
+
+  it('throws for non-array input', () => {
+    expect(() => deserializeWalletProtocol('"not-array"')).toThrow(
+      'Invalid wallet protocol format.'
+    )
+  })
+
+  it('throws for array with wrong length', () => {
+    expect(() => deserializeWalletProtocol(JSON.stringify([1]))).toThrow(
+      'Invalid wallet protocol format.'
+    )
+  })
+
+  it('throws for invalid security level', () => {
+    expect(() => deserializeWalletProtocol(JSON.stringify([3, 'proto']))).toThrow(
+      'Invalid security level.'
+    )
+  })
+
+  it('accepts security level 0', () => {
+    const result = deserializeWalletProtocol(JSON.stringify([0, 'proto']))
+    expect(result[0]).toBe(0)
+  })
+
+  it('accepts security level 2', () => {
+    const result = deserializeWalletProtocol(JSON.stringify([2, 'proto']))
+    expect(result[0]).toBe(2)
+  })
+
+  it('throws for non-string protocol string', () => {
+    expect(() => deserializeWalletProtocol(JSON.stringify([1, 42]))).toThrow(
+      'Invalid protocolID'
+    )
+  })
+
+  it('throws for completely invalid JSON', () => {
+    expect(() => deserializeWalletProtocol('not-json')).toThrow()
+  })
+})
+
+// -------------------- getIdentityKey caching -------------------- //
+
+describe('RegistryClient.getIdentityKey – caching', () => {
+  it('calls getPublicKey only once on repeated calls', async () => {
+    const wallet = buildWalletMock()
+    const client = buildClient(wallet)
+
+    // Trigger two operations that each call getIdentityKey internally
+    await client.registerDefinition({
+      definitionType: 'basket',
+      basketID: 'b1',
+      name: 'Basket 1',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com'
+    })
+    await client.registerDefinition({
+      definitionType: 'basket',
+      basketID: 'b2',
+      name: 'Basket 2',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com'
+    })
+
+    // getPublicKey should only have been called once (identity key was cached)
+    expect(wallet.getPublicKey).toHaveBeenCalledTimes(1)
+  })
+})
+
+// -------------------- getNetwork caching -------------------- //
+
+describe('RegistryClient.getNetwork – caching', () => {
+  it('calls wallet.getNetwork only once even across multiple operations', async () => {
+    const wallet = buildWalletMock()
+    const client = buildClient(wallet)
+
+    await client.registerDefinition({
+      definitionType: 'basket',
+      basketID: 'b1',
+      name: 'Basket 1',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com'
+    })
+    await client.registerDefinition({
+      definitionType: 'basket',
+      basketID: 'b2',
+      name: 'Basket 2',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com'
+    })
+
+    expect(wallet.getNetwork).toHaveBeenCalledTimes(1)
+  })
+})
+
+// -------------------- updateDefinition -------------------- //
+
+describe('RegistryClient.updateDefinition', () => {
+  let wallet: jest.Mocked<Partial<WalletInterface>>
+  let client: RegistryClient
+
+  beforeEach(() => {
+    wallet = buildWalletMock()
+    client = buildClient(wallet)
+    jest.clearAllMocks()
+    mockBroadcast.mockClear()
+    mockBroadcast.mockResolvedValue('broadcastSuccess')
+  })
+
+  it('throws if txid is missing from the record', async () => {
+    const record = { ...baseRegistryRecord, txid: undefined }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record as any, updated)).rejects.toThrow(
+      'Invalid registry record. Missing txid, outputIndex, or lockingScript.'
+    )
+  })
+
+  it('throws if outputIndex is missing from the record', async () => {
+    const record = { ...baseRegistryRecord, outputIndex: undefined }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record as any, updated)).rejects.toThrow(
+      'Invalid registry record. Missing txid, outputIndex, or lockingScript.'
+    )
+  })
+
+  it('throws if lockingScript is missing from the record', async () => {
+    const record = { ...baseRegistryRecord, lockingScript: undefined }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record as any, updated)).rejects.toThrow(
+      'Invalid registry record. Missing txid, outputIndex, or lockingScript.'
+    )
+  })
+
+  it('throws if definitionType does not match updatedData', async () => {
+    const record = { ...baseRegistryRecord }
+    const updated: DefinitionData = {
+      definitionType: 'protocol',
+      protocolID: [1, 'p'],
+      name: 'P',
+      iconURL: 'u',
+      description: 'd',
+      documentationURL: 'doc'
+    }
+    await expect(client.updateDefinition(record, updated)).rejects.toThrow(
+      'Cannot change definition type from basket to protocol'
+    )
+  })
+
+  it('throws if the registry record does not belong to the current wallet', async () => {
+    const record = { ...baseRegistryRecord, registryOperator: 'differentKey' }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record, updated)).rejects.toThrow(
+      'This registry token does not belong to the current wallet.'
+    )
+  })
+
+  it('throws if createAction returns no signableTransaction', async () => {
+    ;(wallet.createAction as jest.Mock).mockResolvedValueOnce({
+      tx: [1, 2, 3],
+      signableTransaction: undefined
+    })
+    const record = { ...baseRegistryRecord }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record, updated)).rejects.toThrow(
+      'Failed to create signable transaction.'
+    )
+  })
+
+  it('throws if signAction returns no tx', async () => {
+    ;(wallet.signAction as jest.Mock).mockResolvedValueOnce({ tx: undefined })
+    const record = { ...baseRegistryRecord }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record, updated)).rejects.toThrow(
+      'Failed to finalize the transaction signature.'
+    )
+  })
+
+  it('successfully updates a basket definition and broadcasts', async () => {
+    const record = { ...baseRegistryRecord }
+    const updated: DefinitionData = {
+      definitionType: 'basket',
+      basketID: 'updatedBasket',
+      name: 'Updated Basket',
+      iconURL: 'https://newicon.com',
+      description: 'Updated description',
+      documentationURL: 'https://newdocs.com'
+    }
+
+    const result = await client.updateDefinition(record, updated)
+
+    expect(result).toBe('broadcastSuccess')
+    expect(wallet.createAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: 'Update basket item: testBasket',
+        inputs: [expect.objectContaining({ outpoint: 'txid123.0' })],
+        outputs: [expect.objectContaining({ basket: 'basketmap' })]
+      }),
+      TEST_ORIGINATOR
+    )
+    expect(wallet.signAction).toHaveBeenCalledWith(
+      expect.objectContaining({ reference: 'ref123' }),
+      TEST_ORIGINATOR
+    )
+    expect(TopicBroadcaster).toHaveBeenCalledWith(
+      ['tm_basketmap'],
+      expect.objectContaining({ networkPreset: 'testnet' })
+    )
+  })
+
+  it('successfully updates a protocol definition and uses protocol item identifier', async () => {
+    const protocolRecord: RegistryRecord = {
+      definitionType: 'protocol',
+      protocolID: [1, 'oldProto'],
+      name: 'Old Protocol',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com',
+      txid: 'protTxid',
+      outputIndex: 0,
+      satoshis: 1,
+      lockingScript: 'lockhex',
+      registryOperator: MOCK_PUB_KEY,
+      beef: [1, 2, 3]
+    }
+    const updated: ProtocolDefinitionData = {
+      definitionType: 'protocol',
+      protocolID: [1, 'newProto'],
+      name: 'New Protocol',
+      iconURL: 'https://icon.com',
+      description: 'Updated desc',
+      documentationURL: 'https://newdocs.com'
+    }
+
+    const result = await client.updateDefinition(protocolRecord, updated)
+
+    expect(result).toBe('broadcastSuccess')
+    expect(wallet.createAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: 'Update protocol item: Old Protocol'
+      }),
+      TEST_ORIGINATOR
+    )
+    expect(TopicBroadcaster).toHaveBeenCalledWith(['tm_protomap'], expect.anything())
+  })
+
+  it('uses certificate type when name is undefined in the item identifier', async () => {
+    const certRecord: RegistryRecord = {
+      definitionType: 'certificate',
+      type: 'certType123',
+      name: undefined as any,
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com',
+      fields: {},
+      txid: 'certTxid',
+      outputIndex: 0,
+      satoshis: 1,
+      lockingScript: 'lockhex',
+      registryOperator: MOCK_PUB_KEY,
+      beef: [1, 2, 3]
+    }
+    const updated: CertificateDefinitionData = {
+      definitionType: 'certificate',
+      type: 'certType123',
+      name: 'New Cert Name',
+      iconURL: 'https://icon.com',
+      description: 'Updated',
+      documentationURL: 'https://docs.com',
+      fields: {}
+    }
+
+    const result = await client.updateDefinition(certRecord, updated)
+
+    expect(result).toBe('broadcastSuccess')
+    expect(wallet.createAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: 'Update certificate item: certType123'
+      }),
+      TEST_ORIGINATOR
+    )
+  })
+
+  it('uses certificate name when defined for the item identifier', async () => {
+    const certRecord: RegistryRecord = {
+      definitionType: 'certificate',
+      type: 'certType456',
+      name: 'Named Cert',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com',
+      fields: {},
+      txid: 'certTxid2',
+      outputIndex: 0,
+      satoshis: 1,
+      lockingScript: 'lockhex',
+      registryOperator: MOCK_PUB_KEY,
+      beef: [1, 2, 3]
+    }
+    const updated: CertificateDefinitionData = {
+      definitionType: 'certificate',
+      type: 'certType456',
+      name: 'Updated Cert',
+      iconURL: 'https://icon.com',
+      description: 'desc',
+      documentationURL: 'https://docs.com',
+      fields: {}
+    }
+
+    await client.updateDefinition(certRecord, updated)
+
+    expect(wallet.createAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: 'Update certificate item: Named Cert'
+      }),
+      TEST_ORIGINATOR
+    )
+  })
+
+  it('uses acceptDelayedBroadcast: true when configured', async () => {
+    const delayedClient = new RegistryClient(
+      wallet as WalletInterface,
+      { acceptDelayedBroadcast: true },
+      TEST_ORIGINATOR
+    )
+    ;(delayedClient as any).resolver = {
+      query: jest.fn().mockResolvedValue({ type: 'output-list', outputs: [] })
+    }
+
+    const record = { ...baseRegistryRecord }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await delayedClient.updateDefinition(record, updated)
+
+    expect(wallet.createAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        options: expect.objectContaining({ acceptDelayedBroadcast: true })
+      }),
+      TEST_ORIGINATOR
+    )
+    expect(wallet.signAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        options: expect.objectContaining({ acceptDelayedBroadcast: true })
+      }),
+      TEST_ORIGINATOR
+    )
+  })
+
+  it('propagates broadcast errors', async () => {
+    mockBroadcast.mockRejectedValueOnce(new Error('Update broadcast failed!'))
+    const record = { ...baseRegistryRecord }
+    const updated: DefinitionData = { ...baseRegistryRecord }
+    await expect(client.updateDefinition(record, updated)).rejects.toThrow('Update broadcast failed!')
+  })
+})
+
+// -------------------- removeDefinition: unknown identifier -------------------- //
+
+describe('RegistryClient.removeDefinition – itemIdentifier edge cases', () => {
+  let wallet: jest.Mocked<Partial<WalletInterface>>
+  let client: RegistryClient
+
+  beforeEach(() => {
+    wallet = buildWalletMock()
+    client = buildClient(wallet)
+    jest.clearAllMocks()
+    mockBroadcast.mockClear()
+    mockBroadcast.mockResolvedValue('broadcastSuccess')
+  })
+
+  it('uses basketID as itemIdentifier for basket records', async () => {
+    const record = { ...baseRegistryRecord }
+    await client.removeDefinition(record)
+    expect(wallet.createAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: 'Remove basket item: testBasket'
+      }),
+      TEST_ORIGINATOR
+    )
+  })
+})
+
+// -------------------- listOwnRegistryEntries edge cases -------------------- //
+
+describe('RegistryClient.listOwnRegistryEntries – edge cases', () => {
+  let wallet: jest.Mocked<Partial<WalletInterface>>
+  let client: RegistryClient
+
+  beforeEach(() => {
+    wallet = buildWalletMock()
+    client = buildClient(wallet)
+    jest.clearAllMocks()
+  })
+
+  it('returns empty array when no outputs are returned', async () => {
+    ;(wallet.listOutputs as jest.Mock).mockResolvedValue({ outputs: [], BEEF: [] })
+    const results = await client.listOwnRegistryEntries('basket')
+    expect(results).toEqual([])
+  })
+
+  it('skips non-spendable outputs', async () => {
+    ;(wallet.listOutputs as jest.Mock).mockResolvedValue({
+      outputs: [
+        { outpoint: 'tx1.0', satoshis: 1, spendable: false },
+        { outpoint: 'tx2.0', satoshis: 1, spendable: false }
+      ],
+      BEEF: [1, 2, 3]
+    })
+    const results = await client.listOwnRegistryEntries('basket')
+    expect(results).toEqual([])
+    expect(PushDrop.decode).not.toHaveBeenCalled()
+  })
+
+  it('skips spendable outputs that fail to parse (catches error silently)', async () => {
+    ;(wallet.listOutputs as jest.Mock).mockResolvedValue({
+      outputs: [{ outpoint: 'badtx.0', satoshis: 1, spendable: true }],
+      BEEF: [1, 2, 3]
+    })
+    // Make decode throw to simulate parse failure
+    ;(PushDrop.decode as jest.Mock).mockImplementationOnce(() => {
+      throw new Error('Invalid script')
+    })
+    const results = await client.listOwnRegistryEntries('basket')
+    expect(results).toEqual([])
+  })
+
+  it('returns records for all valid spendable outputs', async () => {
+    ;(wallet.listOutputs as jest.Mock).mockResolvedValue({
+      outputs: [
+        { outpoint: 'tx1.0', satoshis: 1, spendable: true },
+        { outpoint: 'tx2.0', satoshis: 2, spendable: true }
+      ],
+      BEEF: [0, 1, 2, 3]
+    })
+    // Basket has 7 fields
+    ;(PushDrop.decode as jest.Mock).mockReturnValue({
+      fields: [
+        [98],  // basketID: 'b'
+        [97],  // name: 'a'
+        [115], // iconURL: 's'
+        [107], // description: 'k'
+        [101], // documentationURL: 'e'
+        [116], // operator: 't'
+        [111]  // signature field
+      ]
+    })
+
+    const results = await client.listOwnRegistryEntries('basket')
+    expect(results).toHaveLength(2)
+    expect(results[0].txid).toBe('tx1')
+    expect(results[1].txid).toBe('tx2')
+  })
+
+  it('uses protomap basket for protocol definition type', async () => {
+    ;(wallet.listOutputs as jest.Mock).mockResolvedValue({ outputs: [], BEEF: [] })
+    await client.listOwnRegistryEntries('protocol')
+    expect(wallet.listOutputs).toHaveBeenCalledWith({
+      basket: 'protomap',
+      include: 'entire transactions'
+    })
+  })
+
+  it('uses certmap basket for certificate definition type', async () => {
+    ;(wallet.listOutputs as jest.Mock).mockResolvedValue({ outputs: [], BEEF: [] })
+    await client.listOwnRegistryEntries('certificate')
+    expect(wallet.listOutputs).toHaveBeenCalledWith({
+      basket: 'certmap',
+      include: 'entire transactions'
+    })
+  })
+})
+
+// -------------------- resolve: protocol and certificate parsing -------------------- //
+
+describe('RegistryClient.resolve – protocol and certificate parsing', () => {
+  let wallet: jest.Mocked<Partial<WalletInterface>>
+  let client: RegistryClient
+
+  beforeEach(() => {
+    wallet = buildWalletMock()
+    client = buildClient(wallet)
+    jest.clearAllMocks()
+  })
+
+  it('parses a protocol output from the resolver', async () => {
+    ;(client as any).resolver.query = jest.fn().mockResolvedValue({
+      type: 'output-list',
+      outputs: [{ beef: [1, 2, 3], outputIndex: 0 }]
+    })
+
+    // protocol has 7 fields: protocolID, name, iconURL, description, docURL, operator, sig
+    ;(PushDrop.decode as jest.Mock).mockReturnValueOnce({
+      fields: [
+        Array.from('[1,"proto"]').map((c) => c.charCodeAt(0)), // protocolID JSON
+        [110, 97, 109, 101],  // 'name'
+        [105, 99, 111, 110],  // 'icon'
+        [100, 101, 115, 99],  // 'desc'
+        [100, 111, 99],       // 'doc'
+        [111, 112],           // 'op' - operator
+        [115, 105, 103]       // signature
+      ]
+    })
+
+    const result = await client.resolve('protocol', { name: 'proto' })
+    expect(result).toHaveLength(1)
+    expect(result[0].definitionType).toBe('protocol')
+  })
+
+  it('parses a certificate output from the resolver', async () => {
+    ;(client as any).resolver.query = jest.fn().mockResolvedValue({
+      type: 'output-list',
+      outputs: [{ beef: [1, 2, 3], outputIndex: 0 }]
+    })
+
+    // certificate has 8 fields: type, name, iconURL, desc, docURL, fieldsJSON, operator, sig
+    const fieldsJSON = JSON.stringify({ field1: { friendlyName: 'Field One', description: 'd', type: 'text', fieldIcon: 'i' } })
+    ;(PushDrop.decode as jest.Mock).mockReturnValueOnce({
+      fields: [
+        [116, 121, 112, 101],  // 'type'
+        [110, 97, 109, 101],   // 'name'
+        [105, 99, 111, 110],   // 'icon'
+        [100, 101, 115, 99],   // 'desc'
+        [100, 111, 99],        // 'doc'
+        Array.from(fieldsJSON).map((c) => c.charCodeAt(0)), // fieldsJSON
+        [111, 112],            // 'op' - operator
+        [115, 105, 103]        // signature
+      ]
+    })
+
+    const result = await client.resolve('certificate', { type: 'type' })
+    expect(result).toHaveLength(1)
+    expect(result[0].definitionType).toBe('certificate')
+  })
+
+  it('uses empty fields object when certificate fieldsJSON is invalid JSON', async () => {
+    ;(client as any).resolver.query = jest.fn().mockResolvedValue({
+      type: 'output-list',
+      outputs: [{ beef: [1, 2, 3], outputIndex: 0 }]
+    })
+
+    // Invalid JSON for fieldsJSON
+    ;(PushDrop.decode as jest.Mock).mockReturnValueOnce({
+      fields: [
+        [116, 121, 112, 101],   // 'type'
+        [110, 97, 109, 101],    // 'name'
+        [105, 99, 111, 110],    // 'icon'
+        [100, 101, 115, 99],    // 'desc'
+        [100, 111, 99],         // 'doc'
+        [123, 105, 110, 118],   // '{inv' - invalid JSON
+        [111, 112],             // operator
+        [115, 105, 103]         // signature
+      ]
+    })
+
+    const result = await client.resolve('certificate', { type: 'type' })
+    expect(result).toHaveLength(1)
+    expect((result[0] as CertificateDefinitionData).fields).toEqual({})
+  })
+
+  it('skips outputs with wrong field count for basket (not 7)', async () => {
+    ;(client as any).resolver.query = jest.fn().mockResolvedValue({
+      type: 'output-list',
+      outputs: [{ beef: [1, 2, 3], outputIndex: 0 }]
+    })
+
+    // Return only 5 fields — should fail the basket field count check and be skipped
+    ;(PushDrop.decode as jest.Mock).mockReturnValueOnce({
+      fields: [[1], [2], [3], [4], [5]]
+    })
+
+    const result = await client.resolve('basket', {})
+    expect(result).toEqual([])
+  })
+
+  it('skips outputs with wrong field count for certificate (not 8)', async () => {
+    ;(client as any).resolver.query = jest.fn().mockResolvedValue({
+      type: 'output-list',
+      outputs: [{ beef: [1, 2, 3], outputIndex: 0 }]
+    })
+
+    // Return only 5 fields — should fail the certificate field count check
+    ;(PushDrop.decode as jest.Mock).mockReturnValueOnce({
+      fields: [[1], [2], [3], [4], [5]]
+    })
+
+    const result = await client.resolve('certificate', {})
+    expect(result).toEqual([])
+  })
+})
+
+// -------------------- registerDefinition: network preset used -------------------- //
+
+describe('RegistryClient.registerDefinition – network preset', () => {
+  it('passes testnet to TopicBroadcaster when wallet returns testnet', async () => {
+    const wallet = buildWalletMock()
+    ;(wallet.getNetwork as jest.Mock).mockResolvedValue({ network: 'testnet' })
+    const client = buildClient(wallet)
+
+    await client.registerDefinition({
+      definitionType: 'basket',
+      basketID: 'b1',
+      name: 'Basket',
+      iconURL: 'u',
+      description: 'd',
+      documentationURL: 'doc'
+    })
+
+    expect(TopicBroadcaster).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ networkPreset: 'testnet' })
+    )
+  })
+})