@bsv/sdk 1.1.33 → 1.2.1

package/src/overlay-tools/__tests/SHIPBroadcaster.test.ts

@@ -0,0 +1,904 @@
+import SHIPCast from '../../../dist/cjs/src/overlay-tools/SHIPBroadcaster.js'
+import LookupResolver from '../../../dist/cjs/src/overlay-tools/LookupResolver.js'
+import { PrivateKey } from '../../../dist/cjs/src/primitives/index.js'
+import { Transaction } from '../../../dist/cjs/src/transaction/index.js'
+import OverlayAdminTokenTemplate from '../../../dist/cjs/src/overlay-tools/OverlayAdminTokenTemplate.js'
+import ProtoWallet from '../../../dist/cjs/src/wallet/ProtoWallet.js'
+
+const mockFacilitator = {
+  send: jest.fn()
+}
+
+const mockResolver = {
+  query: jest.fn()
+}
+
+describe('SHIPCast', () => {
+  beforeEach(() => {
+    mockFacilitator.send.mockReset()
+    mockResolver.query.mockReset()
+  })
+
+  it('Handles constructor errors', () => {
+    expect(() => new SHIPCast([])).toThrow(new Error('At least one topic is required for broadcast.'))
+    expect(() => new SHIPCast(['badprefix_foo'])).toThrow(new Error('Every topic must start with "tm_".'))
+  })
+
+  it('should broadcast to a single SHIP host found via resolver', async () => {
+    const shipHostKey = new PrivateKey(42)
+    const shipWallet = new ProtoWallet(shipHostKey)
+    const shipLib = new OverlayAdminTokenTemplate(shipWallet)
+    const shipScript = await shipLib.lock('SHIP', 'https://shiphost.com', 'tm_foo')
+    const shipTx = new Transaction(1, [], [{
+      lockingScript: shipScript,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns one host interested in 'tm_foo' topic
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: shipTx.toBEEF(),
+        outputIndex: 0
+      }]
+    })
+
+    // Host responds successfully
+    mockFacilitator.send.mockReturnValueOnce({
+      tm_foo: {
+
+        outputsToAdmit: [0],
+        coinsToRetain: []
+      }
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: testTx.id('hex'),
+      message: 'Sent to 1 Overlay Services host.'
+    })
+
+    expect(mockResolver.query).toHaveBeenCalledWith({
+      service: 'ls_ship',
+      query: {
+        topics: ['tm_foo']
+      }
+    })
+
+    expect(mockFacilitator.send).toHaveBeenCalledWith('https://shiphost.com', {
+      beef: testTx.toBEEF(),
+      topics: ['tm_foo']
+    })
+  })
+
+  it('should be resilient to malformed or corrupted SHIP data, to the extent possible', async () => {
+    const shipHostKey = new PrivateKey(42)
+    const shipWallet = new ProtoWallet(shipHostKey)
+    const shipLib = new OverlayAdminTokenTemplate(shipWallet)
+    // First SHIP is for wrong topic
+    const shipScript = await shipLib.lock('SHIP', 'https://shiphost.com', 'tm_wrong')
+    const shipTx = new Transaction(1, [], [{
+      lockingScript: shipScript,
+      satoshis: 1
+    }], 0)
+    const shipHostKey2 = new PrivateKey(43)
+    const shipWallet2 = new ProtoWallet(shipHostKey2)
+    const shipLib2 = new OverlayAdminTokenTemplate(shipWallet2)
+    // Second SHIP is for correct topic
+    const shipScript2 = await shipLib2.lock('SHIP', 'https://shiphost2.com', 'tm_foo')
+    const shipTx2 = new Transaction(1, [], [{
+      lockingScript: shipScript2,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns two hosts, both the correct and the corrupted ones.
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: shipTx.toBEEF(),
+        outputIndex: 0
+      }, {
+        beef: shipTx2.toBEEF(),
+        outputIndex: 0
+      }]
+    })
+
+    // Host responds successfully
+    mockFacilitator.send.mockReturnValue({
+      tm_foo: {
+        outputsToAdmit: [0],
+        coinsToRetain: []
+      }
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    let response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: testTx.id('hex'),
+      // One SHIP advertisement should be used, but the second one was invalid
+      message: 'Sent to 1 Overlay Services host.'
+    })
+
+    // Transaction should have been sent to the second host, but the first one was invalid
+    expect(mockFacilitator.send).toHaveBeenCalledWith('https://shiphost2.com', {
+      beef: testTx.toBEEF(),
+      topics: ['tm_foo']
+    })
+    mockFacilitator.send.mockClear()
+
+    // Resolver returns the wrong type of data
+    mockResolver.query.mockReturnValueOnce({
+      type: 'invalid',
+      bogus: true,
+      outputs: {
+        different: 'structure'
+      }
+    })
+    await expect(async () => await b.broadcast(testTx)).rejects.toThrow('SHIP answer is not an output list.')
+    expect(mockFacilitator.send).not.toHaveBeenCalled()
+
+    // Resolver returns the wrong output structure
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: {
+        different: 'structure'
+      }
+    })
+    await expect(async () => await b.broadcast(testTx)).rejects.toThrow('answer.outputs is not iterable')
+    expect(mockFacilitator.send).not.toHaveBeenCalled()
+
+    // Resolver returns corrupted BEEF alongside good data
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: shipTx.toBEEF(), // Wrong topic
+        outputIndex: 0
+      }, {
+        beef: [0], // corrupted "rotten" BEEF
+        outputIndex: 4
+      }, {
+        beef: shipTx2.toBEEF(),
+        outputIndex: 1 // Wrong output index
+      }, {
+        beef: shipTx2.toBEEF(),
+        outputIndex: 0 // correct
+      }]
+    })
+    response = await b.broadcast(testTx)
+    expect(response).toEqual({
+      status: 'success',
+      txid: testTx.id('hex'),
+      // One SHIP advertisement should be used, but the second one was invalid
+      message: 'Sent to 1 Overlay Services host.'
+    })
+
+    // Transaction should have been sent to the second host, but the first one was invalid
+    expect(mockFacilitator.send).toHaveBeenCalledWith('https://shiphost2.com', {
+      beef: testTx.toBEEF(),
+      topics: ['tm_foo']
+    })
+  })
+
+  it('should fail when transaction cannot be serialized to BEEF', async () => {
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = {
+      toBEEF: () => {
+        throw new Error('Cannot serialize to BEEF')
+      }
+    } as unknown as Transaction
+
+    await expect(b.broadcast(testTx)).rejects.toThrow('Transactions sent via SHIP to Overlay Services must be serializable to BEEF format.')
+  })
+
+  it('should fail when no hosts are interested in the topics', async () => {
+    // Resolver returns empty output list
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: []
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+
+    const result = await b.broadcast(testTx)
+
+    expect(result).toEqual({
+      status: 'error',
+      code: 'ERR_NO_HOSTS_INTERESTED',
+      description: 'No hosts are interested in receiving this transaction.'
+    })
+
+    expect(mockResolver.query).toHaveBeenCalledWith({
+      service: 'ls_ship',
+      query: {
+        topics: ['tm_foo']
+      }
+    })
+
+    expect(mockFacilitator.send).not.toHaveBeenCalled()
+  })
+
+  it('should fail when all hosts reject the transaction', async () => {
+    const shipHostKey = new PrivateKey(42)
+    const shipWallet = new ProtoWallet(shipHostKey)
+    const shipLib = new OverlayAdminTokenTemplate(shipWallet)
+    const shipScript = await shipLib.lock('SHIP', 'https://shiphost.com', 'tm_foo')
+    const shipTx = new Transaction(1, [], [{
+      lockingScript: shipScript,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns one host
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: shipTx.toBEEF(),
+        outputIndex: 0
+      }]
+    })
+
+    // Host fails
+    mockFacilitator.send.mockImplementationOnce(() => {
+      throw new Error('Host failed')
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+
+    const result = await b.broadcast(testTx)
+
+    expect(result).toEqual({
+      status: 'error',
+      code: 'ERR_ALL_HOSTS_REJECTED',
+      description: 'All SHIP hosts have rejected the transaction.'
+    })
+
+    expect(mockFacilitator.send).toHaveBeenCalled()
+  })
+
+  it('should fail when required specific hosts are not among interested hosts', async () => {
+    const shipHostKey = new PrivateKey(42)
+    const shipWallet = new ProtoWallet(shipHostKey)
+    const shipLib = new OverlayAdminTokenTemplate(shipWallet)
+    const shipScript = await shipLib.lock('SHIP', 'https://shiphost.com', 'tm_foo')
+    const shipTx = new Transaction(1, [], [{
+      lockingScript: shipScript,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns one host
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: shipTx.toBEEF(),
+        outputIndex: 0
+      }]
+    })
+
+    // First host acknowledges 'tm_foo', but it's not the right host.
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: topic === 'tm_foo' ? [0] : [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver,
+      requireAcknowledgmentFromSpecificHostsForTopics: {
+        'https://anotherhost.com': ['tm_foo']
+      },
+      requireAcknowledgmentFromAllHostsForTopics: [],
+      requireAcknowledgmentFromAnyHostForTopics: []
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'error',
+      code: 'ERR_REQUIRE_ACK_FROM_SPECIFIC_HOSTS_FAILED',
+      description: 'Specific hosts did not acknowledge the required topics.'
+    })
+  })
+
+  it('should succeed when all hosts acknowledge all topics (default behavior)', async () => {
+    const shipHostKey1 = new PrivateKey(42)
+    const shipWallet1 = new ProtoWallet(shipHostKey1)
+    const shipLib1 = new OverlayAdminTokenTemplate(shipWallet1)
+    const shipScript1 = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_foo')
+    const shipScript1b = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_bar')
+    const shipTx1 = new Transaction(1, [], [{
+      lockingScript: shipScript1,
+      satoshis: 1
+    }, {
+      lockingScript: shipScript1b,
+      satoshis: 1
+    }], 0)
+
+    const shipHostKey2 = new PrivateKey(43)
+    const shipWallet2 = new ProtoWallet(shipHostKey2)
+    const shipLib2 = new OverlayAdminTokenTemplate(shipWallet2)
+    const shipScript2 = await shipLib2.lock('SHIP', 'https://shiphost2.com', 'tm_bar')
+    const shipScript2b = await shipLib2.lock('SHIP', 'https://shiphost2.com', 'tm_foo')
+    const shipTx2 = new Transaction(1, [], [{
+      lockingScript: shipScript2,
+      satoshis: 1
+    }, {
+      lockingScript: shipScript2b,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns two hosts
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { beef: shipTx1.toBEEF(), outputIndex: 0 },
+        { beef: shipTx1.toBEEF(), outputIndex: 1 },
+        { beef: shipTx2.toBEEF(), outputIndex: 0 },
+        { beef: shipTx2.toBEEF(), outputIndex: 1 }
+      ]
+    })
+
+    // Both hosts acknowledge all topics
+    mockFacilitator.send.mockImplementation(async (host, { topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [0],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo', 'tm_bar'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: testTx.id('hex'),
+      message: 'Sent to 2 Overlay Services hosts.'
+    })
+
+    expect(mockResolver.query).toHaveBeenCalledWith({
+      service: 'ls_ship',
+      query: {
+        topics: ['tm_foo', 'tm_bar']
+      }
+    })
+
+    expect(mockFacilitator.send).toHaveBeenCalledTimes(2)
+  })
+
+  it('should fail when a host does not acknowledge all topics (default behavior)', async () => {
+    const shipHostKey1 = new PrivateKey(42)
+    const shipWallet1 = new ProtoWallet(shipHostKey1)
+    const shipLib1 = new OverlayAdminTokenTemplate(shipWallet1)
+    const shipScript1 = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_foo')
+    const shipTx1 = new Transaction(1, [], [{
+      lockingScript: shipScript1,
+      satoshis: 1
+    }], 0)
+
+    const shipHostKey2 = new PrivateKey(43)
+    const shipWallet2 = new ProtoWallet(shipHostKey2)
+    const shipLib2 = new OverlayAdminTokenTemplate(shipWallet2)
+    const shipScript2 = await shipLib2.lock('SHIP', 'https://shiphost2.com', 'tm_bar')
+    const shipTx2 = new Transaction(1, [], [{
+      lockingScript: shipScript2,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns two hosts
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { beef: shipTx1.toBEEF(), outputIndex: 0 },
+        { beef: shipTx2.toBEEF(), outputIndex: 0 }
+      ]
+    })
+
+    // First host acknowledges 'tm_foo'
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [0],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    // Second host does not acknowledge any topics
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo', 'tm_bar'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'error',
+      code: 'ERR_REQUIRE_ACK_FROM_ALL_HOSTS_FAILED',
+      description: 'Not all hosts acknowledged the required topics.'
+    })
+  })
+
+  it('should succeed when at least one host acknowledges required topics with requireAcknowledgmentFromAnyHostForTopics set to "any"', async () => {
+    const shipHostKey1 = new PrivateKey(42)
+    const shipWallet1 = new ProtoWallet(shipHostKey1)
+    const shipLib1 = new OverlayAdminTokenTemplate(shipWallet1)
+    const shipScript1 = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_foo')
+    const shipTx1 = new Transaction(1, [], [{
+      lockingScript: shipScript1,
+      satoshis: 1
+    }], 0)
+
+    const shipHostKey2 = new PrivateKey(43)
+    const shipWallet2 = new ProtoWallet(shipHostKey2)
+    const shipLib2 = new OverlayAdminTokenTemplate(shipWallet2)
+    const shipScript2 = await shipLib2.lock('SHIP', 'https://shiphost2.com', 'tm_bar')
+    const shipTx2 = new Transaction(1, [], [{
+      lockingScript: shipScript2,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns two hosts
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { beef: shipTx1.toBEEF(), outputIndex: 0 },
+        { beef: shipTx2.toBEEF(), outputIndex: 0 }
+      ]
+    })
+
+    // First host acknowledges no topics
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    // Second host acknowledges 'tm_bar'
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: topic === 'tm_bar' ? [0] : [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo', 'tm_bar'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver,
+      requireAcknowledgmentFromAnyHostForTopics: 'any',
+      requireAcknowledgmentFromAllHostsForTopics: []
+    })
+
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: testTx.id('hex'),
+      message: 'Sent to 2 Overlay Services hosts.'
+    })
+  })
+
+  it('should fail when no hosts acknowledge required topics with requireAcknowledgmentFromAnyHostForTopics set to "any"', async () => {
+    const shipHostKey1 = new PrivateKey(42)
+    const shipWallet1 = new ProtoWallet(shipHostKey1)
+    const shipLib1 = new OverlayAdminTokenTemplate(shipWallet1)
+    const shipScript1 = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_foo')
+    const shipTx1 = new Transaction(1, [], [{
+      lockingScript: shipScript1,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns one host
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{ beef: shipTx1.toBEEF(), outputIndex: 0 }]
+    })
+
+    // Host acknowledges no topics
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver,
+      requireAcknowledgmentFromAnyHostForTopics: 'any',
+      requireAcknowledgmentFromAllHostsForTopics: []
+    })
+
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'error',
+      code: 'ERR_REQUIRE_ACK_FROM_ANY_HOST_FAILED',
+      description: 'No host acknowledged the required topics.'
+    })
+  })
+
+  it('should succeed when specific hosts acknowledge required topics', async () => {
+    const shipHostKey1 = new PrivateKey(42)
+    const shipWallet1 = new ProtoWallet(shipHostKey1)
+    const shipLib1 = new OverlayAdminTokenTemplate(shipWallet1)
+    const shipScript1 = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_foo')
+    const shipTx1 = new Transaction(1, [], [{
+      lockingScript: shipScript1,
+      satoshis: 1
+    }], 0)
+
+    const shipHostKey2 = new PrivateKey(43)
+    const shipWallet2 = new ProtoWallet(shipHostKey2)
+    const shipLib2 = new OverlayAdminTokenTemplate(shipWallet2)
+    const shipScript2 = await shipLib2.lock('SHIP', 'https://shiphost2.com', 'tm_bar')
+    const shipTx2 = new Transaction(1, [], [{
+      lockingScript: shipScript2,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns two hosts
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { beef: shipTx1.toBEEF(), outputIndex: 0 },
+        { beef: shipTx2.toBEEF(), outputIndex: 0 }
+      ]
+    })
+
+    // First host acknowledges 'tm_foo'
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: topic === 'tm_foo' ? [0] : [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    // Second host does not acknowledge 'tm_bar'
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo', 'tm_bar'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver,
+      requireAcknowledgmentFromSpecificHostsForTopics: {
+        'https://shiphost1.com': ['tm_foo']
+      },
+      requireAcknowledgmentFromAllHostsForTopics: [],
+      requireAcknowledgmentFromAnyHostForTopics: []
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: testTx.id('hex'),
+      message: 'Sent to 2 Overlay Services hosts.'
+    })
+  })
+
+  it('should fail when specific hosts do not acknowledge required topics', async () => {
+    const shipHostKey1 = new PrivateKey(42)
+    const shipWallet1 = new ProtoWallet(shipHostKey1)
+    const shipLib1 = new OverlayAdminTokenTemplate(shipWallet1)
+    const shipScript1 = await shipLib1.lock('SHIP', 'https://shiphost1.com', 'tm_foo')
+    const shipTx1 = new Transaction(1, [], [{
+      lockingScript: shipScript1,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns one host
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{ beef: shipTx1.toBEEF(), outputIndex: 0 }]
+    })
+
+    // Host does not acknowledge 'tm_foo'
+    mockFacilitator.send.mockImplementationOnce(async (host, { beef, topics }) => {
+      const steak = {}
+      for (const topic of topics) {
+        steak[topic] = {
+          outputsToAdmit: [],
+          coinsToRetain: []
+        }
+      }
+      return steak
+    })
+
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver,
+      requireAcknowledgmentFromSpecificHostsForTopics: {
+        'https://shiphost1.com': ['tm_foo']
+      },
+      requireAcknowledgmentFromAllHostsForTopics: [],
+      requireAcknowledgmentFromAnyHostForTopics: []
+    })
+
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    expect(response).toEqual({
+      status: 'error',
+      code: 'ERR_REQUIRE_ACK_FROM_SPECIFIC_HOSTS_FAILED',
+      description: 'Specific hosts did not acknowledge the required topics.'
+    })
+  })
+
+  it('should handle invalid acknowledgments from hosts gracefully', async () => {
+    const shipHostKey = new PrivateKey(42)
+    const shipWallet = new ProtoWallet(shipHostKey)
+    const shipLib = new OverlayAdminTokenTemplate(shipWallet)
+    const shipScript = await shipLib.lock('SHIP', 'https://shiphost.com', 'tm_foo')
+    const shipTx = new Transaction(1, [], [{
+      lockingScript: shipScript,
+      satoshis: 1
+    }], 0)
+
+    // Resolver returns one host
+    mockResolver.query.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: shipTx.toBEEF(),
+        outputIndex: 0
+      }]
+    })
+
+    // Host returns invalid acknowledgment
+    mockFacilitator.send.mockReturnValueOnce(null)
+    const b = new SHIPCast(['tm_foo'], {
+      facilitator: mockFacilitator,
+      resolver: mockResolver as unknown as LookupResolver
+    })
+    const testTx = new Transaction(1, [], [], 0)
+    const response = await b.broadcast(testTx)
+
+    // Since the host responded (successfully in terms of HTTP), but with invalid data, we should consider it a failure
+    expect(response).toEqual({
+      status: 'error',
+      code: 'ERR_ALL_HOSTS_REJECTED',
+      description: 'All SHIP hosts have rejected the transaction.'
+    })
+  })
+  describe('SHIPCast private methods', () => {
+    let shipCast: SHIPCast
+
+    beforeEach(() => {
+      shipCast = new SHIPCast(['tm_foo', 'tm_bar'], {
+        facilitator: mockFacilitator,
+        resolver: mockResolver as unknown as LookupResolver
+      })
+    })
+
+    describe('checkAcknowledgmentFromAllHosts', () => {
+      it('should return true when all hosts acknowledge all required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo', 'tm_bar']),
+          'https://host2.com': new Set(['tm_foo', 'tm_bar'])
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAllHosts(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'all')
+        expect(result).toBe(true)
+      })
+
+      it('should return false when any host does not acknowledge all required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(['tm_foo', 'tm_bar'])
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAllHosts(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'all')
+        expect(result).toBe(false)
+      })
+
+      it('should return true when all hosts acknowledge any of the required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(['tm_bar'])
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAllHosts(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'any')
+        expect(result).toBe(true)
+      })
+
+      it('should return false when any host does not acknowledge any of the required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(),
+          'https://host2.com': new Set(['tm_bar'])
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAllHosts(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'any')
+        expect(result).toBe(false)
+      })
+    })
+
+    describe('checkAcknowledgmentFromAnyHost', () => {
+      it('should return true when at least one host acknowledges all required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo', 'tm_bar']),
+          'https://host2.com': new Set(['tm_foo'])
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAnyHost(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'all')
+        expect(result).toBe(true)
+      })
+
+      it('should return false when no host acknowledges all required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(['tm_bar'])
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAnyHost(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'all')
+        expect(result).toBe(false)
+      })
+
+      it('should return true when at least one host acknowledges any of the required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set()
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAnyHost(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'any')
+        expect(result).toBe(true)
+      })
+
+      it('should return false when no host acknowledges any of the required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(),
+          'https://host2.com': new Set()
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromAnyHost(hostAcknowledgments, ['tm_foo', 'tm_bar'], 'any')
+        expect(result).toBe(false)
+      })
+    })
+
+    describe('checkAcknowledgmentFromSpecificHosts', () => {
+      it('should return true when specific hosts acknowledge all required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo', 'tm_bar']),
+          'https://host2.com': new Set(['tm_foo'])
+        }
+        const requirements = {
+          'https://host1.com': ['tm_foo', 'tm_bar']
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, requirements)
+        expect(result).toBe(true)
+      })
+
+      it('should return false when specific hosts do not acknowledge all required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(['tm_bar'])
+        }
+        const requirements = {
+          'https://host1.com': ['tm_foo', 'tm_bar']
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, requirements)
+        expect(result).toBe(false)
+      })
+
+      it('should return true when specific hosts acknowledge any of the required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(['tm_bar'])
+        }
+        const requirements = {
+          'https://host1.com': 'any'
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, requirements)
+        expect(result).toBe(true)
+      })
+
+      it('should return false when specific hosts do not acknowledge any of the required topics', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(),
+          'https://host2.com': new Set(['tm_bar'])
+        }
+        const requirements = {
+          'https://host1.com': 'any'
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, requirements)
+        expect(result).toBe(false)
+      })
+
+      it('should handle multiple hosts with different requirements', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(['tm_bar']),
+          'https://host3.com': new Set(['tm_foo', 'tm_bar'])
+        }
+        const requirements = {
+          'https://host1.com': ['tm_foo'],
+          'https://host2.com': 'any',
+          'https://host3.com': 'all'
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, requirements)
+        expect(result).toBe(true)
+      })
+
+      it('should return false if any specific host fails to meet its requirement', () => {
+        const hostAcknowledgments = {
+          'https://host1.com': new Set(['tm_foo']),
+          'https://host2.com': new Set(),
+          'https://host3.com': new Set(['tm_foo'])
+        }
+        const requirements = {
+          'https://host1.com': ['tm_foo'],
+          'https://host2.com': 'any',
+          'https://host3.com': ['tm_foo', 'tm_bar']
+        }
+        const result = (shipCast as any).checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, requirements)
+        expect(result).toBe(false)
+      })
+    })
+  })
+})