@tradetrust-tt/dnsprove 2.8.0

package/dist/records/dnsDid.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OpenAttestationDnsDidRecordT = exports.PublicKeyT = exports.VersionT = exports.AlgorithmT = exports.RecordTypesT = exports.validateDid = void 0;
+
+var _runtypes = require("runtypes");
+
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+// References https://www.w3.org/TR/did-core/#did-syntax
+const validateDid = maybeDid => {
+  const _maybeDid$split = maybeDid.split(":"),
+        _maybeDid$split2 = _toArray(_maybeDid$split),
+        did = _maybeDid$split2[0],
+        methodName = _maybeDid$split2[1],
+        methodSpecificIdParts = _maybeDid$split2.slice(2);
+
+  const methodSpecificId = methodSpecificIdParts.join(":");
+  if (did !== "did" || !methodName || !methodSpecificId || !/[a-z]+/.test(methodName)) return false;
+  return true;
+};
+
+exports.validateDid = validateDid;
+const RecordTypesT = (0, _runtypes.Literal)("openatts");
+exports.RecordTypesT = RecordTypesT;
+const AlgorithmT = (0, _runtypes.Union)((0, _runtypes.Literal)("dns-did"));
+exports.AlgorithmT = AlgorithmT;
+const VersionT = _runtypes.String;
+exports.VersionT = VersionT;
+
+const PublicKeyT = _runtypes.String.withConstraint(maybeDid => {
+  return validateDid(maybeDid) || `${maybeDid} is not a valid did`;
+});
+
+exports.PublicKeyT = PublicKeyT;
+const OpenAttestationDnsDidRecordT = (0, _runtypes.Record)({
+  type: RecordTypesT,
+  algorithm: AlgorithmT,
+  publicKey: PublicKeyT,
+  version: VersionT
+}).And((0, _runtypes.Partial)({
+  dnssec: _runtypes.Boolean
+}));
+exports.OpenAttestationDnsDidRecordT = OpenAttestationDnsDidRecordT;

package/dist/records/dnsTxt.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OpenAttestationDNSTextRecordT = exports.EthereumNetworkIdT = exports.EthereumNetworks = exports.EthereumAddressT = exports.BlockchainNetworkT = exports.RecordTypesT = void 0;
+
+var _runtypes = require("runtypes");
+
+const RecordTypesT = (0, _runtypes.Literal)("openatts");
+exports.RecordTypesT = RecordTypesT;
+const BlockchainNetworkT = (0, _runtypes.Literal)("ethereum");
+exports.BlockchainNetworkT = BlockchainNetworkT;
+
+const EthereumAddressT = _runtypes.String.withConstraint(maybeAddress => {
+  return /0x[a-fA-F0-9]{40}/.test(maybeAddress) || `${maybeAddress} is not a valid ethereum address`;
+});
+
+exports.EthereumAddressT = EthereumAddressT;
+let EthereumNetworks;
+exports.EthereumNetworks = EthereumNetworks;
+
+(function (EthereumNetworks) {
+  EthereumNetworks["homestead"] = "1";
+  EthereumNetworks["ropsten"] = "3";
+  EthereumNetworks["rinkeby"] = "4";
+  EthereumNetworks["goerli"] = "5";
+  EthereumNetworks["sepolia"] = "11155111";
+  EthereumNetworks["polygon"] = "137";
+  EthereumNetworks["polygonMumbai"] = "80001";
+  EthereumNetworks["local"] = "1337";
+  EthereumNetworks["xdc"] = "50";
+  EthereumNetworks["xdcapothem"] = "51";
+})(EthereumNetworks || (exports.EthereumNetworks = EthereumNetworks = {}));
+
+const EthereumNetworkIdT = (0, _runtypes.Union)((0, _runtypes.Literal)(EthereumNetworks.homestead), (0, _runtypes.Literal)(EthereumNetworks.ropsten), (0, _runtypes.Literal)(EthereumNetworks.rinkeby), (0, _runtypes.Literal)(EthereumNetworks.goerli), (0, _runtypes.Literal)(EthereumNetworks.sepolia), (0, _runtypes.Literal)(EthereumNetworks.polygon), (0, _runtypes.Literal)(EthereumNetworks.polygonMumbai), (0, _runtypes.Literal)(EthereumNetworks.xdc), (0, _runtypes.Literal)(EthereumNetworks.xdcapothem), (0, _runtypes.Literal)(EthereumNetworks.local));
+exports.EthereumNetworkIdT = EthereumNetworkIdT;
+const OpenAttestationDNSTextRecordT = (0, _runtypes.Record)({
+  type: RecordTypesT,
+  net: BlockchainNetworkT,
+  // key names are directly lifted from the dns-txt record format
+  netId: EthereumNetworkIdT,
+  // they are abbreviated because of 255 char constraint on dns-txt records
+  addr: EthereumAddressT
+}).And((0, _runtypes.Partial)({
+  dnssec: _runtypes.Boolean
+}));
+exports.OpenAttestationDNSTextRecordT = OpenAttestationDNSTextRecordT;

package/dist/ts/common/error.d.ts

@@ -0,0 +1,8 @@
+export declare enum DnsproveStatusCode {
+    IDNS_QUERY_ERROR_GENERAL = 0
+}
+export declare class CodedError extends Error {
+    code: number;
+    codeString: string;
+    constructor(message: string, code: DnsproveStatusCode, codeString: string);
+}

package/dist/ts/index.d.ts

@@ -0,0 +1,43 @@
+import { OpenAttestationDNSTextRecord } from "./records/dnsTxt";
+import { OpenAttestationDnsDidRecord } from "./records/dnsDid";
+export interface IDNSRecord {
+    name: string;
+    type: number;
+    TTL: number;
+    data: string;
+}
+export interface IDNSQueryResponse {
+    AD: boolean;
+    Answer: IDNSRecord[];
+}
+interface GenericObject {
+    [key: string]: string;
+}
+export declare type CustomDnsResolver = (domain: string) => Promise<IDNSQueryResponse>;
+export declare const defaultDnsResolvers: CustomDnsResolver[];
+export declare const queryDns: (domain: string, customDnsResolvers: CustomDnsResolver[]) => Promise<IDNSQueryResponse>;
+/**
+ * Parses one openattestation DNS-TXT record and turns it into an OpenAttestationsDNSTextRecord object
+ * @param record e.g: '"openatts net=ethereum netId=3 addr=0x0c9d5E6C766030cc6f0f49951D275Ad0701F81EC"'
+ */
+export declare const parseOpenAttestationRecord: (record: string) => GenericObject;
+/**
+ * Takes a DNS-TXT Record set and returns openattestation document store records if any
+ * @param recordSet Refer to tests for examples
+ */
+export declare const parseDocumentStoreResults: (recordSet: IDNSRecord[] | undefined, dnssec: boolean) => OpenAttestationDNSTextRecord[];
+export declare const parseDnsDidResults: (recordSet: IDNSRecord[] | undefined, dnssec: boolean) => OpenAttestationDnsDidRecord[];
+/**
+ * Queries a given domain and parses the results to retrieve openattestation document store records if any
+ * @param domain e.g: "example.openattestation.com"
+ * @example
+ * > getDocumentStoreRecords("example.openattestation.com")
+ * > [ { type: 'openatts',
+    net: 'ethereum',
+    netId: '3',
+    addr: '0x2f60375e8144e16Adf1979936301D8341D58C36C',
+    dnssec: true } ]
+ */
+export declare const getDocumentStoreRecords: (domain: string, customDnsResolvers?: CustomDnsResolver[] | undefined) => Promise<OpenAttestationDNSTextRecord[]>;
+export declare const getDnsDidRecords: (domain: string, customDnsResolvers?: CustomDnsResolver[] | undefined) => Promise<OpenAttestationDnsDidRecord[]>;
+export { OpenAttestationDNSTextRecord, OpenAttestationDnsDidRecord };

package/dist/ts/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ts/records/dnsDid.d.ts

@@ -0,0 +1,15 @@
+import { Static, Boolean, String, Literal, Record, Union, Partial } from "runtypes";
+export declare const validateDid: (maybeDid: string) => boolean;
+export declare const RecordTypesT: Literal<"openatts">;
+export declare const AlgorithmT: Union<[Literal<"dns-did">]>;
+export declare const VersionT: String;
+export declare const PublicKeyT: import("runtypes").Constraint<String, string, unknown>;
+export declare const OpenAttestationDnsDidRecordT: import("runtypes").Intersect<[Record<{
+    type: Literal<"openatts">;
+    algorithm: Union<[Literal<"dns-did">]>;
+    publicKey: import("runtypes").Constraint<String, string, unknown>;
+    version: String;
+}, false>, Partial<{
+    dnssec: Boolean;
+}, false>]>;
+export declare type OpenAttestationDnsDidRecord = Static<typeof OpenAttestationDnsDidRecordT>;

package/dist/ts/records/dnsDid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ts/records/dnsTxt.d.ts

@@ -0,0 +1,29 @@
+import { Static, Boolean, String, Literal, Record, Union, Partial } from "runtypes";
+export declare const RecordTypesT: Literal<"openatts">;
+export declare const BlockchainNetworkT: Literal<"ethereum">;
+export declare const EthereumAddressT: import("runtypes").Constraint<String, string, unknown>;
+export declare enum EthereumNetworks {
+    homestead = "1",
+    ropsten = "3",
+    rinkeby = "4",
+    goerli = "5",
+    sepolia = "11155111",
+    polygon = "137",
+    polygonMumbai = "80001",
+    local = "1337",
+    xdc = "50",
+    xdcapothem = "51"
+}
+export declare const EthereumNetworkIdT: Union<[Literal<EthereumNetworks.homestead>, Literal<EthereumNetworks.ropsten>, Literal<EthereumNetworks.rinkeby>, Literal<EthereumNetworks.goerli>, Literal<EthereumNetworks.sepolia>, Literal<EthereumNetworks.polygon>, Literal<EthereumNetworks.polygonMumbai>, Literal<EthereumNetworks.xdc>, Literal<EthereumNetworks.xdcapothem>, Literal<EthereumNetworks.local>]>;
+export declare const OpenAttestationDNSTextRecordT: import("runtypes").Intersect<[Record<{
+    type: Literal<"openatts">;
+    net: Literal<"ethereum">;
+    netId: Union<[Literal<EthereumNetworks.homestead>, Literal<EthereumNetworks.ropsten>, Literal<EthereumNetworks.rinkeby>, Literal<EthereumNetworks.goerli>, Literal<EthereumNetworks.sepolia>, Literal<EthereumNetworks.polygon>, Literal<EthereumNetworks.polygonMumbai>, Literal<EthereumNetworks.xdc>, Literal<EthereumNetworks.xdcapothem>, Literal<EthereumNetworks.local>]>;
+    addr: import("runtypes").Constraint<String, string, unknown>;
+}, false>, Partial<{
+    dnssec: Boolean;
+}, false>]>;
+export declare type BlockchainNetwork = Static<typeof BlockchainNetworkT>;
+export declare type EthereumAddress = Static<typeof EthereumAddressT>;
+export declare type OpenAttestationDNSTextRecord = Static<typeof OpenAttestationDNSTextRecordT>;
+export declare type RecordTypes = Static<typeof RecordTypesT>;

package/dist/ts/util/logger.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="debug" />
+export declare const trace: (namespace: string) => import("debug").Debugger;
+export declare const info: (namespace: string) => import("debug").Debugger;
+export declare const error: (namespace: string) => import("debug").Debugger;
+export declare const getLogger: (namespace: string) => {
+    trace: import("debug").Debugger;
+    info: import("debug").Debugger;
+    error: import("debug").Debugger;
+};

package/dist/util/logger.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLogger = exports.error = exports.info = exports.trace = void 0;
+
+var _debug = _interopRequireDefault(require("debug"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// not using .extends because of next.js resolve modules bug where its picking up old version of debug
+const trace = namespace => (0, _debug.default)(`dnsprove:trace:${namespace}`);
+
+exports.trace = trace;
+
+const info = namespace => (0, _debug.default)(`dnsprove:info:${namespace}`);
+
+exports.info = info;
+
+const error = namespace => (0, _debug.default)(`dnsprove:error:${namespace}`);
+
+exports.error = error;
+
+const getLogger = namespace => ({
+  trace: trace(namespace),
+  info: info(namespace),
+  error: error(namespace)
+});
+
+exports.getLogger = getLogger;

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@tradetrust-tt/dnsprove",
+  "version": "2.8.0",
+  "description": "Helper utility for retrieving OpenAttestations document store address records from DNS",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TradeTrust/dnsprove.git"
+  },
+  "main": "dist/index.js",
+  "author": {
+    "name": "RJ Chow",
+    "email": "me@rjchow.com",
+    "url": "https://github.com/rjchow"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "test": "jest",
+    "coverage": "npm test -- --coverage",
+    "postcoverage": "open-cli coverage/lcov-report/index.html",
+    "commit": "git-cz",
+    "commit:retry": "git-cz --retry",
+    "lint": "eslint . --ext js,ts,tsx",
+    "lint:fix": "npm run lint -- --fix",
+    "docs": "documentation readme src/index.ts --section=API --document-exported --babel=./.babelrc --parse-extension=ts",
+    "postdocs": "git add README.md",
+    "clean": "rimraf dist",
+    "prebuild": "npm run docs && npm run clean",
+    "build": "tsc --emitDeclarationOnly && babel src -d dist --ignore **/*.d.ts,src/**/*.spec.ts,src/**/*.test.ts -x .js,.ts,.tsx",
+    "preversion": "npm run lint && npm test && npm run build",
+    "semantic-release": "semantic-release"
+  },
+  "types": "dist/ts",
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{js,ts,tsx}": [
+      "eslint --fix --ext js,ts,tsx",
+      "git add"
+    ]
+  },
+  "keywords": [
+    "generator-nod"
+  ],
+  "dependencies": {
+    "axios": "^0.21.1",
+    "debug": "^4.3.1",
+    "runtypes": "^6.3.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.13.16",
+    "@babel/core": "^7.13.16",
+    "@babel/plugin-proposal-class-properties": "^7.13.0",
+    "@babel/preset-env": "^7.13.15",
+    "@babel/preset-typescript": "^7.13.0",
+    "@commitlint/cli": "^12.1.1",
+    "@commitlint/config-conventional": "^12.1.1",
+    "@commitlint/prompt": "^12.1.1",
+    "@ls-age/commitlint-circle": "^1.0.0",
+    "@types/axios": "^0.14.0",
+    "@types/debug": "^4.1.5",
+    "@types/jest": "^26.0.23",
+    "@typescript-eslint/eslint-plugin": "^4.22.0",
+    "@typescript-eslint/parser": "^4.22.0",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
+    "commitizen": "^4.2.3",
+    "documentation": "^13.2.5",
+    "eslint": "^7.25.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-prettier": "^3.4.0",
+    "git-cz": "^4.7.6",
+    "husky": "^6.0.0",
+    "jest": "^26.6.3",
+    "lint-staged": "^10.5.4",
+    "msw": "0.35.0",
+    "open-cli": "^6.0.1",
+    "prettier": "^2.2.1",
+    "rimraf": "^3.0.2",
+    "semantic-release": "^17.4.2",
+    "ts-jest": "^26.5.5",
+    "typescript": "^4.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "config": {
+    "commitizen": {
+      "path": "node_modules/@commitlint/prompt"
+    }
+  }
+}

package/src/common/error.ts

@@ -0,0 +1,14 @@
+export enum DnsproveStatusCode {
+  IDNS_QUERY_ERROR_GENERAL = 0,
+}
+export class CodedError extends Error {
+  code: number;
+
+  codeString: string;
+
+  constructor(message: string, code: DnsproveStatusCode, codeString: string) {
+    super(message);
+    this.code = code;
+    this.codeString = codeString;
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,257 @@
+import axios from "axios";
+import { setupServer, SetupServerApi } from "msw/node";
+import { rest } from "msw";
+import { CustomDnsResolver, getDocumentStoreRecords, queryDns, parseDocumentStoreResults, getDnsDidRecords } from ".";
+import { DnsproveStatusCode } from "./common/error";
+
+describe("getCertStoreRecords", () => {
+  const sampleDnsTextRecordWithDnssec = {
+    type: "openatts",
+    net: "ethereum",
+    netId: "3",
+    dnssec: true,
+    addr: "0x2f60375e8144e16Adf1979936301D8341D58C36C",
+  };
+  test("it should work", async () => {
+    const records = await getDocumentStoreRecords("donotuse.openattestation.com");
+    expect(records).toStrictEqual([sampleDnsTextRecordWithDnssec]);
+  });
+
+  test("it should return an empty array if there is no openatts record", async () => {
+    expect(await getDocumentStoreRecords("google.com")).toStrictEqual([]);
+  });
+
+  test("it should return an empty array with a non-existent domain", async () => {
+    expect(await getDocumentStoreRecords("thisdoesnotexist.gov.sg")).toStrictEqual([]);
+  });
+});
+
+describe("getDnsDidRecords", () => {
+  test("it should work", async () => {
+    const records = await getDnsDidRecords("donotuse.openattestation.com");
+    expect(records).toStrictEqual([
+      {
+        type: "openatts",
+        algorithm: "dns-did",
+        publicKey: "did:ethr:0xE712878f6E8d5d4F9e87E10DA604F9cB564C9a89#controller",
+        version: "1.0",
+        dnssec: true,
+      },
+    ]);
+  });
+
+  test("it should return an empty array if there is no openatts record", async () => {
+    const records = await getDnsDidRecords("google.com");
+    expect(records).toStrictEqual([]);
+  });
+
+  test("it should return an empty array with a non-existent domain", async () => {
+    const records = await getDnsDidRecords("thisdoesnotexist.gov.sg");
+    expect(records).toStrictEqual([]);
+  });
+});
+
+describe("parseDocumentStoreResults", () => {
+  test("it should return one record in an array if there is one openatts record", () => {
+    const sampleRecord = [
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf1979936301D8341D58C36C"',
+        dnssec: true,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, true)).toStrictEqual([
+      {
+        type: "openatts",
+        net: "ethereum",
+        netId: "3",
+        addr: "0x2f60375e8144e16Adf1979936301D8341D58C36C",
+        dnssec: true,
+      },
+    ]);
+  });
+  test("it should correctly handle cases where the TXT record is not double quoted", () => {
+    const sampleRecord = [
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: "openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf1979936301D8341D58C36C",
+        dnssec: true,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, true)).toStrictEqual([
+      {
+        type: "openatts",
+        net: "ethereum",
+        netId: "3",
+        addr: "0x2f60375e8144e16Adf1979936301D8341D58C36C",
+        dnssec: true,
+      },
+    ]);
+  });
+  test("it should return two record items if there are two openatts record", () => {
+    const sampleRecord = [
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf1979936301D8341D58C36C"',
+        dnssec: true,
+      },
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=1 addr=0x007d40224f6562461633ccfbaffd359ebb2fc9ba"',
+        dnssec: true,
+      },
+    ];
+
+    expect(parseDocumentStoreResults(sampleRecord, true)).toStrictEqual([
+      {
+        addr: "0x2f60375e8144e16Adf1979936301D8341D58C36C",
+        net: "ethereum",
+        netId: "3",
+        type: "openatts",
+        dnssec: true,
+      },
+      {
+        addr: "0x007d40224f6562461633ccfbaffd359ebb2fc9ba",
+        net: "ethereum",
+        netId: "1",
+        type: "openatts",
+        dnssec: true,
+      },
+    ]);
+  });
+  test("it should omit malformed records even if it has openatts header", () => {
+    const sampleRecord = [
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts foobarbar"',
+        dnssec: true,
+      },
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=1 addr=0x007d40224f6562461633ccfbaffd359ebb2fc9ba"',
+        dnssec: true,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, true)).toStrictEqual([
+      {
+        addr: "0x007d40224f6562461633ccfbaffd359ebb2fc9ba",
+        net: "ethereum",
+        netId: "1",
+        type: "openatts",
+        dnssec: true,
+      },
+    ]);
+  });
+  test("should not return a record if addr fails ethereum regex", () => {
+    const sampleRecord = [
+      {
+        name: "example.openattestation.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf19=79936301D8341D58C36C"',
+        dnssec: true,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, true)).toStrictEqual([]);
+  });
+});
+
+describe("queryDns", () => {
+  let server: SetupServerApi;
+
+  const sampleResponse = {
+    AD: false,
+    Answer: [
+      {
+        name: "google.com",
+        type: 16,
+        TTL: 3529,
+        data: '"docusign=1b0a6754-49b1-4db5-8540-d2c12664b289"',
+      },
+    ],
+  };
+
+  const testDnsResolvers: CustomDnsResolver[] = [
+    async (domain) => {
+      const { data } = await axios({
+        method: "GET",
+        url: `https://dns.google/resolve?name=${domain}&type=TXT`,
+      });
+
+      return data;
+    },
+    async (domain) => {
+      const { data } = await axios({
+        method: "GET",
+        url: `https://cloudflare-dns.com/dns-query?name=${domain}&type=TXT`,
+        headers: { accept: "application/dns-json", contentType: "application/json", connection: "keep-alive" },
+      });
+      return data;
+    },
+  ];
+
+  afterEach(() => {
+    server.close();
+  });
+
+  test("Should work for first dns if first dns is not down", async () => {
+    const handlers = [
+      rest.get("https://dns.google/resolve", (_, res, ctx) => {
+        return res(ctx.json(sampleResponse));
+      }),
+    ];
+
+    server = setupServer(...handlers);
+    server.listen();
+
+    const records = await queryDns("https://google.com", testDnsResolvers);
+    expect(sampleResponse).toStrictEqual(records);
+  });
+
+  test("Should fallback to second dns when first dns is down", async () => {
+    const handlers = [
+      rest.get("https://dns.google/resolve", (_, res, ctx) => {
+        return res(ctx.status(500));
+      }),
+      rest.get("https://cloudflare-dns.com/dns-query", (_, res, ctx) => {
+        return res(ctx.json(sampleResponse));
+      }),
+    ];
+    server = setupServer(...handlers);
+    server.listen();
+
+    const records = await queryDns("https://google.com", testDnsResolvers);
+
+    expect(sampleResponse).toStrictEqual(records);
+  });
+
+  test("Should throw error when all dns provided are down", async () => {
+    const handlers = [
+      rest.get("https://dns.google/resolve", (_, res, ctx) => {
+        return res(ctx.status(500));
+      }),
+      rest.get("https://cloudflare-dns.com/dns-query", (_, res, ctx) => {
+        return res(ctx.status(500));
+      }),
+    ];
+    server = setupServer(...handlers);
+    server.listen();
+    try {
+      await queryDns("https://google.com", testDnsResolvers);
+    } catch (e: any) {
+      expect(e.code).toStrictEqual(DnsproveStatusCode.IDNS_QUERY_ERROR_GENERAL);
+    }
+  });
+});