@bsv/wallet-toolbox 1.7.16 → 1.7.18

package/mobile/node_modules/@bsv/sdk/src/overlay-tools/__tests/LookupResolver.test.ts

@@ -1,1805 +0,0 @@
-import LookupResolver, {
-  HTTPSOverlayLookupFacilitator
-} from '../LookupResolver'
-import { getOverlayHostReputationTracker } from '../HostReputationTracker'
-import OverlayAdminTokenTemplate from '../../overlay-tools/OverlayAdminTokenTemplate'
-import { CompletedProtoWallet } from '../../auth/certificates/__tests/CompletedProtoWallet'
-import { PrivateKey } from '../../primitives/index'
-import { Transaction } from '../../transaction/index'
-import { LockingScript } from '../../script/index'
-
-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', () => {
-  const hostTracker = getOverlayHostReputationTracker()
-  beforeEach(() => {
-    mockFacilitator.lookup.mockReset()
-    hostTracker.reset()
-  })
-
-  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 CompletedProtoWallet(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'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  it('should query from provided additional hosts while still making use of SLAP', async () => {
-    const slapHostKey = new PrivateKey(42)
-    const slapWallet = new CompletedProtoWallet(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'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ],
-      [
-        // additional host should also have been queried
-        'https://additional.host',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  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
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  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
-          }
-        },
-        undefined
-      ],
-      [
-        // additional host should also have been queried
-        'https://additional.host',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  it('should handle multiple SLAP trackers and aggregate results from multiple hosts', async () => {
-    const slapHostKey1 = new PrivateKey(42)
-    const slapWallet1 = new CompletedProtoWallet(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 CompletedProtoWallet(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'
-          }
-        },
-        5000
-      ],
-      [
-        'https://mock.slap2',
-        {
-          service: 'ls_slap',
-          query: {
-            service: 'ls_foo'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost1.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ],
-      [
-        'https://slaphost2.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  it('should de-duplicate outputs from multiple hosts', async () => {
-    const slapHostKey1 = new PrivateKey(42)
-    const slapWallet1 = new CompletedProtoWallet(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 CompletedProtoWallet(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'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost1.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ],
-      [
-        'https://slaphost2.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  it('should ignore freeform responses when first response is output-list', async () => {
-    const slapHostKey1 = new PrivateKey(42)
-    const slapWallet1 = new CompletedProtoWallet(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 CompletedProtoWallet(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'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost1.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ],
-      [
-        'https://slaphost2.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  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 mainnet 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'
-          }
-        },
-        5000
-      ]
-    ])
-  })
-
-  it('should not throw an error when one host fails to respond', async () => {
-    const slapHostKey1 = new PrivateKey(42)
-    const slapWallet1 = new CompletedProtoWallet(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 CompletedProtoWallet(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'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost1.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ],
-      [
-        'https://slaphost2.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  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
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
-  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 mainnet 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'
-          }
-        },
-        5000
-      ]
-    ])
-  })
-
-  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('Host reputation tracking', () => {
-    it('shares performance learnings across resolver instances and prefers low latency hosts', async () => {
-      const fastHost = 'https://fast.host'
-      const slowHost = 'https://slow.host'
-      const hosts = [slowHost, fastHost]
-      let fakeNow = 0
-      const nowSpy = jest.spyOn(Date, 'now').mockImplementation(() => fakeNow)
-
-      try {
-        mockFacilitator.lookup.mockImplementation(async (url: string) => {
-          if (url === slowHost) {
-            fakeNow += 80
-          } else if (url === fastHost) {
-            fakeNow += 5
-          }
-          return {
-            type: 'output-list',
-            outputs: [
-              {
-                beef: url === fastHost ? sampleBeef2 : sampleBeef1,
-                outputIndex: url === fastHost ? 2 : 1
-              }
-            ]
-          }
-        })
-
-        const resolverA = new LookupResolver({
-          facilitator: mockFacilitator,
-          hostOverrides: {
-            ls_latency: hosts
-          }
-        })
-        await resolverA.query({
-          service: 'ls_latency',
-          query: { attempt: 1 }
-        })
-
-        mockFacilitator.lookup.mockClear()
-
-        const resolverB = new LookupResolver({
-          facilitator: mockFacilitator,
-          hostOverrides: {
-            ls_latency: hosts
-          }
-        })
-        await resolverB.query({
-          service: 'ls_latency',
-          query: { attempt: 2 }
-        })
-
-        const orderedHosts = mockFacilitator.lookup.mock.calls.map((call) => call[0])
-        expect(orderedHosts).toEqual([fastHost, slowHost])
-      } finally {
-        nowSpy.mockRestore()
-      }
-    })
-
-    it('exponentially backs off consistently failing hosts to avoid repeated work', async () => {
-      const failingHost = 'https://offline.host'
-      const healthyHost = 'https://healthy.host'
-      let fakeNow = 0
-      const nowSpy = jest.spyOn(Date, 'now').mockImplementation(() => fakeNow)
-      const callLog: string[] = []
-      let failingCalls = 0
-
-      try {
-        mockFacilitator.lookup.mockImplementation(async (url: string) => {
-          callLog.push(url)
-          fakeNow += 5
-          if (url === failingHost) {
-            failingCalls += 1
-            throw new Error('offline')
-          }
-          return {
-            type: 'output-list',
-            outputs: [
-              {
-                beef: sampleBeef3,
-                outputIndex: 0
-              }
-            ]
-          }
-        })
-
-        const resolver = new LookupResolver({
-          facilitator: mockFacilitator,
-          hostOverrides: {
-            ls_backoff: [failingHost, healthyHost]
-          }
-        })
-
-        // First three attempts should contact both hosts (grace period)
-        await resolver.query({ service: 'ls_backoff', query: { attempt: 1 } })
-        fakeNow += 20
-        await resolver.query({ service: 'ls_backoff', query: { attempt: 2 } })
-        fakeNow += 20
-        await resolver.query({ service: 'ls_backoff', query: { attempt: 3 } })
-
-        expect(failingCalls).toBe(3)
-
-        // Immediately try again; failing host should now be in backoff and skipped
-        fakeNow += 20
-        await resolver.query({ service: 'ls_backoff', query: { attempt: 4 } })
-        expect(failingCalls).toBe(3)
-        const lastCall = callLog[callLog.length - 1]
-        expect(lastCall).toBe(healthyHost)
-
-        // Advance beyond the backoff window so the failing host is retried
-        fakeNow = 2000
-        await resolver.query({ service: 'ls_backoff', query: { attempt: 5 } })
-        expect(failingCalls).toBe(4)
-      } finally {
-        nowSpy.mockRestore()
-      }
-    })
-  })
-  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 CompletedProtoWallet(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'
-            }
-          },
-          5000
-        ],
-        [
-          'https://mock.slap2',
-          {
-            service: 'ls_slap',
-            query: {
-              service: 'ls_foo'
-            }
-          },
-          5000
-        ],
-        [
-          'https://slaphost.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ]
-      ])
-    })
-
-    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 CompletedProtoWallet(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 CompletedProtoWallet(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 CompletedProtoWallet(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'
-            }
-          },
-          5000
-        ],
-        [
-          'https://slaphost1.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ],
-        [
-          'https://slaphost2.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ]
-      ])
-    })
-
-    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 CompletedProtoWallet(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 CompletedProtoWallet(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'
-            }
-          },
-          5000
-        ],
-        [
-          'https://slaphost1.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ],
-        [
-          'https://slaphost2.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ]
-      ])
-    })
-
-    it('should aggregate outputs from hosts that respond, even if some fail', async () => {
-      const slapHostKey1 = new PrivateKey(42)
-      const slapWallet1 = new CompletedProtoWallet(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 CompletedProtoWallet(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'
-            }
-          },
-          5000
-        ],
-        [
-          'https://slaphost1.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ],
-        [
-          'https://slaphost2.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ]
-      ])
-    })
-
-    it('should handle invalid responses from some hosts and continue with valid ones', async () => {
-      const slapHostKey = new PrivateKey(42)
-      const slapWallet = new CompletedProtoWallet(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'
-            }
-          },
-          5000
-        ],
-        [
-          'https://slaphost.com',
-          {
-            service: 'ls_foo',
-            query: {
-              test: 1
-            }
-          },
-          undefined
-        ]
-      ])
-    })
-
-    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 mainnet hosts found by the SLAP trackers for lookup service: ls_foo'
-      )
-
-      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 CompletedProtoWallet(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 CompletedProtoWallet(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 CompletedProtoWallet(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 CompletedProtoWallet(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)
-    })
-  })
-})