@bsv/sdk 1.3.11 → 1.3.13

package/dist/cjs/src/overlay-tools/__tests/LookupResolver.test.js

@@ -0,0 +1,1471 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LookupResolver_1 = __importStar(require("../LookupResolver"));
+const OverlayAdminTokenTemplate_1 = __importDefault(require("../../overlay-tools/OverlayAdminTokenTemplate"));
+const CompletedProtoWallet_1 = require("../../auth/certificates/__tests/CompletedProtoWallet");
+const index_1 = require("../../primitives/index");
+const index_2 = require("../../transaction/index");
+const index_3 = require("../../script/index");
+const mockFacilitator = {
+    lookup: jest.fn()
+};
+const sampleBeef1 = new index_2.Transaction(1, [], [{ lockingScript: index_3.LockingScript.fromHex('88'), satoshis: 1 }], 0).toBEEF();
+const sampleBeef2 = new index_2.Transaction(1, [], [{ lockingScript: index_3.LockingScript.fromHex('88'), satoshis: 2 }], 0).toBEEF();
+const sampleBeef3 = new index_2.Transaction(1, [], [{ lockingScript: index_3.LockingScript.fromHex('88'), satoshis: 3 }], 0).toBEEF();
+const sampleBeef4 = new index_2.Transaction(1, [], [{ lockingScript: index_3.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 index_1.PrivateKey(42);
+        const slapWallet = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey);
+        const slapLib = new OverlayAdminTokenTemplate_1.default(slapWallet);
+        const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo');
+        const slapTx = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                '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 index_1.PrivateKey(42);
+        const slapWallet = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey);
+        const slapLib = new OverlayAdminTokenTemplate_1.default(slapWallet);
+        const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo');
+        const slapTx = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                '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_1.default({
+            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_1.default({
+            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 index_1.PrivateKey(42);
+        const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+        const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+        const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+        const slapTx1 = new index_2.Transaction(1, [], [
+            {
+                lockingScript: slapScript1,
+                satoshis: 1
+            }
+        ], 0);
+        const slapHostKey2 = new index_1.PrivateKey(43);
+        const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+        const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+        const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+        const slapTx2 = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                'https://mock.slap2',
+                {
+                    service: 'ls_slap',
+                    query: {
+                        service: 'ls_foo'
+                    }
+                },
+                1000
+            ],
+            [
+                '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 index_1.PrivateKey(42);
+        const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+        const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+        const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+        const slapTx1 = new index_2.Transaction(1, [], [
+            {
+                lockingScript: slapScript1,
+                satoshis: 1
+            }
+        ], 0);
+        const slapHostKey2 = new index_1.PrivateKey(43);
+        const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+        const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+        const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+        const slapTx2 = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                'https://slaphost1.com',
+                {
+                    service: 'ls_foo',
+                    query: {
+                        test: 1
+                    }
+                },
+                undefined
+            ],
+            [
+                'https://slaphost2.com',
+                {
+                    service: 'ls_foo',
+                    query: {
+                        test: 1
+                    }
+                },
+                undefined
+            ]
+        ]);
+    });
+    it('should handle hosts returning different response types', async () => {
+        const slapHostKey1 = new index_1.PrivateKey(42);
+        const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+        const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+        const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+        const slapTx1 = new index_2.Transaction(1, [], [
+            {
+                lockingScript: slapScript1,
+                satoshis: 1
+            }
+        ], 0);
+        const slapHostKey2 = new index_1.PrivateKey(43);
+        const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+        const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+        const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+        const slapTx2 = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                '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 index_1.PrivateKey(42);
+        const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+        const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+        const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+        const slapTx1 = new index_2.Transaction(1, [], [
+            {
+                lockingScript: slapScript1,
+                satoshis: 1
+            }
+        ], 0);
+        const slapHostKey2 = new index_1.PrivateKey(43);
+        const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+        const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+        const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+        const slapTx2 = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                '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_1.default({
+            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'
+                    }
+                },
+                1000
+            ]
+        ]);
+    });
+    it('should not throw an error when one host fails to respond', async () => {
+        const slapHostKey1 = new index_1.PrivateKey(42);
+        const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+        const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+        const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+        const slapTx1 = new index_2.Transaction(1, [], [
+            {
+                lockingScript: slapScript1,
+                satoshis: 1
+            }
+        ], 0);
+        const slapHostKey2 = new index_1.PrivateKey(43);
+        const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+        const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+        const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+        const slapTx2 = new index_2.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_1.default({
+            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'
+                    }
+                },
+                1000
+            ],
+            [
+                '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_1.default({
+            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_1.default({
+            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'
+                    }
+                },
+                1000
+            ]
+        ]);
+    });
+    it('should throw an error when HTTPSOverlayLookupFacilitator is used with non-HTTPS URL', async () => {
+        const facilitator = new LookupResolver_1.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 index_1.PrivateKey(42);
+            const slapWallet = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey);
+            const slapLib = new OverlayAdminTokenTemplate_1.default(slapWallet);
+            const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo');
+            const slapTx = new index_2.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_1.default({
+                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'
+                        }
+                    },
+                    1000
+                ],
+                [
+                    'https://mock.slap2',
+                    {
+                        service: 'ls_slap',
+                        query: {
+                            service: 'ls_foo'
+                        }
+                    },
+                    1000
+                ],
+                [
+                    '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 index_1.PrivateKey(42);
+            const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+            const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+            const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+            const slapTx1 = new index_2.Transaction(1, [], [
+                {
+                    lockingScript: slapScript1,
+                    satoshis: 1
+                }
+            ], 0);
+            const slapHostKey2 = new index_1.PrivateKey(43);
+            const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+            const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+            const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+            const slapTx2 = new index_2.Transaction(1, [], [
+                {
+                    lockingScript: slapScript2,
+                    satoshis: 1
+                }
+            ], 0);
+            const slapHostKey3 = new index_1.PrivateKey(44);
+            const slapWallet3 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey3);
+            const slapLib3 = new OverlayAdminTokenTemplate_1.default(slapWallet3);
+            const slapScript3 = await slapLib3.lock('SLAP', 'https://slaphost3.pantsonfire.com', 'ls_not_what_i_asked_you_for');
+            const slapTx3 = new index_2.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_1.default({
+                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'
+                        }
+                    },
+                    1000
+                ],
+                [
+                    '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 index_1.PrivateKey(42);
+            const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+            const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+            const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+            const slapTx1 = new index_2.Transaction(1, [], [
+                {
+                    lockingScript: slapScript1,
+                    satoshis: 1
+                }
+            ], 0);
+            const slapHostKey2 = new index_1.PrivateKey(43);
+            const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+            const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+            const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+            const slapTx2 = new index_2.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_1.default({
+                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'
+                        }
+                    },
+                    1000
+                ],
+                [
+                    '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 index_1.PrivateKey(42);
+            const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+            const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+            const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+            const slapTx1 = new index_2.Transaction(1, [], [
+                {
+                    lockingScript: slapScript1,
+                    satoshis: 1
+                }
+            ], 0);
+            const slapHostKey2 = new index_1.PrivateKey(43);
+            const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+            const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+            const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+            const slapTx2 = new index_2.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_1.default({
+                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'
+                        }
+                    },
+                    1000
+                ],
+                [
+                    '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 index_1.PrivateKey(42);
+            const slapWallet = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey);
+            const slapLib = new OverlayAdminTokenTemplate_1.default(slapWallet);
+            const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo');
+            const slapTx = new index_2.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_1.default({
+                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'
+                        }
+                    },
+                    1000
+                ],
+                [
+                    '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_1.default({
+                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 index_1.PrivateKey(42);
+            const slapWallet = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey);
+            const slapLib = new OverlayAdminTokenTemplate_1.default(slapWallet);
+            const slapScript = await slapLib.lock('SLAP', 'https://slaphost.com', 'ls_foo');
+            const slapTx = new index_2.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_1.default({
+                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 index_1.PrivateKey(42);
+            const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+            const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+            const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+            const slapTx1 = new index_2.Transaction(1, [], [
+                {
+                    lockingScript: slapScript1,
+                    satoshis: 1
+                }
+            ], 0);
+            const slapHostKey2 = new index_1.PrivateKey(43);
+            const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+            const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+            const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+            const slapTx2 = new index_2.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_1.default({
+                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 index_1.PrivateKey(42);
+            const slapWallet1 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey1);
+            const slapLib1 = new OverlayAdminTokenTemplate_1.default(slapWallet1);
+            const slapScript1 = await slapLib1.lock('SLAP', 'https://slaphost1.com', 'ls_foo');
+            const slapTx1 = new index_2.Transaction(1, [], [
+                {
+                    lockingScript: slapScript1,
+                    satoshis: 1
+                }
+            ], 0);
+            const slapHostKey2 = new index_1.PrivateKey(43);
+            const slapWallet2 = new CompletedProtoWallet_1.CompletedProtoWallet(slapHostKey2);
+            const slapLib2 = new OverlayAdminTokenTemplate_1.default(slapWallet2);
+            const slapScript2 = await slapLib2.lock('SLAP', 'https://slaphost2.com', 'ls_foo');
+            const slapTx2 = new index_2.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_1.default({
+                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);
+        });
+    });
+});
+//# sourceMappingURL=LookupResolver.test.js.map