@waku/discovery 0.0.2-434be7b.0

package/dist/peer-exchange/waku_peer_exchange_discovery.d.ts

@@ -0,0 +1,53 @@
+import { TypedEventEmitter } from "@libp2p/interface";
+import { peerDiscoverySymbol as symbol } from "@libp2p/interface";
+import type { PeerDiscovery, PeerDiscoveryEvents } from "@libp2p/interface";
+import { Libp2pComponents, PubsubTopic, Tags } from "@waku/interfaces";
+export interface Options {
+    /**
+     * Tag a bootstrap peer with this name before "discovering" it (default: 'bootstrap')
+     */
+    tagName?: string;
+    /**
+     * The bootstrap peer tag will have this value (default: 50)
+     */
+    tagValue?: number;
+    /**
+     * Cause the bootstrap peer tag to be removed after this number of ms (default: 2 minutes)
+     */
+    tagTTL?: number;
+    /**
+     * The interval between queries to a peer (default: 10 seconds)
+     * The interval will increase by a factor of an incrementing number (starting at 1)
+     * until it reaches the maximum attempts before backoff
+     */
+    queryInterval?: number;
+    /**
+     * The number of attempts before the queries to a peer are aborted (default: 3)
+     */
+    maxRetries?: number;
+}
+export declare const DEFAULT_PEER_EXCHANGE_TAG_NAME = Tags.PEER_EXCHANGE;
+export declare class PeerExchangeDiscovery extends TypedEventEmitter<PeerDiscoveryEvents> implements PeerDiscovery {
+    private readonly components;
+    private readonly peerExchange;
+    private readonly options;
+    private isStarted;
+    private queryingPeers;
+    private queryAttempts;
+    private readonly handleDiscoveredPeer;
+    constructor(components: Libp2pComponents, pubsubTopics: PubsubTopic[], options?: Options);
+    /**
+     * Start emitting events
+     */
+    start(): void;
+    /**
+     * Remove event listener
+     */
+    stop(): void;
+    get [symbol](): true;
+    get [Symbol.toStringTag](): string;
+    private readonly startRecurringQueries;
+    private query;
+    private abortQueriesForPeer;
+}
+export declare function wakuPeerExchangeDiscovery(pubsubTopics: PubsubTopic[]): (components: Libp2pComponents) => PeerExchangeDiscovery;

package/dist/peer-exchange/waku_peer_exchange_discovery.js

@@ -0,0 +1,136 @@
+import { CustomEvent, TypedEventEmitter } from "@libp2p/interface";
+import { peerDiscoverySymbol as symbol } from "@libp2p/interface";
+import { Tags } from "@waku/interfaces";
+import { encodeRelayShard, Logger } from "@waku/utils";
+import { PeerExchangeCodec, WakuPeerExchange } from "./waku_peer_exchange.js";
+const log = new Logger("peer-exchange-discovery");
+const DEFAULT_PEER_EXCHANGE_REQUEST_NODES = 10;
+const DEFAULT_PEER_EXCHANGE_QUERY_INTERVAL_MS = 10 * 1000;
+const DEFAULT_MAX_RETRIES = 3;
+export const DEFAULT_PEER_EXCHANGE_TAG_NAME = Tags.PEER_EXCHANGE;
+const DEFAULT_PEER_EXCHANGE_TAG_VALUE = 50;
+const DEFAULT_PEER_EXCHANGE_TAG_TTL = 100000000;
+export class PeerExchangeDiscovery extends TypedEventEmitter {
+    components;
+    peerExchange;
+    options;
+    isStarted;
+    queryingPeers = new Set();
+    queryAttempts = new Map();
+    handleDiscoveredPeer = (event) => {
+        const { protocols, peerId } = event.detail;
+        if (!protocols.includes(PeerExchangeCodec) ||
+            this.queryingPeers.has(peerId.toString()))
+            return;
+        this.queryingPeers.add(peerId.toString());
+        this.startRecurringQueries(peerId).catch((error) => log.error(`Error querying peer ${error}`));
+    };
+    constructor(components, pubsubTopics, options = {}) {
+        super();
+        this.components = components;
+        this.peerExchange = new WakuPeerExchange(components, pubsubTopics);
+        this.options = options;
+        this.isStarted = false;
+    }
+    /**
+     * Start emitting events
+     */
+    start() {
+        if (this.isStarted) {
+            return;
+        }
+        log.info("Starting peer exchange node discovery, discovering peers");
+        // might be better to use "peer:identify" or "peer:update"
+        this.components.events.addEventListener("peer:identify", this.handleDiscoveredPeer);
+    }
+    /**
+     * Remove event listener
+     */
+    stop() {
+        if (!this.isStarted)
+            return;
+        log.info("Stopping peer exchange node discovery");
+        this.isStarted = false;
+        this.queryingPeers.clear();
+        this.components.events.removeEventListener("peer:identify", this.handleDiscoveredPeer);
+    }
+    get [symbol]() {
+        return true;
+    }
+    get [Symbol.toStringTag]() {
+        return "@waku/peer-exchange";
+    }
+    startRecurringQueries = async (peerId) => {
+        const peerIdStr = peerId.toString();
+        const { queryInterval = DEFAULT_PEER_EXCHANGE_QUERY_INTERVAL_MS, maxRetries = DEFAULT_MAX_RETRIES } = this.options;
+        log.info(`Querying peer: ${peerIdStr} (attempt ${this.queryAttempts.get(peerIdStr) ?? 1})`);
+        await this.query(peerId);
+        const currentAttempt = this.queryAttempts.get(peerIdStr) ?? 1;
+        if (currentAttempt > maxRetries) {
+            this.abortQueriesForPeer(peerIdStr);
+            return;
+        }
+        setTimeout(() => {
+            this.queryAttempts.set(peerIdStr, currentAttempt + 1);
+            this.startRecurringQueries(peerId).catch((error) => {
+                log.error(`Error in startRecurringQueries: ${error}`);
+            });
+        }, queryInterval * currentAttempt);
+    };
+    async query(peerId) {
+        const { error, peerInfos } = await this.peerExchange.query({
+            numPeers: DEFAULT_PEER_EXCHANGE_REQUEST_NODES,
+            peerId
+        });
+        if (error) {
+            log.error("Peer exchange query failed", error);
+            return { error, peerInfos: null };
+        }
+        for (const _peerInfo of peerInfos) {
+            const { ENR } = _peerInfo;
+            if (!ENR) {
+                log.warn("No ENR in peerInfo object, skipping");
+                continue;
+            }
+            const { peerId, peerInfo, shardInfo } = ENR;
+            if (!peerId || !peerInfo) {
+                continue;
+            }
+            const hasPeer = await this.components.peerStore.has(peerId);
+            if (hasPeer) {
+                continue;
+            }
+            // update the tags for the peer
+            await this.components.peerStore.save(peerId, {
+                tags: {
+                    [DEFAULT_PEER_EXCHANGE_TAG_NAME]: {
+                        value: this.options.tagValue ?? DEFAULT_PEER_EXCHANGE_TAG_VALUE,
+                        ttl: this.options.tagTTL ?? DEFAULT_PEER_EXCHANGE_TAG_TTL
+                    }
+                },
+                ...(shardInfo && {
+                    metadata: {
+                        shardInfo: encodeRelayShard(shardInfo)
+                    }
+                })
+            });
+            log.info(`Discovered peer: ${peerId.toString()}`);
+            this.dispatchEvent(new CustomEvent("peer", {
+                detail: {
+                    id: peerId,
+                    multiaddrs: peerInfo.multiaddrs
+                }
+            }));
+        }
+        return { error: null, peerInfos };
+    }
+    abortQueriesForPeer(peerIdStr) {
+        log.info(`Aborting queries for peer: ${peerIdStr}`);
+        this.queryingPeers.delete(peerIdStr);
+        this.queryAttempts.delete(peerIdStr);
+    }
+}
+export function wakuPeerExchangeDiscovery(pubsubTopics) {
+    return (components) => new PeerExchangeDiscovery(components, pubsubTopics);
+}
+//# sourceMappingURL=waku_peer_exchange_discovery.js.map

package/dist/peer-exchange/waku_peer_exchange_discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waku_peer_exchange_discovery.js","sourceRoot":"","sources":["../../src/peer-exchange/waku_peer_exchange_discovery.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1 @@
+{"name":"@waku/discovery","version":"0.0.2-434be7b.0","description":"Contains various discovery mechanisms: DNS Discovery (EIP-1459, Peer Exchange, Local Peer Cache Discovery.","types":"./dist/index.d.ts","module":"./dist/index.js","react-native":"./dist/index.js","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js","react-native":"./dist/index.js"}},"type":"module","author":"Waku Team","homepage":"https://github.com/waku-org/js-waku/tree/master/packages/discovery#readme","repository":{"type":"git","url":"https://github.com/waku-org/js-waku.git"},"bugs":{"url":"https://github.com/waku-org/js-waku/issues"},"license":"MIT OR Apache-2.0","keywords":["waku","decentralized","secure","communication","web3","ethereum","dapps","privacy"],"scripts":{"build":"run-s build:**","build:esm":"tsc","build:bundle":"rollup --config rollup.config.js","fix":"run-s fix:*","fix:lint":"eslint src *.js --fix","check":"run-s check:*","check:lint":"eslint src --ext .ts","check:spelling":"cspell \"{README.md,src/**/*.ts}\"","check:tsc":"tsc -p tsconfig.dev.json","prepublish":"npm run build","reset-hard":"git clean -dfx -e .idea && git reset --hard && npm i && npm run build","test":"NODE_ENV=test run-s test:*","test:node":"NODE_ENV=test TS_NODE_PROJECT=./tsconfig.dev.json mocha","test:browser":"NODE_ENV=test karma start karma.conf.cjs"},"engines":{"node":">=18"},"dependencies":{"@waku/interfaces":"0.0.23-434be7b.0","@waku/proto":"0.0.7-434be7b.0","@waku/enr":"0.0.22-434be7b.0","@waku/utils":"0.0.16-434be7b.0","debug":"^4.3.4","dns-query":"^0.11.2","hi-base32":"^0.5.1","uint8arrays":"^5.0.1"},"devDependencies":{"@libp2p/peer-id":"^4.0.4","@libp2p/peer-id-factory":"^4.0.5","@multiformats/multiaddr":"^12.0.0","@rollup/plugin-commonjs":"^25.0.7","@rollup/plugin-json":"^6.0.0","@rollup/plugin-node-resolve":"^15.2.3","@types/chai":"^4.3.11","@types/node-localstorage":"^1.3.3","@waku/build-utils":"*","chai":"^4.3.10","chai-as-promised":"^7.1.1","cspell":"^8.3.2","mocha":"^10.3.0","node-localstorage":"^3.0.5","npm-run-all":"^4.1.5","rollup":"^4.12.0","sinon":"^17.0.1"},"peerDependencies":{"@waku/core":"0.0.28-434be7b.0","@waku/enr":"0.0.22-434be7b.0","@waku/interfaces":"0.0.23-434be7b.0","@waku/proto":"0.0.7-434be7b.0","@waku/utils":"0.0.16-434be7b.0","@libp2p/interface":"^1.1.2"},"peerDependenciesMeta":{"@waku/interfaces":{"optional":true},"@libp2p/interface":{"optional":true}},"files":["dist","bundle","src/**/*.ts","!**/*.spec.*","!**/*.json","CHANGELOG.md","LICENSE","README.md"]}

package/src/dns/constants.ts

@@ -0,0 +1,16 @@
+import type { NodeCapabilityCount } from "@waku/interfaces";
+
+export const enrTree = {
+  TEST: "enrtree://AO47IDOLBKH72HIZZOXQP6NMRESAN7CHYWIBNXDXWRJRZWLODKII6@test.wakuv2.nodes.status.im",
+  PROD: "enrtree://ANEDLO25QVUGJOUTQFRYKWX6P4Z4GKVESBMHML7DZ6YK4LGS5FC5O@prod.wakuv2.nodes.status.im"
+};
+
+export const DEFAULT_BOOTSTRAP_TAG_NAME = "bootstrap";
+export const DEFAULT_BOOTSTRAP_TAG_VALUE = 50;
+export const DEFAULT_BOOTSTRAP_TAG_TTL = 100_000_000;
+
+export const DEFAULT_NODE_REQUIREMENTS: Partial<NodeCapabilityCount> = {
+  store: 2,
+  filter: 1,
+  lightPush: 1
+};

package/src/dns/dns.ts

@@ -0,0 +1,215 @@
+import { ENR, EnrDecoder } from "@waku/enr";
+import type {
+  DnsClient,
+  IEnr,
+  NodeCapabilityCount,
+  SearchContext
+} from "@waku/interfaces";
+import { Logger } from "@waku/utils";
+
+import { DnsOverHttps } from "./dns_over_https.js";
+import { ENRTree } from "./enrtree.js";
+import {
+  fetchNodesUntilCapabilitiesFulfilled,
+  yieldNodesUntilCapabilitiesFulfilled
+} from "./fetch_nodes.js";
+
+const log = new Logger("discovery:dns");
+
+export class DnsNodeDiscovery {
+  private readonly dns: DnsClient;
+  private readonly _DNSTreeCache: { [key: string]: string };
+  private readonly _errorTolerance: number = 10;
+
+  public static async dnsOverHttp(
+    dnsClient?: DnsClient
+  ): Promise<DnsNodeDiscovery> {
+    if (!dnsClient) {
+      dnsClient = await DnsOverHttps.create();
+    }
+    return new DnsNodeDiscovery(dnsClient);
+  }
+
+  /**
+   * Returns a list of verified peers listed in an EIP-1459 DNS tree. Method may
+   * return fewer peers than requested if @link wantedNodeCapabilityCount requires
+   * larger quantity of peers than available or the number of errors/duplicate
+   * peers encountered by randomized search exceeds the sum of the fields of
+   * @link wantedNodeCapabilityCount plus the @link _errorTolerance factor.
+   */
+  async getPeers(
+    enrTreeUrls: string[],
+    wantedNodeCapabilityCount: Partial<NodeCapabilityCount>
+  ): Promise<IEnr[]> {
+    const networkIndex = Math.floor(Math.random() * enrTreeUrls.length);
+    const { publicKey, domain } = ENRTree.parseTree(enrTreeUrls[networkIndex]);
+    const context: SearchContext = {
+      domain,
+      publicKey,
+      visits: {}
+    };
+
+    const peers = await fetchNodesUntilCapabilitiesFulfilled(
+      wantedNodeCapabilityCount,
+      this._errorTolerance,
+      () => this._search(domain, context)
+    );
+    log.info(
+      "retrieved peers: ",
+      peers.map((peer) => {
+        return {
+          id: peer.peerId?.toString(),
+          multiaddrs: peer.multiaddrs?.map((ma) => ma.toString())
+        };
+      })
+    );
+    return peers;
+  }
+
+  public constructor(dns: DnsClient) {
+    this._DNSTreeCache = {};
+    this.dns = dns;
+  }
+
+  /**
+   * {@inheritDoc getPeers}
+   */
+  async *getNextPeer(
+    enrTreeUrls: string[],
+    wantedNodeCapabilityCount: Partial<NodeCapabilityCount>
+  ): AsyncGenerator<IEnr> {
+    const networkIndex = Math.floor(Math.random() * enrTreeUrls.length);
+    const { publicKey, domain } = ENRTree.parseTree(enrTreeUrls[networkIndex]);
+    const context: SearchContext = {
+      domain,
+      publicKey,
+      visits: {}
+    };
+
+    for await (const peer of yieldNodesUntilCapabilitiesFulfilled(
+      wantedNodeCapabilityCount,
+      this._errorTolerance,
+      () => this._search(domain, context)
+    )) {
+      yield peer;
+    }
+  }
+
+  /**
+   * Runs a recursive, randomized descent of the DNS tree to retrieve a single
+   * ENR record as an ENR. Returns null if parsing or DNS resolution fails.
+   */
+  private async _search(
+    subdomain: string,
+    context: SearchContext
+  ): Promise<ENR | null> {
+    try {
+      const entry = await this._getTXTRecord(subdomain, context);
+      context.visits[subdomain] = true;
+
+      let next: string;
+      let branches: string[];
+
+      const entryType = getEntryType(entry);
+      try {
+        switch (entryType) {
+          case ENRTree.ROOT_PREFIX:
+            next = ENRTree.parseAndVerifyRoot(entry, context.publicKey);
+            return await this._search(next, context);
+          case ENRTree.BRANCH_PREFIX:
+            branches = ENRTree.parseBranch(entry);
+            next = selectRandomPath(branches, context);
+            return await this._search(next, context);
+          case ENRTree.RECORD_PREFIX:
+            return EnrDecoder.fromString(entry);
+          default:
+            return null;
+        }
+      } catch (error) {
+        log.error(
+          `Failed to search DNS tree ${entryType} at subdomain ${subdomain}: ${error}`
+        );
+        return null;
+      }
+    } catch (error) {
+      log.error(
+        `Failed to retrieve TXT record at subdomain ${subdomain}: ${error}`
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Retrieves the TXT record stored at a location from either
+   * this DNS tree cache or via DNS query.
+   *
+   * @throws if the TXT Record contains non-UTF-8 values.
+   */
+  private async _getTXTRecord(
+    subdomain: string,
+    context: SearchContext
+  ): Promise<string> {
+    if (this._DNSTreeCache[subdomain]) {
+      return this._DNSTreeCache[subdomain];
+    }
+
+    // Location is either the top level tree entry host or a subdomain of it.
+    const location =
+      subdomain !== context.domain
+        ? `${subdomain}.${context.domain}`
+        : context.domain;
+
+    const response = await this.dns.resolveTXT(location);
+
+    if (!response.length)
+      throw new Error("Received empty result array while fetching TXT record");
+    if (!response[0].length) throw new Error("Received empty TXT record");
+
+    // Branch entries can be an array of strings of comma delimited subdomains, with
+    // some subdomain strings split across the array elements
+    const result = response.join("");
+
+    this._DNSTreeCache[subdomain] = result;
+    return result;
+  }
+}
+
+function getEntryType(entry: string): string {
+  if (entry.startsWith(ENRTree.ROOT_PREFIX)) return ENRTree.ROOT_PREFIX;
+  if (entry.startsWith(ENRTree.BRANCH_PREFIX)) return ENRTree.BRANCH_PREFIX;
+  if (entry.startsWith(ENRTree.RECORD_PREFIX)) return ENRTree.RECORD_PREFIX;
+
+  return "";
+}
+
+/**
+ * Returns a randomly selected subdomain string from the list provided by a branch
+ * entry record.
+ *
+ * The client must track subdomains which are already resolved to avoid
+ * going into an infinite loop b/c branch entries can contain
+ * circular references. It’s in the client’s best interest to traverse the
+ * tree in random order.
+ */
+function selectRandomPath(branches: string[], context: SearchContext): string {
+  // Identify domains already visited in this traversal of the DNS tree.
+  // Then filter against them to prevent cycles.
+  const circularRefs: { [key: number]: boolean } = {};
+  for (const [idx, subdomain] of branches.entries()) {
+    if (context.visits[subdomain]) {
+      circularRefs[idx] = true;
+    }
+  }
+  // If all possible paths are circular...
+  if (Object.keys(circularRefs).length === branches.length) {
+    throw new Error("Unresolvable circular path detected");
+  }
+
+  // Randomly select a viable path
+  let index;
+  do {
+    index = Math.floor(Math.random() * branches.length);
+  } while (circularRefs[index]);
+
+  return branches[index];
+}

package/src/dns/dns_discovery.ts

@@ -0,0 +1,144 @@
+import {
+  CustomEvent,
+  PeerDiscovery,
+  PeerDiscoveryEvents,
+  TypedEventEmitter
+} from "@libp2p/interface";
+import { peerDiscoverySymbol as symbol } from "@libp2p/interface";
+import type { PeerInfo } from "@libp2p/interface";
+import type {
+  DnsDiscOptions,
+  DnsDiscoveryComponents,
+  IEnr,
+  NodeCapabilityCount
+} from "@waku/interfaces";
+import { encodeRelayShard, Logger } from "@waku/utils";
+
+import {
+  DEFAULT_BOOTSTRAP_TAG_NAME,
+  DEFAULT_BOOTSTRAP_TAG_TTL,
+  DEFAULT_BOOTSTRAP_TAG_VALUE,
+  DEFAULT_NODE_REQUIREMENTS
+} from "./constants.js";
+import { DnsNodeDiscovery } from "./dns.js";
+
+const log = new Logger("peer-discovery-dns");
+
+/**
+ * Parse options and expose function to return bootstrap peer addresses.
+ */
+export class PeerDiscoveryDns
+  extends TypedEventEmitter<PeerDiscoveryEvents>
+  implements PeerDiscovery
+{
+  private nextPeer: (() => AsyncGenerator<IEnr>) | undefined;
+  private _started: boolean;
+  private _components: DnsDiscoveryComponents;
+  private _options: DnsDiscOptions;
+
+  constructor(components: DnsDiscoveryComponents, options: DnsDiscOptions) {
+    super();
+    this._started = false;
+    this._components = components;
+    this._options = options;
+
+    const { enrUrls } = options;
+    log.info("Use following EIP-1459 ENR Tree URLs: ", enrUrls);
+  }
+
+  /**
+   * Start discovery process
+   */
+  async start(): Promise<void> {
+    log.info("Starting peer discovery via dns");
+
+    this._started = true;
+
+    if (this.nextPeer === undefined) {
+      let { enrUrls } = this._options;
+      if (!Array.isArray(enrUrls)) enrUrls = [enrUrls];
+
+      const { wantedNodeCapabilityCount } = this._options;
+      const dns = await DnsNodeDiscovery.dnsOverHttp();
+
+      this.nextPeer = dns.getNextPeer.bind(
+        dns,
+        enrUrls,
+        wantedNodeCapabilityCount
+      );
+    }
+
+    for await (const peerEnr of this.nextPeer()) {
+      if (!this._started) {
+        return;
+      }
+
+      const { peerInfo, shardInfo } = peerEnr;
+
+      if (!peerInfo) {
+        continue;
+      }
+
+      const tagsToUpdate = {
+        [DEFAULT_BOOTSTRAP_TAG_NAME]: {
+          value: this._options.tagValue ?? DEFAULT_BOOTSTRAP_TAG_VALUE,
+          ttl: this._options.tagTTL ?? DEFAULT_BOOTSTRAP_TAG_TTL
+        }
+      };
+
+      let isPeerChanged = false;
+      const isPeerExists = await this._components.peerStore.has(peerInfo.id);
+
+      if (isPeerExists) {
+        const peer = await this._components.peerStore.get(peerInfo.id);
+        const hasBootstrapTag = peer.tags.has(DEFAULT_BOOTSTRAP_TAG_NAME);
+
+        if (!hasBootstrapTag) {
+          isPeerChanged = true;
+          await this._components.peerStore.merge(peerInfo.id, {
+            tags: tagsToUpdate
+          });
+        }
+      } else {
+        isPeerChanged = true;
+        await this._components.peerStore.save(peerInfo.id, {
+          tags: tagsToUpdate,
+          ...(shardInfo && {
+            metadata: {
+              shardInfo: encodeRelayShard(shardInfo)
+            }
+          })
+        });
+      }
+
+      if (isPeerChanged) {
+        this.dispatchEvent(
+          new CustomEvent<PeerInfo>("peer", { detail: peerInfo })
+        );
+      }
+    }
+  }
+
+  /**
+   * Stop emitting events
+   */
+  stop(): void {
+    this._started = false;
+  }
+
+  get [symbol](): true {
+    return true;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return "@waku/bootstrap";
+  }
+}
+
+export function wakuDnsDiscovery(
+  enrUrls: string[],
+  wantedNodeCapabilityCount: Partial<NodeCapabilityCount> = DEFAULT_NODE_REQUIREMENTS
+): (components: DnsDiscoveryComponents) => PeerDiscoveryDns {
+  return (components: DnsDiscoveryComponents) =>
+    new PeerDiscoveryDns(components, { enrUrls, wantedNodeCapabilityCount });
+}

package/src/dns/dns_over_https.ts

@@ -0,0 +1,83 @@
+import type { DnsClient } from "@waku/interfaces";
+import { Logger } from "@waku/utils";
+import { bytesToUtf8 } from "@waku/utils/bytes";
+import { Endpoint, query, wellknown } from "dns-query";
+
+const log = new Logger("dns-over-https");
+
+export class DnsOverHttps implements DnsClient {
+  /**
+   * Create new Dns-Over-Http DNS client.
+   *
+   * @param endpoints The endpoints for Dns-Over-Https queries;
+   * Defaults to using dns-query's API..
+   * @param retries Retries if a given endpoint fails.
+   *
+   * @throws {code: string} If DNS query fails.
+   */
+  public static async create(
+    endpoints?: Endpoint[],
+    retries?: number
+  ): Promise<DnsOverHttps> {
+    const _endpoints = endpoints ?? (await wellknown.endpoints("doh"));
+
+    return new DnsOverHttps(_endpoints, retries);
+  }
+
+  private constructor(
+    private endpoints: Endpoint[],
+    private retries: number = 3
+  ) {}
+
+  /**
+   * Resolves a TXT record
+   *
+   * @param domain The domain name
+   *
+   * @throws if the query fails
+   */
+  async resolveTXT(domain: string): Promise<string[]> {
+    let answers;
+    try {
+      const res = await query(
+        {
+          question: { type: "TXT", name: domain }
+        },
+        {
+          endpoints: this.endpoints,
+          retries: this.retries
+        }
+      );
+      answers = res.answers;
+    } catch (error) {
+      log.error("query failed: ", error);
+      throw new Error("DNS query failed");
+    }
+
+    if (!answers) throw new Error(`Could not resolve ${domain}`);
+
+    const data = answers.map((a) => a.data) as
+      | Array<string | Uint8Array>
+      | Array<Array<string | Uint8Array>>;
+
+    const result: string[] = [];
+
+    data.forEach((d) => {
+      if (typeof d === "string") {
+        result.push(d);
+      } else if (Array.isArray(d)) {
+        d.forEach((sd) => {
+          if (typeof sd === "string") {
+            result.push(sd);
+          } else {
+            result.push(bytesToUtf8(sd));
+          }
+        });
+      } else {
+        result.push(bytesToUtf8(d));
+      }
+    });
+
+    return result;
+  }
+}