@bsv/sdk 1.1.33 → 1.2.0

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

@@ -0,0 +1,1403 @@
+import LookupResolver, { HTTPSOverlayLookupFacilitator } from '../../../dist/cjs/src/overlay-tools/LookupResolver.js'
+import OverlayAdminTokenTemplate from '../../../dist/cjs/src//overlay-tools/OverlayAdminTokenTemplate.js'
+import ProtoWallet from '../../../dist/cjs/src/wallet/ProtoWallet.js'
+import { PrivateKey } from '../../../dist/cjs/src/primitives/index.js'
+import { Transaction } from '../../../dist/cjs/src/transaction/index.js'
+import { LockingScript } from '../../../dist/cjs/src/script/index.js'
+
+const mockFacilitator = {
+  lookup: jest.fn()
+}
+
+const sampleBeef1 = new Transaction(1, [], [{ lockingScript: LockingScript.fromHex('88'), satoshis: 1 }], 0).toBEEF()
+const sampleBeef2 = new Transaction(1, [], [{ lockingScript: LockingScript.fromHex('88'), satoshis: 2 }], 0).toBEEF()
+const sampleBeef3 = new Transaction(1, [], [{ lockingScript: LockingScript.fromHex('88'), satoshis: 3 }], 0).toBEEF()
+const sampleBeef4 = new Transaction(1, [], [{ lockingScript: LockingScript.fromHex('88'), satoshis: 4 }], 0).toBEEF()
+
+describe('LookupResolver', () => {
+  beforeEach(() => {
+    mockFacilitator.lookup.mockReset()
+  })
+
+  it('should query the host and return the response when a single host is found via SLAP', async () => {
+    const slapHostKey = new PrivateKey(42)
+    const slapWallet = new ProtoWallet(slapHostKey)
+    const slapLib = new OverlayAdminTokenTemplate(slapWallet)
+    const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo')
+    const slapTx = new Transaction(1, [], [{
+      lockingScript: slapScript,
+      satoshis: 1
+    }], 0)
+
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        outputIndex: 0,
+        beef: slapTx.toBEEF()
+      }]
+    }).mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    })
+
+    const r = new LookupResolver({ facilitator: mockFacilitator, slapTrackers: ['https://mock.slap'] })
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    })
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should query from provided additional hosts while still making use of SLAP', async () => {
+    const slapHostKey = new PrivateKey(42)
+    const slapWallet = new ProtoWallet(slapHostKey)
+    const slapLib = new OverlayAdminTokenTemplate(slapWallet)
+    const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo')
+    const slapTx = new Transaction(1, [], [{
+      lockingScript: slapScript,
+      satoshis: 1
+    }], 0)
+
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        outputIndex: 0,
+        beef: slapTx.toBEEF()
+      }]
+    }).mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    }).mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{ // duplicate the output the other host knows about
+        beef: sampleBeef1,
+        outputIndex: 0
+      }, { // the additional host also knows about a second output
+        beef: sampleBeef2,
+        outputIndex: 1033
+      }]
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap'],
+      additionalHosts: {
+        ls_foo: ['https://additional.host']
+      }
+    })
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{ // expect the first output to appear only once, and be de-duplicated
+        beef: sampleBeef1,
+        outputIndex: 0
+      }, { // also expect the second output from the additional host
+        beef: sampleBeef2,
+        outputIndex: 1033
+      }]
+    })
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [ // additional host should also have been queried
+        'https://additional.host',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should utilize host overrides instead of SLAP', async () => {
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap'],
+      hostOverrides: {
+        ls_foo: ['https://override.host']
+      }
+    })
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    })
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://override.host',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should allow using host overrides with additional hosts at the same time', async () => {
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list', // from the override host
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    }).mockReturnValueOnce({
+      type: 'output-list', // from the additional host
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }, {
+        beef: sampleBeef2,
+        outputIndex: 1033
+      }]
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap'],
+      additionalHosts: {
+        ls_foo: ['https://additional.host']
+      },
+      hostOverrides: {
+        ls_foo: ['https://override.host']
+      }
+    })
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{ // expect the first output to appear only once, and be de-duplicated
+        beef: sampleBeef1,
+        outputIndex: 0
+      }, { // also expect the second output from the additional host
+        beef: sampleBeef2,
+        outputIndex: 1033
+      }]
+    })
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://override.host',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [ // additional host should also have been queried
+        'https://additional.host',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should handle multiple SLAP trackers and aggregate results from multiple hosts', async () => {
+    const slapHostKey1 = new PrivateKey(42)
+    const slapWallet1 = new ProtoWallet(slapHostKey1)
+    const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+    const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+    const slapTx1 = new Transaction(1, [], [{
+      lockingScript: slapScript1,
+      satoshis: 1
+    }], 0)
+
+    const slapHostKey2 = new PrivateKey(43)
+    const slapWallet2 = new ProtoWallet(slapHostKey2)
+    const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+    const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+    const slapTx2 = new Transaction(1, [], [{
+      lockingScript: slapScript2,
+      satoshis: 1
+    }], 0)
+
+    // SLAP trackers return hosts
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        outputIndex: 0,
+        beef: slapTx1.toBEEF()
+      }]
+    }).mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        outputIndex: 0,
+        beef: slapTx2.toBEEF()
+      }]
+    })
+
+    // Hosts respond to the query
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef3,
+        outputIndex: 0
+      }]
+    }).mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef4,
+        outputIndex: 1
+      }]
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap1', 'https://mock.slap2']
+    })
+
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [
+        { beef: sampleBeef3, outputIndex: 0 },
+        { beef: sampleBeef4, outputIndex: 1 }
+      ]
+    })
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap1',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://mock.slap2',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost1.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [
+        'https://slaphost2.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should de-duplicate outputs from multiple hosts', async () => {
+    const slapHostKey1 = new PrivateKey(42)
+    const slapWallet1 = new ProtoWallet(slapHostKey1)
+    const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+    const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+    const slapTx1 = new Transaction(1, [], [{
+      lockingScript: slapScript1,
+      satoshis: 1
+    }], 0)
+
+    const slapHostKey2 = new PrivateKey(43)
+    const slapWallet2 = new ProtoWallet(slapHostKey2)
+    const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+    const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+    const slapTx2 = new Transaction(1, [], [{
+      lockingScript: slapScript2,
+      satoshis: 1
+    }], 0)
+
+    // SLAP tracker returns two hosts
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { outputIndex: 0, beef: slapTx1.toBEEF() },
+        { outputIndex: 0, beef: slapTx2.toBEEF() }
+      ]
+    })
+
+    // Both hosts return the same output
+    const duplicateOutput = { beef: sampleBeef3, outputIndex: 0 }
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [duplicateOutput]
+    }).mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [duplicateOutput]
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap']
+    })
+
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [duplicateOutput]
+    })
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost1.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [
+        'https://slaphost2.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should handle hosts returning different response types', async () => {
+    const slapHostKey1 = new PrivateKey(42)
+    const slapWallet1 = new ProtoWallet(slapHostKey1)
+    const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+    const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+    const slapTx1 = new Transaction(1, [], [{
+      lockingScript: slapScript1,
+      satoshis: 1
+    }], 0)
+
+    const slapHostKey2 = new PrivateKey(43)
+    const slapWallet2 = new ProtoWallet(slapHostKey2)
+    const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+    const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+    const slapTx2 = new Transaction(1, [], [{
+      lockingScript: slapScript2,
+      satoshis: 1
+    }], 0)
+
+    // SLAP tracker returns two hosts
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { outputIndex: 0, beef: slapTx1.toBEEF() },
+        { outputIndex: 0, beef: slapTx2.toBEEF() }
+      ]
+    })
+
+    // First host returns 'freeform' response
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'freeform',
+      result: { message: 'Freeform response from host1' }
+    })
+
+    // Second host returns 'output-list' response
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap']
+    })
+
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+
+    // Since the first response is 'freeform', it should return that response
+    expect(res).toEqual({
+      type: 'freeform',
+      result: { message: 'Freeform response from host1' }
+    })
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost1.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [
+        'https://slaphost2.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should ignore freeform responses when first response is output-list', async () => {
+    const slapHostKey1 = new PrivateKey(42)
+    const slapWallet1 = new ProtoWallet(slapHostKey1)
+    const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+    const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+    const slapTx1 = new Transaction(1, [], [{
+      lockingScript: slapScript1,
+      satoshis: 1
+    }], 0)
+
+    const slapHostKey2 = new PrivateKey(43)
+    const slapWallet2 = new ProtoWallet(slapHostKey2)
+    const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+    const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+    const slapTx2 = new Transaction(1, [], [{
+      lockingScript: slapScript2,
+      satoshis: 1
+    }], 0)
+
+    // SLAP tracker returns two hosts
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { outputIndex: 0, beef: slapTx1.toBEEF() },
+        { outputIndex: 0, beef: slapTx2.toBEEF() }
+      ]
+    })
+
+    // First host returns 'output-list' response
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+    })
+
+    // Second host returns 'freeform' response
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'freeform',
+      result: { message: 'Freeform response from host2' }
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap']
+    })
+
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+    })
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost1.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [
+        'https://slaphost2.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should throw an error when no competent hosts are found', async () => {
+    // SLAP tracker returns empty output-list
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: []
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap']
+    })
+
+    await expect(r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })).rejects.toThrow('No competent hosts found by the SLAP trackers for lookup service: ls_foo')
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should not throw an error when one host fails to respond', async () => {
+    const slapHostKey1 = new PrivateKey(42)
+    const slapWallet1 = new ProtoWallet(slapHostKey1)
+    const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+    const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+    const slapTx1 = new Transaction(1, [], [{
+      lockingScript: slapScript1,
+      satoshis: 1
+    }], 0)
+
+    const slapHostKey2 = new PrivateKey(43)
+    const slapWallet2 = new ProtoWallet(slapHostKey2)
+    const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+    const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+    const slapTx2 = new Transaction(1, [], [{
+      lockingScript: slapScript2,
+      satoshis: 1
+    }], 0)
+
+    // SLAP tracker returns two hosts
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [
+        { outputIndex: 0, beef: slapTx1.toBEEF() },
+        { outputIndex: 0, beef: slapTx2.toBEEF() }
+      ]
+    })
+
+    // First host responds successfully
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+    })
+
+    // Second host fails to respond
+    mockFacilitator.lookup.mockImplementationOnce(async () => {
+      throw new Error('Host2 failed to respond')
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap']
+    })
+
+    const res = await r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })
+
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef3,
+        outputIndex: 0
+      }]
+    })
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ],
+      [
+        'https://slaphost1.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ],
+      [
+        'https://slaphost2.com',
+        {
+          service: 'ls_foo',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('Directly uses SLAP resolvers to facilitate SLAP queries', async () => {
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    })
+
+    const r = new LookupResolver({ facilitator: mockFacilitator, slapTrackers: ['https://mock.slap'] })
+    const res = await r.query({
+      service: 'ls_slap',
+      query: { test: 1 }
+    })
+    expect(res).toEqual({
+      type: 'output-list',
+      outputs: [{
+        beef: sampleBeef1,
+        outputIndex: 0
+      }]
+    })
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            test: 1
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should throw an error when SLAP tracker returns invalid response', async () => {
+    // SLAP tracker returns 'freeform' response
+    mockFacilitator.lookup.mockReturnValueOnce({
+      type: 'freeform',
+      result: { message: 'Invalid response' }
+    })
+
+    const r = new LookupResolver({
+      facilitator: mockFacilitator,
+      slapTrackers: ['https://mock.slap']
+    })
+
+    // Because a freeform response is not valid, the SLAP trackers have not found any competent hosts.
+    await expect(r.query({
+      service: 'ls_foo',
+      query: { test: 1 }
+    })).rejects.toThrow('No competent hosts found by the SLAP trackers for lookup service: ls_foo')
+
+    expect(mockFacilitator.lookup.mock.calls).toEqual([
+      [
+        'https://mock.slap',
+        {
+          service: 'ls_slap',
+          query: {
+            service: 'ls_foo'
+          }
+        }
+      ]
+    ])
+  })
+
+  it('should throw an error when HTTPSOverlayLookupFacilitator is used with non-HTTPS URL', async () => {
+    const facilitator = new HTTPSOverlayLookupFacilitator()
+    await expect(facilitator.lookup('http://insecure.url', { service: 'test', query: {} }))
+      .rejects.toThrow('HTTPS facilitator can only use URLs that start with "https:"')
+  })
+  describe('LookupResolver Resiliency', () => {
+    beforeEach(() => {
+      mockFacilitator.lookup.mockReset()
+    })
+
+    it('should continue to function when one SLAP tracker fails', async () => {
+      const slapHostKey = new PrivateKey(42)
+      const slapWallet = new ProtoWallet(slapHostKey)
+      const slapLib = new OverlayAdminTokenTemplate(slapWallet)
+      const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo')
+      const slapTx = new Transaction(1, [], [{
+        lockingScript: slapScript,
+        satoshis: 1
+      }], 0)
+
+      // First SLAP tracker fails
+      mockFacilitator.lookup.mockImplementationOnce(async () => {
+        throw new Error('SLAP tracker failed')
+      })
+
+      // Second SLAP tracker succeeds
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{
+          outputIndex: 0,
+          beef: slapTx.toBEEF()
+        }]
+      })
+
+      // Host responds successfully
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{
+          beef: sampleBeef3,
+          outputIndex: 0
+        }]
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap1', 'https://mock.slap2']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: [{
+          beef: sampleBeef3,
+          outputIndex: 0
+        }]
+      })
+
+      expect(mockFacilitator.lookup.mock.calls).toEqual([
+        [
+          'https://mock.slap1',
+          {
+            service: 'ls_slap',
+            query: {
+              service: 'ls_foo'
+            }
+          }
+        ],
+        [
+          'https://mock.slap2',
+          {
+            service: 'ls_slap',
+            query: {
+              service: 'ls_foo'
+            }
+          }
+        ],
+        [
+          'https://slaphost.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ]
+      ])
+    })
+
+    it('should aggregate outputs from hosts that respond, even if some SLAP trackers lie to our face', async () => {
+      const slapHostKey1 = new PrivateKey(42)
+      const slapWallet1 = new ProtoWallet(slapHostKey1)
+      const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+      const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+      const slapTx1 = new Transaction(1, [], [{
+        lockingScript: slapScript1,
+        satoshis: 1
+      }], 0)
+
+      const slapHostKey2 = new PrivateKey(43)
+      const slapWallet2 = new ProtoWallet(slapHostKey2)
+      const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+      const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+      const slapTx2 = new Transaction(1, [], [{
+        lockingScript: slapScript2,
+        satoshis: 1
+      }], 0)
+
+      const slapHostKey3 = new PrivateKey(44)
+      const slapWallet3 = new ProtoWallet(slapHostKey3)
+      const slapLib3 = new OverlayAdminTokenTemplate(slapWallet3)
+      const slapScript3 = await slapLib3.lock('SLAP', 'https://slaphost3.pantsonfire.com', 'ls_not_what_i_asked_you_for')
+      const slapTx3 = new Transaction(1, [], [{
+        lockingScript: slapScript3,
+        satoshis: 1
+      }], 0)
+
+      // SLAP trackers return hosts
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [
+          { outputIndex: 0, beef: slapTx1.toBEEF() },
+          { outputIndex: 0, beef: slapTx2.toBEEF() },
+          { outputIndex: 0, beef: slapTx3.toBEEF() }
+        ]
+      })
+
+      // First host responds successfully
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      // Second host fails
+      mockFacilitator.lookup.mockImplementationOnce(async () => {
+        throw new Error('Host2 failed')
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      expect(mockFacilitator.lookup.mock.calls).toEqual([
+        [
+          'https://mock.slap',
+          {
+            service: 'ls_slap',
+            query: {
+              service: 'ls_foo'
+            }
+          }
+        ],
+        [
+          'https://slaphost1.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ],
+        [
+          'https://slaphost2.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ]
+      ])
+    })
+
+    it('should aggregate outputs from hosts that respond, even if some SLAP trackers give us rotten BEEF', async () => {
+      const slapHostKey1 = new PrivateKey(42)
+      const slapWallet1 = new ProtoWallet(slapHostKey1)
+      const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+      const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+      const slapTx1 = new Transaction(1, [], [{
+        lockingScript: slapScript1,
+        satoshis: 1
+      }], 0)
+
+      const slapHostKey2 = new PrivateKey(43)
+      const slapWallet2 = new ProtoWallet(slapHostKey2)
+      const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+      const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+      const slapTx2 = new Transaction(1, [], [{
+        lockingScript: slapScript2,
+        satoshis: 1
+      }], 0)
+
+      // SLAP trackers return hosts
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [
+          { outputIndex: 0, beef: slapTx1.toBEEF() },
+          { outputIndex: 0, beef: slapTx2.toBEEF() },
+          { outputIndex: 0, beef: [0] } // "rotten" (corrupted) BEEF
+        ]
+      })
+
+      // First host responds successfully
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      // Second host fails
+      mockFacilitator.lookup.mockImplementationOnce(async () => {
+        throw new Error('Host2 failed')
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      expect(mockFacilitator.lookup.mock.calls).toEqual([
+        [
+          'https://mock.slap',
+          {
+            service: 'ls_slap',
+            query: {
+              service: 'ls_foo'
+            }
+          }
+        ],
+        [
+          'https://slaphost1.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ],
+        [
+          'https://slaphost2.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ]
+      ])
+    })
+
+    it('should aggregate outputs from hosts that respond, even if some fail', async () => {
+      const slapHostKey1 = new PrivateKey(42)
+      const slapWallet1 = new ProtoWallet(slapHostKey1)
+      const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+      const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+      const slapTx1 = new Transaction(1, [], [{
+        lockingScript: slapScript1,
+        satoshis: 1
+      }], 0)
+
+      const slapHostKey2 = new PrivateKey(43)
+      const slapWallet2 = new ProtoWallet(slapHostKey2)
+      const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+      const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+      const slapTx2 = new Transaction(1, [], [{
+        lockingScript: slapScript2,
+        satoshis: 1
+      }], 0)
+
+      // SLAP trackers return hosts
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [
+          { outputIndex: 0, beef: slapTx1.toBEEF() },
+          { outputIndex: 0, beef: slapTx2.toBEEF() }
+        ]
+      })
+
+      // First host responds successfully
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      // Second host fails
+      mockFacilitator.lookup.mockImplementationOnce(async () => {
+        throw new Error('Host2 failed')
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      expect(mockFacilitator.lookup.mock.calls).toEqual([
+        [
+          'https://mock.slap',
+          {
+            service: 'ls_slap',
+            query: {
+              service: 'ls_foo'
+            }
+          }
+        ],
+        [
+          'https://slaphost1.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ],
+        [
+          'https://slaphost2.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ]
+      ])
+    })
+
+    it('should handle invalid responses from some hosts and continue with valid ones', async () => {
+      const slapHostKey = new PrivateKey(42)
+      const slapWallet = new ProtoWallet(slapHostKey)
+      const slapLib = new OverlayAdminTokenTemplate(slapWallet)
+      const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo')
+      const slapTx = new Transaction(1, [], [{
+        lockingScript: slapScript,
+        satoshis: 1
+      }], 0)
+
+      // SLAP tracker returns host
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ outputIndex: 0, beef: slapTx.toBEEF() }]
+      })
+
+      // Host returns invalid response
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'invalid-type',
+        data: {}
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      // Since there are no valid outputs, expect an error
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: []
+      })
+
+      expect(mockFacilitator.lookup.mock.calls).toEqual([
+        [
+          'https://mock.slap',
+          {
+            service: 'ls_slap',
+            query: {
+              service: 'ls_foo'
+            }
+          }
+        ],
+        [
+          'https://slaphost.com',
+          {
+            service: 'ls_foo',
+            query: {
+              test: 1
+            }
+          }
+        ]
+      ])
+    })
+
+    it('should handle all SLAP trackers failing and throw an error', async () => {
+      // Both SLAP trackers fail
+      mockFacilitator.lookup.mockImplementation(async () => {
+        throw new Error('SLAP tracker failed')
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap1', 'https://mock.slap2']
+      })
+
+      await expect(r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })).rejects.toThrow('No competent hosts found by the SLAP trackers for lookup service: ls_foo')
+
+      expect(mockFacilitator.lookup.mock.calls.length).toBe(2)
+    })
+
+    it('should handle all hosts failing and throw an error', async () => {
+      const slapHostKey = new PrivateKey(42)
+      const slapWallet = new ProtoWallet(slapHostKey)
+      const slapLib = new OverlayAdminTokenTemplate(slapWallet)
+      const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo')
+      const slapTx = new Transaction(1, [], [{
+        lockingScript: slapScript,
+        satoshis: 1
+      }], 0)
+
+      // SLAP tracker returns host
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ outputIndex: 0, beef: slapTx.toBEEF() }]
+      })
+
+      // Host fails
+      mockFacilitator.lookup.mockImplementationOnce(async () => {
+        throw new Error('Host failed')
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      await expect(r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })).rejects.toThrow('No successful responses from any hosts')
+
+      expect(mockFacilitator.lookup.mock.calls.length).toBe(2)
+    })
+
+    it('should continue to aggregate outputs when some hosts return invalid outputs', async () => {
+      const slapHostKey1 = new PrivateKey(42)
+      const slapWallet1 = new ProtoWallet(slapHostKey1)
+      const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+      const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+      const slapTx1 = new Transaction(1, [], [{
+        lockingScript: slapScript1,
+        satoshis: 1
+      }], 0)
+
+      const slapHostKey2 = new PrivateKey(43)
+      const slapWallet2 = new ProtoWallet(slapHostKey2)
+      const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+      const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+      const slapTx2 = new Transaction(1, [], [{
+        lockingScript: slapScript2,
+        satoshis: 1
+      }], 0)
+
+      // SLAP tracker returns two hosts
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [
+          { outputIndex: 0, beef: slapTx1.toBEEF() },
+          { outputIndex: 0, beef: slapTx2.toBEEF() }
+        ]
+      })
+
+      // First host returns valid output
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      // Second host returns invalid output
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ invalid: true }]
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      expect(mockFacilitator.lookup.mock.calls.length).toBe(3)
+    })
+
+    it('should continue to aggregate outputs when some hosts return malformed malarkie', async () => {
+      const slapHostKey1 = new PrivateKey(42)
+      const slapWallet1 = new ProtoWallet(slapHostKey1)
+      const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
+      const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo')
+      const slapTx1 = new Transaction(1, [], [{
+        lockingScript: slapScript1,
+        satoshis: 1
+      }], 0)
+
+      const slapHostKey2 = new PrivateKey(43)
+      const slapWallet2 = new ProtoWallet(slapHostKey2)
+      const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
+      const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo')
+      const slapTx2 = new Transaction(1, [], [{
+        lockingScript: slapScript2,
+        satoshis: 1
+      }], 0)
+
+      // SLAP tracker returns two hosts
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [
+          { outputIndex: 0, beef: slapTx1.toBEEF() },
+          { outputIndex: 0, beef: slapTx2.toBEEF() }
+        ]
+      })
+
+      // First host returns valid output
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      // Second host returns invalid output
+      mockFacilitator.lookup.mockReturnValueOnce({
+        type: 'output-list',
+        output: 'document.createElement('
+      })
+
+      const r = new LookupResolver({
+        facilitator: mockFacilitator,
+        slapTrackers: ['https://mock.slap']
+      })
+
+      const res = await r.query({
+        service: 'ls_foo',
+        query: { test: 1 }
+      })
+
+      expect(res).toEqual({
+        type: 'output-list',
+        outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
+      })
+
+      expect(mockFacilitator.lookup.mock.calls.length).toBe(3)
+    })
+  })
+})