@hackerhouse/xpub-scan 1.0.0

package/__tests__/deriveAddresses/deriveBitcoinCashAddresses.test copy.ts

@@ -0,0 +1,79 @@
+import { configuration } from "../../src/configuration/settings";
+import { currencies, DerivationMode } from "../../src/configuration/currencies";
+import { deriveAddress } from "../../src/actions/deriveAddresses";
+
+describe("derive Bitcoin Cash addresses", () => {
+  let xpub;
+  let derivationMode;
+
+  describe("derive Bitcoin Cash mainnet addresses", () => {
+    beforeEach(() => {
+      xpub =
+        "xpub6CJgFcZxrd2yjt11C91E4xTb7whLw1amvXzzhhdmfqutTdbT53GS4nbS6pcsPQ2EJyPBxWi7Rvro2pqBVUuKj1BqET1gujWmLE6WJD7pb1o";
+      configuration.currency = currencies.bch;
+      configuration.currency.network = currencies.bch.network_mainnet;
+    });
+
+    describe("derive Legacy addresses", () => {
+      beforeEach(() => {
+        derivationMode = DerivationMode.LEGACY;
+      });
+
+      it("derive m/0/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 0);
+        expect(address).toEqual("195D2Q9NPSpZxkD2gmEtNFzK8s65FS7QZB");
+      });
+
+      it("derive m/0/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 1);
+        expect(address).toEqual("1Nchm2Yu65gGua1jNF1viaNPYLtjmmgzpe");
+      });
+
+      it("derive m/1/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 0);
+        expect(address).toEqual("1JJEsMr4dpTtsA9JL8HyQVN2NZ4WsMuoMj");
+      });
+
+      it("derive m/1/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 1);
+        expect(address).toEqual("1EL7PVjrHMNPpCk47T86URSzVRqccdexVy");
+      });
+
+      it("derive m/1/10000000", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 10000000);
+        expect(address).toEqual("1Lutb2GiXzT1VmstpNp89Gdv5xK1WxS7yw");
+      });
+    });
+
+    describe("derive SegWit addresses", () => {
+      beforeEach(() => {
+        derivationMode = DerivationMode.SEGWIT;
+      });
+
+      it("derive m/0/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 0);
+        expect(address).toEqual("3Hznz37SVW7SCQVexMuHouGxS2JkT5SBcE");
+      });
+
+      it("derive m/0/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 1);
+        expect(address).toEqual("3H4PXNXFZBMXXtj73a2M4ZnWyKcAFMcw7p");
+      });
+
+      it("derive m/1/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 0);
+        expect(address).toEqual("3PXDUXZBqN1su1wYeBy1guBkUJVFLzupqP");
+      });
+
+      it("derive m/1/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 1);
+        expect(address).toEqual("34DmE8fnF6dSHHtY3H2suDB3jDedBMZVMf");
+      });
+
+      it("derive m/1/10000000", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 10000000);
+        expect(address).toEqual("3DdXQRrzTndRWyEiR1JRKVCJp7YZsJUwff");
+      });
+    });
+  });
+});

package/__tests__/deriveAddresses/deriveDogecoinAddresses.test.ts

@@ -0,0 +1,43 @@
+import { configuration } from "../../src/configuration/settings";
+import { currencies, DerivationMode } from "../../src/configuration/currencies";
+import { deriveAddress } from "../../src/actions/deriveAddresses";
+
+describe("derive Dogecoin addresses", () => {
+  let xpub;
+  let derivationMode;
+
+  describe("derive Dogecoin mainnet addresses", () => {
+    beforeEach(() => {
+      xpub =
+        "dgub8rDzyFqzw35B8zSqrW9sHDivXL2YmcGEVKyRMhPh8SoeUmkGozD5YzNyEkSH1T9zhvy9iQzns7igxrhQkg4jETWna4X1AUC4MT3YgHenTMB";
+      configuration.currency = currencies.doge;
+      configuration.currency.network = currencies.doge.network_mainnet;
+      derivationMode = DerivationMode.DOGECOIN;
+    });
+
+    it("derive m/0/0", () => {
+      const address = deriveAddress(derivationMode, xpub, 0, 0);
+      expect(address).toEqual("DNoFXKQVgbYU5pnpJEoiJjoWs1yH74KcvC");
+    });
+
+    it("derive m/0/1", () => {
+      const address = deriveAddress(derivationMode, xpub, 0, 1);
+      expect(address).toEqual("DNKtLJKxfYascpVyVHyQ73S65ssKQtH95A");
+    });
+
+    it("derive m/1/0", () => {
+      const address = deriveAddress(derivationMode, xpub, 1, 0);
+      expect(address).toEqual("DLnAvdtK2DDGeakaQUf2BUvZVUJw7KRgTg");
+    });
+
+    it("derive m/1/1", () => {
+      const address = deriveAddress(derivationMode, xpub, 1, 1);
+      expect(address).toEqual("DC6Pmh6eGENRC8T2cu5roTXPPQXBMk8b2o");
+    });
+
+    it("derive m/1/10000000", () => {
+      const address = deriveAddress(derivationMode, xpub, 1, 10000000);
+      expect(address).toEqual("D6Yf9DRNY8VSTtorybWJzJbDBugExnMTsg");
+    });
+  });
+});

package/__tests__/deriveAddresses/deriveEthereumAddresses.test.ts

@@ -0,0 +1,26 @@
+import { configuration } from "../../src/configuration/settings";
+import { currencies, DerivationMode } from "../../src/configuration/currencies";
+import { deriveAddress } from "../../src/actions/deriveAddresses";
+
+describe("derive Ethereum addresses", () => {
+  let derivationMode;
+
+  beforeEach(() => {
+    derivationMode = DerivationMode.ETHEREUM;
+    configuration.currency = currencies.eth;
+  });
+
+  it("derive from xpub6Fx82V...zwKG5g4Sc6", () => {
+    const xpub =
+      "xpub6Fx82VfZ6EdtNfD7eANUEvKYxB2AV4hf4Xm4LpiyNVmNHDGKu7T72WVr7qmCzKFC3VQMYrMMNJVy9BNXKUtUebxZx7kRYNG89zwKG5g4Sc6";
+    const address = deriveAddress(derivationMode, xpub);
+    expect(address).toEqual("0xb56aa13aab4869da8ae07ad2a04ec2deec35e0f0");
+  });
+
+  it("derive from xpub6GkCbW...Lejvh9nHE", () => {
+    const xpub =
+      "xpub6GkCbW4FDnz8k9zhroVhZefi9fXhFFuTmmcQqfQKPDBrQjtSu4pdLpQ1Tje1BAzUw6PbJ47MMtNZ4RYM42VzRNxwaYUFnm3R44Lejvh9nHE";
+    const address = deriveAddress(derivationMode, xpub);
+    expect(address).toEqual("0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1");
+  });
+});

package/__tests__/deriveAddresses/deriveLitecoinAddresses.test.ts

@@ -0,0 +1,110 @@
+import { configuration } from "../../src/configuration/settings";
+import { currencies, DerivationMode } from "../../src/configuration/currencies";
+import { deriveAddress } from "../../src/actions/deriveAddresses";
+
+describe("derive Litecoin addresses", () => {
+  let xpub;
+  let derivationMode;
+
+  describe("derive Litecoin mainnet addresses", () => {
+    beforeEach(() => {
+      xpub =
+        "Ltub2ZoLFXBt7mLeb4out9duUxMmqCSX9mqi73NcQ8nyjQsJEm76JP1poExdj9rRCFfHyuUVKgj5t2B2EBsmFvKivKzVpmKKZ4XiAVx65s3WZ8j";
+      configuration.currency = currencies.ltc;
+      configuration.currency.network = currencies.ltc.network_mainnet;
+    });
+
+    describe("derive Legacy addresses", () => {
+      beforeEach(() => {
+        derivationMode = DerivationMode.LEGACY;
+      });
+
+      it("derive m/0/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 0);
+        expect(address).toEqual("LQvJrXTHfAvUBGRs6LRTwC6nX7rYhzVbu9");
+      });
+
+      it("derive m/0/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 1);
+        expect(address).toEqual("LQFH5FQp2yi5NGspg8hGXeRJRzVYWAM2Ks");
+      });
+
+      it("derive m/1/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 0);
+        expect(address).toEqual("LYijJ7MzngZGGf5pQ1FBDLe23mjAM5dZWm");
+      });
+
+      it("derive m/1/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 1);
+        expect(address).toEqual("LTGro5xiqTsk7evvQmbAm4SqHq4X97pswZ");
+      });
+
+      it("derive m/1/10000000", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 10000000);
+        expect(address).toEqual("LUoTXPY5CfaXY3ZVMBbANX2erZK26bHsGP");
+      });
+    });
+
+    describe("derive SegWit addresses", () => {
+      beforeEach(() => {
+        derivationMode = DerivationMode.SEGWIT;
+      });
+
+      it("derive m/0/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 0);
+        expect(address).toEqual("MBz6dSyR1RkkUa7iEiKsXapEGEK6hxjWci");
+      });
+
+      it("derive m/0/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 1);
+        expect(address).toEqual("MMN88qfy1JmdCdmccXWeJCXJGAiVLgRTCY");
+      });
+
+      it("derive m/1/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 0);
+        expect(address).toEqual("MPxw2xaMUSTHjGQwqw51RMjrPpbK4cT86S");
+      });
+
+      it("derive m/1/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 1);
+        expect(address).toEqual("MN6dPnaRuMRtGj7WXjdJw2F37fhV8s6f9X");
+      });
+
+      it("derive m/1/10000000", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 10000000);
+        expect(address).toEqual("MULBsckG2JmuWqryuEqKLsCDC2dGxUdJaj");
+      });
+    });
+
+    describe("derive Native SegWit addresses", () => {
+      beforeEach(() => {
+        derivationMode = DerivationMode.NATIVE;
+      });
+
+      it("derive m/0/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 0);
+        expect(address).toEqual("ltc1q8ea8f4337su3ucfeaxq5pyyz3nttx6v3ehvg0l");
+      });
+
+      it("derive m/0/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 0, 1);
+        expect(address).toEqual("ltc1qxuvt7k66rqdy7m76ckaum9cwcq2tezyc400gg0");
+      });
+
+      it("derive m/1/0", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 0);
+        expect(address).toEqual("ltc1qjs9dlgqa6lyu8m2w08yt0u20vaahcms2uxtdn6");
+      });
+
+      it("derive m/1/1", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 1);
+        expect(address).toEqual("ltc1qtpxmpgrhfwyvl3rtrl2dxjq3fma54y06prjy5a");
+      });
+
+      it("derive m/1/10000000", () => {
+        const address = deriveAddress(derivationMode, xpub, 1, 10000000);
+        expect(address).toEqual("ltc1qdy85jq4h6qsyc5ljayxev226rxp9gkupt4h9gt");
+      });
+    });
+  });
+});

package/__tests__/helpers.test.ts

@@ -0,0 +1,274 @@
+import BigNumber from "bignumber.js";
+import { currencies } from "../src/configuration/currencies";
+import { configuration } from "../src/configuration/settings";
+import { retry, toAccountUnit, toBaseUnit } from "../src/helpers";
+import { flushPromises } from "./test-utils";
+
+describe("helpers", () => {
+  describe("convert from unit of account to base unit", () => {
+    describe("convert bitcoins to satoshis", () => {
+      beforeEach(() => {
+        configuration.currency = currencies.btc;
+      });
+
+      it("0.99999999 bitcoin ➝ 99999999 satoshis", () => {
+        const AmountInBaseUnit = new BigNumber(0.99999999);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("99999999");
+      });
+
+      it("1 bitcoin ➝ 100000000 satoshis", () => {
+        const AmountInBaseUnit = new BigNumber(1);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("100000000");
+      });
+
+      it("1.23456789 bitcoin ➝ 123456789 satoshis", () => {
+        const AmountInBaseUnit = new BigNumber(1.23456789);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("123456789");
+      });
+
+      it("123456789 bitcoins ➝ 12345678900000000 satoshis", () => {
+        const AmountInBaseUnit = new BigNumber(123456789);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("12345678900000000");
+      });
+    });
+
+    describe("convert litecoins to litoshi", () => {
+      beforeEach(() => {
+        configuration.currency = currencies.ltc;
+      });
+
+      it("0.99999999 litecoin ➝ 99999999 litoshis", () => {
+        const AmountInBaseUnit = new BigNumber(0.99999999);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("99999999");
+      });
+
+      it("1 litecoin ➝ 100000000 litoshis", () => {
+        const AmountInBaseUnit = new BigNumber(1);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("100000000");
+      });
+
+      it("1.23456789 litecoin ➝ 123456789 litoshis", () => {
+        const AmountInBaseUnit = new BigNumber(1.23456789);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("123456789");
+      });
+
+      it("123456789 litecoins ➝ 12345678900000000 litoshis", () => {
+        const AmountInBaseUnit = new BigNumber(123456789);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("12345678900000000");
+      });
+    });
+
+    describe("convert ethers to weis", () => {
+      beforeEach(() => {
+        configuration.currency = currencies.eth;
+      });
+
+      it("0.99999999 ether ➝ 999999990000000000 weis", () => {
+        const AmountInBaseUnit = new BigNumber(0.99999999);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("999999990000000000");
+      });
+
+      it("1 ether ➝ 1000000000000000000 weis", () => {
+        const AmountInBaseUnit = new BigNumber(1);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("1000000000000000000");
+      });
+
+      it("1.23456789 ether ➝ 1234567890000000000 weis", () => {
+        const AmountInBaseUnit = new BigNumber(1.23456789);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("1234567890000000000");
+      });
+
+      it("123456789 ethers ➝ 123456789000000000000000000 weis", () => {
+        const AmountInBaseUnit = new BigNumber(123456789);
+        const amountInAccountUnit = toBaseUnit(AmountInBaseUnit);
+        expect(amountInAccountUnit).toEqual("123456789000000000000000000");
+      });
+    });
+  });
+
+  describe("convert from base unit to unit of account", () => {
+    describe("convert satoshis to bitcoin", () => {
+      beforeEach(() => {
+        configuration.currency = currencies.btc;
+      });
+
+      it("1 satoshi ➝ 0.00000001 bitcoin", () => {
+        const amountInAccountUnit = new BigNumber(1);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.00000001");
+      });
+
+      it("10 satoshis ➝ 0.0000001 bitcoin", () => {
+        const amountInAccountUnit = new BigNumber(10);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.0000001");
+      });
+
+      it("9999999999 satoshis ➝ 99.99999999 bitcoins", () => {
+        const amountInAccountUnit = new BigNumber(9999999999);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("99.99999999");
+      });
+
+      it("10000000000 satoshis ➝ 100 bitcoins", () => {
+        const amountInAccountUnit = new BigNumber(10000000000);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("100");
+      });
+    });
+
+    describe("convert litoshis to litecoins", () => {
+      beforeEach(() => {
+        configuration.currency = currencies.ltc;
+      });
+
+      it("1 litoshi ➝ 0.00000001 litecoins", () => {
+        const amountInAccountUnit = new BigNumber(1);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.00000001");
+      });
+
+      it("10 litoshis ➝ 0.0000001 litecoins", () => {
+        const amountInAccountUnit = new BigNumber(10);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.0000001");
+      });
+
+      it("9999999999 litoshis ➝ 99.99999999 litecoins", () => {
+        const amountInAccountUnit = new BigNumber(9999999999);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("99.99999999");
+      });
+
+      it("10000000000 litoshis ➝ 100 litecoins", () => {
+        const amountInAccountUnit = new BigNumber(10000000000);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("100");
+      });
+    });
+
+    describe("convert weis to ethers", () => {
+      beforeEach(() => {
+        configuration.currency = currencies.eth;
+      });
+
+      it("1 wei ➝ 0.00000000 ether (because of the 10-digit precision)", () => {
+        const amountInAccountUnit = new BigNumber(1);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.0000000000");
+      });
+
+      it("100000000 weis ➝ 0.0000000001 ether", () => {
+        const amountInAccountUnit = new BigNumber(100000000);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.0000000001");
+      });
+
+      it("1000000000 weis ➝ 0.0000000010 ether", () => {
+        const amountInAccountUnit = new BigNumber(1000000000);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.0000000010");
+      });
+
+      it("9999999999 weis ➝ 0.0000000100 ether (round up)", () => {
+        const amountInAccountUnit = new BigNumber(9999999999);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("0.0000000100");
+      });
+
+      it("1000000000000000000 weis ➝ 1 ether", () => {
+        const amountInAccountUnit = new BigNumber(1000000000000000000);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("1.0000000000");
+      });
+
+      it("1000000000000000000000 weis ➝ 1000 ethers", () => {
+        const amountInAccountUnit = new BigNumber(1000000000000000000000);
+        const AmountInBaseUnit = toAccountUnit(amountInAccountUnit);
+        expect(AmountInBaseUnit).toEqual("1000.0000000000");
+      });
+    });
+  });
+
+  describe("retry", () => {
+    it("should try only 1 time if job is successful", async () => {
+      const job = jest.fn();
+      await retry(job);
+      expect(job).toHaveBeenCalledTimes(1);
+    });
+
+    it("should retry and succeed on the second time", async () => {
+      let nonce = 0;
+      const mock = {
+        job: async () => {
+          nonce++;
+          if (nonce === 2) return { result: "test" };
+          throw new Error("Job failed");
+        },
+      };
+      const spy = jest.spyOn(mock, "job");
+      const res = await retry(mock.job);
+      expect(spy).toHaveBeenCalledTimes(2);
+      expect(res).toEqual({ result: "test" });
+    });
+
+    it("should error after all retries has been consumed", async () => {
+      const retriesCount = 23;
+      const mock = {
+        job: async () => {
+          throw new Error("Job failed");
+        },
+      };
+      let err;
+      const spy = jest.spyOn(mock, "job");
+      try {
+        await retry(mock.job, { retries: retriesCount });
+      } catch (e) {
+        err = e;
+      }
+      expect(spy).toHaveBeenCalledTimes(retriesCount);
+      expect(err).toEqual(new Error("Job failed"));
+    });
+
+    it("should allow delaying each retry", async () => {
+      let nonce = 0;
+      const mock = {
+        job: async () => {
+          nonce++;
+          if (nonce === 3) return { result: "test" };
+          throw new Error("Job failed");
+        },
+      };
+      const spy = jest.spyOn(mock, "job");
+      jest.useFakeTimers({ legacyFakeTimers: true });
+      const promise = retry(mock.job, { retryDelayMS: 500 });
+
+      await flushPromises();
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(500);
+      await flushPromises();
+
+      expect(spy).toHaveBeenCalledTimes(2);
+
+      jest.advanceTimersByTime(500);
+      await flushPromises();
+
+      expect(spy).toHaveBeenCalledTimes(3);
+
+      const res = await promise;
+      expect(res).toEqual({ result: "test" });
+    });
+  });
+});

package/__tests__/test-utils.ts

@@ -0,0 +1,3 @@
+export function flushPromises() {
+  return new Promise((resolve) => setImmediate(resolve));
+}

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ["@babel/preset-env", { targets: { node: "current" } }],
+    "@babel/preset-typescript",
+  ],
+};

package/jest.config.ts

@@ -0,0 +1,5 @@
+export default {
+  testEnvironment: "node",
+  testMatch: ["**/__tests__/**/*.test.ts"],
+  moduleDirectories: ["node_modules"],
+};

package/lib/actions/checkAddress.d.ts

@@ -0,0 +1,29 @@
+interface Result {
+    partial?: string;
+    account?: number;
+    index?: number;
+}
+interface SearchRange {
+    account: {
+        min: number;
+        max: number;
+    };
+    index: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * identify whether an address provided by the user belongs or not to the xpub
+ * @param xpub the xpub from which the address may have been derived
+ * @param providedAddress the address provided by the user
+ * @param range the range of the search (i.e., accounts and indices ranges)
+ * @param searchType indication of the type of search (quick/deep)
+ * @returns a match or an empty object (i.e., non-match)
+ */
+declare function search(xpub: string, providedAddress: string, range: SearchRange, searchType: string): Result;
+declare function run(xpub: string, providedAddress: string): void;
+export declare const _private: {
+    search: typeof search;
+};
+export { run };