@tradetrust-tt/dnsprove 2.18.0 → 2.20.0

package/README.md

@@ -111,7 +111,7 @@ Takes a DNS-TXT Record set and returns openattestation document store records if
 #### Parameters
 
 *   `recordSet` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[IDNSRecord](#idnsrecord)>** Refer to tests for examples (optional, default `[]`)
-*   `dnssec` **[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)**&#x20;
+*   `dnssec` **[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Resolver AD (authenticated data) flag; applied as each record's `dnssec` field
 
 Returns **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[OpenAttestationDNSTextRecord](#openattestationdnstextrecord)>**&#x20;
 
@@ -131,7 +131,7 @@ Queries a given domain and parses the results to retrieve openattestation docume
 #### Parameters
 
 *   `domain` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** e.g: "example.openattestation.com"
-*   `customDnsResolvers` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[CustomDnsResolver](#customdnsresolver)>?**&#x20;
+*   `customDnsResolvers` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[CustomDnsResolver](#customdnsresolver)>?** Optional resolver list; built-in HTTP DNS chain is used when omitted
 
 #### Examples
 

package/dist/index.js

@@ -3,6 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  defaultDnsResolvers: true,
+  queryDns: true,
+  parseOpenAttestationRecord: true,
+  parseDocumentStoreResults: true,
+  parseDnsDidResults: true,
+  getDocumentStoreRecords: true,
+  getDnsDidRecords: true,
+  OpenAttestationDNSTextRecord: true,
+  OpenAttestationDnsDidRecord: true
+};
 Object.defineProperty(exports, "OpenAttestationDNSTextRecord", {
   enumerable: true,
   get: function get() {
@@ -20,47 +31,34 @@ var _dnsTxt = require("./records/dnsTxt");
 var _dnsDid = require("./records/dnsDid");
 var _logger = require("./util/logger");
 var _error = require("./common/error");
+var _dnsResolvers = require("./util/dns-resolvers");
+Object.keys(_dnsResolvers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _dnsResolvers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dnsResolvers[key];
+    }
+  });
+});
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 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; }
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 const _getLogger = (0, _logger.getLogger)("index"),
   trace = _getLogger.trace;
-const defaultDnsResolvers = exports.defaultDnsResolvers = [( /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(function* (domain) {
-    const data = yield fetch(`https://dns.google/resolve?name=${domain}&type=TXT`, {
-      method: "GET"
-    });
-    return data.json();
-  });
-  return function (_x) {
-    return _ref.apply(this, arguments);
-  };
-}()), ( /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(function* (domain) {
-    const data = yield fetch(`https://cloudflare-dns.com/dns-query?name=${domain}&type=TXT`, {
-      method: "GET",
-      headers: {
-        accept: "application/dns-json",
-        contentType: "application/json",
-        connection: "keep-alive"
-      }
-    });
-    return data.json();
-  });
-  return function (_x2) {
-    return _ref2.apply(this, arguments);
-  };
-}())];
+const defaultDnsResolvers = exports.defaultDnsResolvers = [_dnsResolvers.googleDnsResolver, _dnsResolvers.cloudflareDnsResolver, _dnsResolvers.aliDnsResolver];
 
 /**
  * Returns true for strings that are openattestation records
@@ -104,7 +102,7 @@ const formatDnsDidRecord = ({
   };
 };
 const queryDns = exports.queryDns = /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator(function* (domain, customDnsResolvers) {
+  var _ref = _asyncToGenerator(function* (domain, customDnsResolvers) {
     let data;
     let i = 0;
     if (domain.includes("://")) {
@@ -124,8 +122,8 @@ const queryDns = exports.queryDns = /*#__PURE__*/function () {
     }
     return data;
   });
-  return function queryDns(_x3, _x4) {
-    return _ref3.apply(this, arguments);
+  return function queryDns(_x, _x2) {
+    return _ref.apply(this, arguments);
   };
 }();
 
@@ -137,8 +135,10 @@ const parseOpenAttestationRecord = record => {
   trace(`Parsing record: ${record}`);
   const keyValuePairs = record.trim().split(" "); // tokenize into key=value elements
   const recordObject = {};
-  // @ts-ignore: we already checked for this token
-  recordObject.type = keyValuePairs.shift();
+  const typeToken = keyValuePairs.shift();
+  if (typeToken !== undefined) {
+    recordObject.type = typeToken;
+  }
   keyValuePairs.reduce(addKeyValuePairToObject, recordObject);
   return recordObject;
 };
@@ -175,6 +175,7 @@ const parseOpenAttestationRecords = (recordSet = []) => {
 /**
  * Takes a DNS-TXT Record set and returns openattestation document store records if any
  * @param recordSet Refer to tests for examples
+ * @param dnssec Resolver AD (authenticated data) flag; applied as each record's `dnssec` field
  */
 const parseDocumentStoreResults = (recordSet = [], dnssec) => {
   return parseOpenAttestationRecords(recordSet).reduce((prev, curr) => {
@@ -191,6 +192,7 @@ const parseDnsDidResults = (recordSet = [], dnssec) => {
 /**
  * Queries a given domain and parses the results to retrieve openattestation document store records if any
  * @param domain e.g: "example.openattestation.com"
+ * @param customDnsResolvers Optional resolver list; built-in HTTP DNS chain is used when omitted
  * @example
  * > getDocumentStoreRecords("example.openattestation.com")
  * > [ { type: 'openatts',
@@ -201,28 +203,28 @@ const parseDnsDidResults = (recordSet = [], dnssec) => {
  */
 exports.parseDnsDidResults = parseDnsDidResults;
 const getDocumentStoreRecords = exports.getDocumentStoreRecords = /*#__PURE__*/function () {
-  var _ref4 = _asyncToGenerator(function* (domain, customDnsResolvers) {
+  var _ref2 = _asyncToGenerator(function* (domain, customDnsResolvers) {
     trace(`Received request to resolve ${domain}`);
-    const dnsResolvers = customDnsResolvers || defaultDnsResolvers;
+    const dnsResolvers = customDnsResolvers !== null && customDnsResolvers !== void 0 ? customDnsResolvers : defaultDnsResolvers;
     const results = yield queryDns(domain, dnsResolvers);
     const answers = results.Answer || [];
     trace(`Lookup results: ${JSON.stringify(answers)}`);
     return parseDocumentStoreResults(answers, results.AD);
   });
-  return function getDocumentStoreRecords(_x5, _x6) {
-    return _ref4.apply(this, arguments);
+  return function getDocumentStoreRecords(_x3, _x4) {
+    return _ref2.apply(this, arguments);
   };
 }();
 const getDnsDidRecords = exports.getDnsDidRecords = /*#__PURE__*/function () {
-  var _ref5 = _asyncToGenerator(function* (domain, customDnsResolvers) {
+  var _ref3 = _asyncToGenerator(function* (domain, customDnsResolvers) {
     trace(`Received request to resolve ${domain}`);
-    const dnsResolvers = customDnsResolvers || defaultDnsResolvers;
+    const dnsResolvers = customDnsResolvers !== null && customDnsResolvers !== void 0 ? customDnsResolvers : defaultDnsResolvers;
     const results = yield queryDns(domain, dnsResolvers);
     const answers = results.Answer || [];
     trace(`Lookup results: ${JSON.stringify(answers)}`);
     return parseDnsDidResults(answers, results.AD);
   });
-  return function getDnsDidRecords(_x7, _x8) {
-    return _ref5.apply(this, arguments);
+  return function getDnsDidRecords(_x5, _x6) {
+    return _ref3.apply(this, arguments);
   };
 }();

package/dist/records/dnsTxt.js

@@ -3,31 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RecordTypesT = exports.OpenAttestationDNSTextRecordT = exports.EthereumNetworks = exports.EthereumNetworkIdT = exports.EthereumAddressT = exports.BlockchainNetworkT = void 0;
+exports.RecordTypesT = exports.OpenAttestationDNSTextRecordT = exports.EthereumNetworkIdT = exports.EthereumAddressT = exports.BlockchainNetworkT = void 0;
 var _runtypes = require("runtypes");
 const RecordTypesT = exports.RecordTypesT = (0, _runtypes.Literal)("openatts");
 const BlockchainNetworkT = exports.BlockchainNetworkT = (0, _runtypes.Literal)("ethereum");
 const EthereumAddressT = exports.EthereumAddressT = _runtypes.String.withConstraint(maybeAddress => {
   return /0x[a-fA-F0-9]{40}/.test(maybeAddress) || `${maybeAddress} is not a valid ethereum address`;
 });
-let EthereumNetworks = exports.EthereumNetworks = void 0;
-(function (EthereumNetworks) {
-  EthereumNetworks["homestead"] = "1";
-  EthereumNetworks["ropsten"] = "3";
-  EthereumNetworks["rinkeby"] = "4";
-  EthereumNetworks["goerli"] = "5";
-  EthereumNetworks["sepolia"] = "11155111";
-  EthereumNetworks["polygon"] = "137";
-  EthereumNetworks["polygonAmoy"] = "80002";
-  EthereumNetworks["local"] = "1337";
-  EthereumNetworks["xdc"] = "50";
-  EthereumNetworks["xdcapothem"] = "51";
-  EthereumNetworks["stabilityTestnet"] = "20180427";
-  EthereumNetworks["stability"] = "101010";
-  EthereumNetworks["astronTestnet"] = "21002";
-  EthereumNetworks["astron"] = "1338";
-})(EthereumNetworks || (exports.EthereumNetworks = EthereumNetworks = {}));
-const EthereumNetworkIdT = exports.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.polygonAmoy), (0, _runtypes.Literal)(EthereumNetworks.xdc), (0, _runtypes.Literal)(EthereumNetworks.xdcapothem), (0, _runtypes.Literal)(EthereumNetworks.stabilityTestnet), (0, _runtypes.Literal)(EthereumNetworks.stability), (0, _runtypes.Literal)(EthereumNetworks.local), (0, _runtypes.Literal)(EthereumNetworks.astronTestnet), (0, _runtypes.Literal)(EthereumNetworks.astron));
+const EthereumNetworkIdT = exports.EthereumNetworkIdT = _runtypes.String.withConstraint(maybeNetId => /^\d+$/.test(maybeNetId) || `${maybeNetId} is not a valid numeric network id`);
 const OpenAttestationDNSTextRecordT = exports.OpenAttestationDNSTextRecordT = (0, _runtypes.Record)({
   type: RecordTypesT,
   net: BlockchainNetworkT,

package/dist/ts/index.d.ts

@@ -24,12 +24,14 @@ export declare const parseOpenAttestationRecord: (record: string) => GenericObje
 /**
  * Takes a DNS-TXT Record set and returns openattestation document store records if any
  * @param recordSet Refer to tests for examples
+ * @param dnssec Resolver AD (authenticated data) flag; applied as each record's `dnssec` field
  */
 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"
+ * @param customDnsResolvers Optional resolver list; built-in HTTP DNS chain is used when omitted
  * @example
  * > getDocumentStoreRecords("example.openattestation.com")
  * > [ { type: 'openatts',
@@ -41,3 +43,4 @@ export declare const parseDnsDidResults: (recordSet: IDNSRecord[] | undefined, d
 export declare const getDocumentStoreRecords: (domain: string, customDnsResolvers?: CustomDnsResolver[]) => Promise<OpenAttestationDNSTextRecord[]>;
 export declare const getDnsDidRecords: (domain: string, customDnsResolvers?: CustomDnsResolver[]) => Promise<OpenAttestationDnsDidRecord[]>;
 export { OpenAttestationDNSTextRecord, OpenAttestationDnsDidRecord };
+export * from "./util/dns-resolvers";

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

@@ -1,28 +1,12 @@
-import { Static, Boolean, String, Literal, Record, Union, Partial } from "runtypes";
+import { Static, Boolean, String, Literal, Record, 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",
-    polygonAmoy = "80002",
-    local = "1337",
-    xdc = "50",
-    xdcapothem = "51",
-    stabilityTestnet = "20180427",
-    stability = "101010",
-    astronTestnet = "21002",
-    astron = "1338"
-}
-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.polygonAmoy>, Literal<EthereumNetworks.xdc>, Literal<EthereumNetworks.xdcapothem>, Literal<EthereumNetworks.stabilityTestnet>, Literal<EthereumNetworks.stability>, Literal<EthereumNetworks.local>, Literal<EthereumNetworks.astronTestnet>, Literal<EthereumNetworks.astron>]>;
+export declare const EthereumNetworkIdT: import("runtypes").Constraint<String, string, unknown>;
 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.polygonAmoy>, Literal<EthereumNetworks.xdc>, Literal<EthereumNetworks.xdcapothem>, Literal<EthereumNetworks.stabilityTestnet>, Literal<EthereumNetworks.stability>, Literal<EthereumNetworks.local>, Literal<EthereumNetworks.astronTestnet>, Literal<EthereumNetworks.astron>]>;
+    netId: import("runtypes").Constraint<String, string, unknown>;
     addr: import("runtypes").Constraint<String, string, unknown>;
 }, false>, Partial<{
     dnssec: Boolean;

package/dist/ts/util/dns-resolvers/ali-dns-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { CustomDnsResolver } from "../..";
+export declare const aliDnsResolver: CustomDnsResolver;

package/dist/ts/util/dns-resolvers/cloudflare-dns-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { CustomDnsResolver } from "../..";
+export declare const cloudflareDnsResolver: CustomDnsResolver;

package/dist/ts/util/dns-resolvers/dns-resolvers.test.d.ts

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

package/dist/ts/util/dns-resolvers/google-dns-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { CustomDnsResolver } from "../..";
+export declare const googleDnsResolver: CustomDnsResolver;

package/dist/ts/util/dns-resolvers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./google-dns-resolver";
+export * from "./cloudflare-dns-resolver";
+export * from "./ali-dns-resolver";

package/dist/util/dns-resolvers/ali-dns-resolver.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.aliDnsResolver = void 0;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+/** Ali DNS JSON API uses numeric RRTYPE; 16 = TXT */
+const ALI_DNS_TXT_QUERY_TYPE = "16";
+const aliDnsResolver = exports.aliDnsResolver = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (domain) {
+    const url = new URL("https://dns.alidns.com/resolve");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    url.searchParams.set("name", domain);
+    url.searchParams.set("type", ALI_DNS_TXT_QUERY_TYPE);
+    const res = yield fetch(url);
+    if (!res.ok) {
+      throw new Error(`Ali DNS request failed: HTTP ${res.status}`);
+    }
+    let data;
+    try {
+      data = yield res.json();
+    } catch (_unused) {
+      throw new Error("Failed to parse DNS response JSON");
+    }
+    return data;
+  });
+  return function aliDnsResolver(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/util/dns-resolvers/cloudflare-dns-resolver.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloudflareDnsResolver = void 0;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const cloudflareDnsResolver = exports.cloudflareDnsResolver = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (domain) {
+    const url = new URL("https://cloudflare-dns.com/dns-query");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    url.searchParams.set("name", domain);
+    url.searchParams.set("type", "TXT");
+    const res = yield fetch(url, {
+      headers: {
+        Accept: "application/dns-json"
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Cloudflare DNS request failed: HTTP ${res.status}`);
+    }
+    let data;
+    try {
+      data = yield res.json();
+    } catch (_unused) {
+      throw new Error("Failed to parse DNS response JSON");
+    }
+    return data;
+  });
+  return function cloudflareDnsResolver(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/util/dns-resolvers/google-dns-resolver.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.googleDnsResolver = void 0;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const googleDnsResolver = exports.googleDnsResolver = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (domain) {
+    const url = new URL("https://dns.google/resolve");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    url.searchParams.set("name", domain);
+    url.searchParams.set("type", "TXT");
+    const res = yield fetch(url);
+    if (!res.ok) {
+      throw new Error(`Google DNS request failed: HTTP ${res.status}`);
+    }
+    let data;
+    try {
+      data = yield res.json();
+    } catch (_unused) {
+      throw new Error("Failed to parse DNS response JSON");
+    }
+    return data;
+  });
+  return function googleDnsResolver(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/util/dns-resolvers/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _googleDnsResolver = require("./google-dns-resolver");
+Object.keys(_googleDnsResolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _googleDnsResolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _googleDnsResolver[key];
+    }
+  });
+});
+var _cloudflareDnsResolver = require("./cloudflare-dns-resolver");
+Object.keys(_cloudflareDnsResolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cloudflareDnsResolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _cloudflareDnsResolver[key];
+    }
+  });
+});
+var _aliDnsResolver = require("./ali-dns-resolver");
+Object.keys(_aliDnsResolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _aliDnsResolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _aliDnsResolver[key];
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradetrust-tt/dnsprove",
-  "version": "2.18.0",
+  "version": "2.20.0",
   "description": "Helper utility for retrieving OpenAttestations document store address records from DNS",
   "license": "Apache-2.0",
   "repository": {

package/src/index.test.ts

@@ -1,6 +1,14 @@
 import { setupServer, SetupServerApi } from "msw/node";
 import { http, HttpResponse } from "msw";
-import { CustomDnsResolver, getDocumentStoreRecords, queryDns, parseDocumentStoreResults, getDnsDidRecords } from ".";
+import {
+  aliDnsResolver,
+  cloudflareDnsResolver,
+  getDocumentStoreRecords,
+  getDnsDidRecords,
+  googleDnsResolver,
+  parseDocumentStoreResults,
+  queryDns,
+} from ".";
 import { DnsproveStatusCode } from "./common/error";
 
 describe("getCertStoreRecords", () => {
@@ -8,11 +16,11 @@ describe("getCertStoreRecords", () => {
     type: "openatts",
     net: "ethereum",
     netId: "3",
-    dnssec: true,
+    dnssec: false,
     addr: "0x2f60375e8144e16Adf1979936301D8341D58C36C",
   };
   test("it should work", async () => {
-    const records = await getDocumentStoreRecords("donotuse.openattestation.com");
+    const records = await getDocumentStoreRecords("donotuse.trustvc.io");
     expect(records).toStrictEqual([sampleDnsTextRecordWithDnssec]);
   });
 
@@ -27,14 +35,14 @@ describe("getCertStoreRecords", () => {
 
 describe("getDnsDidRecords", () => {
   test("it should work", async () => {
-    const records = await getDnsDidRecords("donotuse.openattestation.com");
+    const records = await getDnsDidRecords("donotuse.trustvc.io");
     expect(records).toStrictEqual([
       {
         type: "openatts",
         algorithm: "dns-did",
         publicKey: "did:ethr:0xE712878f6E8d5d4F9e87E10DA604F9cB564C9a89#controller",
         version: "1.0",
-        dnssec: true,
+        dnssec: false,
       },
     ]);
   });
@@ -165,6 +173,76 @@ describe("parseDocumentStoreResults", () => {
     ];
     expect(parseDocumentStoreResults(sampleRecord, true)).toStrictEqual([]);
   });
+
+  test("it should accept any numeric netId (e.g. Mantle mainnet 5000)", () => {
+    const addr = "0x2f60375e8144e16Adf1979936301D8341D58C36C";
+    const sampleRecord = [
+      {
+        name: "example.example.com.",
+        type: 16,
+        TTL: 110,
+        data: `"openatts net=ethereum netId=5000 addr=${addr}"`,
+        dnssec: false,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, false)).toStrictEqual([
+      {
+        type: "openatts",
+        net: "ethereum",
+        netId: "5000",
+        addr,
+        dnssec: false,
+      },
+    ]);
+  });
+
+  test("it should accept an arbitrary previously-unknown numeric netId", () => {
+    const addr = "0x2f60375e8144e16Adf1979936301D8341D58C36C";
+    const sampleRecord = [
+      {
+        name: "example.example.com.",
+        type: 16,
+        TTL: 110,
+        data: `"openatts net=ethereum netId=99999 addr=${addr}"`,
+        dnssec: false,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, false)).toStrictEqual([
+      {
+        type: "openatts",
+        net: "ethereum",
+        netId: "99999",
+        addr,
+        dnssec: false,
+      },
+    ]);
+  });
+
+  test("it should reject a non-numeric netId", () => {
+    const sampleRecord = [
+      {
+        name: "example.example.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=abc addr=0x2f60375e8144e16Adf1979936301D8341D58C36C"',
+        dnssec: false,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, false)).toStrictEqual([]);
+  });
+
+  test("it should reject an alphanumeric netId", () => {
+    const sampleRecord = [
+      {
+        name: "example.example.com.",
+        type: 16,
+        TTL: 110,
+        data: '"openatts net=ethereum netId=1abc addr=0x2f60375e8144e16Adf1979936301D8341D58C36C"',
+        dnssec: false,
+      },
+    ];
+    expect(parseDocumentStoreResults(sampleRecord, false)).toStrictEqual([]);
+  });
 });
 
 describe("queryDns", () => {
@@ -177,29 +255,29 @@ describe("queryDns", () => {
     RA: true,
     AD: true,
     CD: false,
-    Question: [{ name: "donotuse.openattestation.com.", type: 16 }],
+    Question: [{ name: "donotuse.trustvc.io.", type: 16 }],
     Answer: [
       {
-        name: "donotuse.openattestation.com.",
+        name: "donotuse.trustvc.io.",
         type: 16,
         TTL: 300,
         data: "openatts a=dns-did; p=did:ethr:0xE712878f6E8d5d4F9e87E10DA604F9cB564C9a89#controller; v=1.0;",
       },
       {
-        name: "donotuse.openattestation.com.",
+        name: "donotuse.trustvc.io.",
         type: 16,
         TTL: 300,
         data:
           "openatts DO NOT ADD ANY RECORDS BEYOND THIS AS THIS DOMAIN IS USED FOR DNSPROVE NPM LIBRARY INTEGRATION TESTS",
       },
       {
-        name: "donotuse.openattestation.com.",
+        name: "donotuse.trustvc.io.",
         type: 16,
         TTL: 300,
         data: "openatts fooooooobarrrrrrrrr this entry exists to ensure validation works",
       },
       {
-        name: "donotuse.openattestation.com.",
+        name: "donotuse.trustvc.io.",
         type: 16,
         TTL: 300,
         data: "openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf1979936301D8341D58C36C",
@@ -208,22 +286,7 @@ describe("queryDns", () => {
     Comment: "Response from 205.251.199.177.",
   };
 
-  const testDnsResolvers: CustomDnsResolver[] = [
-    async (domain) => {
-      const data = await fetch(`https://dns.google/resolve?name=${domain}&type=TXT`, {
-        method: "GET",
-      });
-
-      return data.json();
-    },
-    async (domain) => {
-      const data = await fetch(`https://cloudflare-dns.com/dns-query?name=${domain}&type=TXT`, {
-        method: "GET",
-        headers: { accept: "application/dns-json", contentType: "application/json", connection: "keep-alive" },
-      });
-      return data.json();
-    },
-  ];
+  const testDnsResolvers = [googleDnsResolver, cloudflareDnsResolver, aliDnsResolver];
 
   afterEach(() => {
     server.close();
@@ -239,7 +302,7 @@ describe("queryDns", () => {
     server = setupServer(...handlers);
     server.listen();
 
-    const records = await queryDns("https://donotuse.openattestation.com", testDnsResolvers);
+    const records = await queryDns("https://donotuse.trustvc.io", testDnsResolvers);
     const sortedAnswer = records?.Answer.sort((a, b) => a.data.localeCompare(b.data));
     expect(sortedAnswer).toMatchObject(sampleResponse.Answer);
   });
@@ -256,7 +319,28 @@ describe("queryDns", () => {
     server = setupServer(...handlers);
     server.listen();
 
-    const records = await queryDns("https://donotuse.openattestation.com", testDnsResolvers);
+    const records = await queryDns("https://donotuse.trustvc.io", testDnsResolvers);
+
+    const sortedAnswer = records?.Answer.sort((a, b) => a.data.localeCompare(b.data));
+    expect(sortedAnswer).toMatchObject(sampleResponse.Answer);
+  });
+
+  test("Should fallback to third dns when first and second dns is down", async () => {
+    const handlers = [
+      http.get("https://dns.google/resolve", (_) => {
+        return new HttpResponse(null, { status: 500 });
+      }),
+      http.get("https://cloudflare-dns.com/dns-query", (_) => {
+        return new HttpResponse(null, { status: 500 });
+      }),
+      http.get("https://dns.alidns.com/resolve", (_) => {
+        return HttpResponse.json(sampleResponse);
+      }),
+    ];
+    server = setupServer(...handlers);
+    server.listen();
+
+    const records = await queryDns("https://donotuse.trustvc.io", testDnsResolvers);
 
     const sortedAnswer = records?.Answer.sort((a, b) => a.data.localeCompare(b.data));
     expect(sortedAnswer).toMatchObject(sampleResponse.Answer);
@@ -270,14 +354,16 @@ describe("queryDns", () => {
       http.get("https://cloudflare-dns.com/dns-query", (_) => {
         return new HttpResponse(null, { status: 500 });
       }),
+      http.get("https://dns.alidns.com/resolve", (_) => {
+        return new HttpResponse(null, { status: 500 });
+      }),
     ];
     server = setupServer(...handlers);
     server.listen();
-    try {
-      await queryDns("https://donotuse.openattestation.com", testDnsResolvers);
-    } catch (e: any) {
-      expect(e.code).toStrictEqual(DnsproveStatusCode.IDNS_QUERY_ERROR_GENERAL);
-    }
+
+    await expect(queryDns("https://donotuse.trustvc.io", testDnsResolvers)).rejects.toMatchObject({
+      code: DnsproveStatusCode.IDNS_QUERY_ERROR_GENERAL,
+    });
   });
 });
 
@@ -321,6 +407,13 @@ describe("getDocumentStoreRecords for Astron", () => {
       addr: "0x18bc0127Ae33389cD96593a1a612774fD14c0737",
       dnssec: false,
     },
+    {
+      type: "openatts",
+      net: "ethereum",
+      netId: "1338",
+      addr: "0x94FD21A026E29E0686583b8be71Cb28a8ca1A8d4",
+      dnssec: false,
+    },
     {
       type: "openatts",
       net: "ethereum",

package/src/index.ts

@@ -2,6 +2,7 @@ import { OpenAttestationDNSTextRecord, OpenAttestationDNSTextRecordT } from "./r
 import { OpenAttestationDnsDidRecord, OpenAttestationDnsDidRecordT } from "./records/dnsDid";
 import { getLogger } from "./util/logger";
 import { CodedError, DnsproveStatusCode } from "./common/error";
+import { aliDnsResolver, cloudflareDnsResolver, googleDnsResolver } from "./util/dns-resolvers";
 
 const { trace } = getLogger("index");
 
@@ -23,22 +24,7 @@ interface GenericObject {
 
 export type CustomDnsResolver = (domain: string) => Promise<IDNSQueryResponse>;
 
-export const defaultDnsResolvers: CustomDnsResolver[] = [
-  async (domain) => {
-    const data = await fetch(`https://dns.google/resolve?name=${domain}&type=TXT`, {
-      method: "GET",
-    });
-
-    return data.json();
-  },
-  async (domain) => {
-    const data = await fetch(`https://cloudflare-dns.com/dns-query?name=${domain}&type=TXT`, {
-      method: "GET",
-      headers: { accept: "application/dns-json", contentType: "application/json", connection: "keep-alive" },
-    });
-    return data.json();
-  },
-];
+export const defaultDnsResolvers: CustomDnsResolver[] = [googleDnsResolver, cloudflareDnsResolver, aliDnsResolver];
 
 /**
  * Returns true for strings that are openattestation records
@@ -115,8 +101,10 @@ export const parseOpenAttestationRecord = (record: string): GenericObject => {
   trace(`Parsing record: ${record}`);
   const keyValuePairs = record.trim().split(" "); // tokenize into key=value elements
   const recordObject = {} as GenericObject;
-  // @ts-ignore: we already checked for this token
-  recordObject.type = keyValuePairs.shift();
+  const typeToken = keyValuePairs.shift();
+  if (typeToken !== undefined) {
+    recordObject.type = typeToken;
+  }
   keyValuePairs.reduce<GenericObject>(addKeyValuePairToObject, recordObject);
   return recordObject;
 };
@@ -153,6 +141,7 @@ const parseOpenAttestationRecords = (recordSet: IDNSRecord[] = []): GenericObjec
 /**
  * Takes a DNS-TXT Record set and returns openattestation document store records if any
  * @param recordSet Refer to tests for examples
+ * @param dnssec Resolver AD (authenticated data) flag; applied as each record's `dnssec` field
  */
 export const parseDocumentStoreResults = (
   recordSet: IDNSRecord[] = [],
@@ -177,6 +166,7 @@ export const parseDnsDidResults = (recordSet: IDNSRecord[] = [], dnssec: boolean
 /**
  * Queries a given domain and parses the results to retrieve openattestation document store records if any
  * @param domain e.g: "example.openattestation.com"
+ * @param customDnsResolvers Optional resolver list; built-in HTTP DNS chain is used when omitted
  * @example
  * > getDocumentStoreRecords("example.openattestation.com")
  * > [ { type: 'openatts',
@@ -191,7 +181,7 @@ export const getDocumentStoreRecords = async (
 ): Promise<OpenAttestationDNSTextRecord[]> => {
   trace(`Received request to resolve ${domain}`);
 
-  const dnsResolvers = customDnsResolvers || defaultDnsResolvers;
+  const dnsResolvers = customDnsResolvers ?? defaultDnsResolvers;
 
   const results = await queryDns(domain, dnsResolvers);
   const answers = results.Answer || [];
@@ -207,7 +197,7 @@ export const getDnsDidRecords = async (
 ): Promise<OpenAttestationDnsDidRecord[]> => {
   trace(`Received request to resolve ${domain}`);
 
-  const dnsResolvers = customDnsResolvers || defaultDnsResolvers;
+  const dnsResolvers = customDnsResolvers ?? defaultDnsResolvers;
 
   const results = await queryDns(domain, dnsResolvers);
   const answers = results.Answer || [];
@@ -218,3 +208,4 @@ export const getDnsDidRecords = async (
 };
 
 export { OpenAttestationDNSTextRecord, OpenAttestationDnsDidRecord };
+export * from "./util/dns-resolvers";

package/src/records/dnsTxt.ts

@@ -1,4 +1,4 @@
-import { Static, Boolean, String, Literal, Record, Union, Partial } from "runtypes";
+import { Static, Boolean, String, Literal, Record, Partial } from "runtypes";
 
 export const RecordTypesT = Literal("openatts");
 
@@ -8,38 +8,8 @@ export const EthereumAddressT = String.withConstraint((maybeAddress: string) =>
   return /0x[a-fA-F0-9]{40}/.test(maybeAddress) || `${maybeAddress} is not a valid ethereum address`;
 });
 
-export enum EthereumNetworks {
-  homestead = "1",
-  ropsten = "3",
-  rinkeby = "4",
-  goerli = "5",
-  sepolia = "11155111",
-  polygon = "137",
-  polygonAmoy = "80002",
-  local = "1337",
-  xdc = "50",
-  xdcapothem = "51",
-  stabilityTestnet = "20180427",
-  stability = "101010",
-  astronTestnet = "21002",
-  astron = "1338",
-}
-
-export const EthereumNetworkIdT = Union(
-  Literal(EthereumNetworks.homestead),
-  Literal(EthereumNetworks.ropsten),
-  Literal(EthereumNetworks.rinkeby),
-  Literal(EthereumNetworks.goerli),
-  Literal(EthereumNetworks.sepolia),
-  Literal(EthereumNetworks.polygon),
-  Literal(EthereumNetworks.polygonAmoy),
-  Literal(EthereumNetworks.xdc),
-  Literal(EthereumNetworks.xdcapothem),
-  Literal(EthereumNetworks.stabilityTestnet),
-  Literal(EthereumNetworks.stability),
-  Literal(EthereumNetworks.local),
-  Literal(EthereumNetworks.astronTestnet),
-  Literal(EthereumNetworks.astron)
+export const EthereumNetworkIdT = String.withConstraint(
+  (maybeNetId: string) => /^\d+$/.test(maybeNetId) || `${maybeNetId} is not a valid numeric network id`
 );
 
 export const OpenAttestationDNSTextRecordT = Record({

package/src/util/dns-resolvers/ali-dns-resolver.ts

@@ -0,0 +1,29 @@
+import type { CustomDnsResolver, IDNSQueryResponse } from "../..";
+
+/** Ali DNS JSON API uses numeric RRTYPE; 16 = TXT */
+const ALI_DNS_TXT_QUERY_TYPE = "16";
+export const aliDnsResolver: CustomDnsResolver = async (domain) => {
+  const url = new URL("https://dns.alidns.com/resolve");
+
+  if (!domain) {
+    throw new Error("Domain is required");
+  }
+
+  url.searchParams.set("name", domain);
+  url.searchParams.set("type", ALI_DNS_TXT_QUERY_TYPE);
+
+  const res = await fetch(url);
+
+  if (!res.ok) {
+    throw new Error(`Ali DNS request failed: HTTP ${res.status}`);
+  }
+
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("Failed to parse DNS response JSON");
+  }
+
+  return data as IDNSQueryResponse;
+};

package/src/util/dns-resolvers/cloudflare-dns-resolver.ts

@@ -0,0 +1,29 @@
+import type { CustomDnsResolver, IDNSQueryResponse } from "../..";
+
+export const cloudflareDnsResolver: CustomDnsResolver = async (domain) => {
+  const url = new URL("https://cloudflare-dns.com/dns-query");
+
+  if (!domain) {
+    throw new Error("Domain is required");
+  }
+
+  url.searchParams.set("name", domain);
+  url.searchParams.set("type", "TXT");
+
+  const res = await fetch(url, {
+    headers: { Accept: "application/dns-json" },
+  });
+
+  if (!res.ok) {
+    throw new Error(`Cloudflare DNS request failed: HTTP ${res.status}`);
+  }
+
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("Failed to parse DNS response JSON");
+  }
+
+  return data as IDNSQueryResponse;
+};

package/src/util/dns-resolvers/dns-resolvers.test.ts

@@ -0,0 +1,120 @@
+import { setupServer, SetupServerApi } from "msw/node";
+import { http, HttpResponse } from "msw";
+import { aliDnsResolver } from "./ali-dns-resolver";
+import { cloudflareDnsResolver } from "./cloudflare-dns-resolver";
+import { googleDnsResolver } from "./google-dns-resolver";
+
+const emptyDnsJson = {
+  Status: 0,
+  TC: false,
+  RD: true,
+  RA: true,
+  AD: false,
+  CD: false,
+  Answer: [] as [],
+};
+
+describe("googleDnsResolver", () => {
+  let server: SetupServerApi | undefined;
+
+  afterEach(() => {
+    server?.close();
+  });
+
+  test("requests Google DNS JSON with name, TXT type, and encoded query", async () => {
+    server = setupServer(
+      http.get("https://dns.google/resolve", ({ request }) => {
+        const url = new URL(request.url);
+        expect(url.searchParams.get("name")).toBe("my domain.test");
+        expect(url.searchParams.get("type")).toBe("TXT");
+        return HttpResponse.json(emptyDnsJson);
+      })
+    );
+    server.listen();
+
+    const out = await googleDnsResolver("my domain.test");
+    expect(out).toMatchObject({ Status: 0, Answer: [] });
+  });
+
+  test("throws when Google DNS returns non-2xx", async () => {
+    server = setupServer(http.get("https://dns.google/resolve", () => new HttpResponse(null, { status: 503 })));
+    server.listen();
+
+    await expect(googleDnsResolver("my.domain.test")).rejects.toThrow(/HTTP 503/);
+  });
+
+  test("throws when domain is empty", async () => {
+    await expect(googleDnsResolver("")).rejects.toThrow("Domain is required");
+  });
+});
+
+describe("cloudflareDnsResolver", () => {
+  let server: SetupServerApi | undefined;
+
+  afterEach(() => {
+    server?.close();
+  });
+
+  test("requests Cloudflare DNS JSON with name, TXT type, Accept header, and encoded query", async () => {
+    server = setupServer(
+      http.get("https://cloudflare-dns.com/dns-query", ({ request }) => {
+        const url = new URL(request.url);
+        expect(url.searchParams.get("name")).toBe("cf example.test");
+        expect(url.searchParams.get("type")).toBe("TXT");
+        expect(request.headers.get("accept")).toBe("application/dns-json");
+        return HttpResponse.json(emptyDnsJson);
+      })
+    );
+    server.listen();
+
+    const out = await cloudflareDnsResolver("cf example.test");
+    expect(out).toMatchObject({ Status: 0, Answer: [] });
+  });
+
+  test("throws when Cloudflare DNS returns non-2xx", async () => {
+    server = setupServer(
+      http.get("https://cloudflare-dns.com/dns-query", () => new HttpResponse(null, { status: 502 }))
+    );
+    server.listen();
+
+    await expect(cloudflareDnsResolver("cf.example.test")).rejects.toThrow(/HTTP 502/);
+  });
+
+  test("throws when domain is empty", async () => {
+    await expect(cloudflareDnsResolver("")).rejects.toThrow("Domain is required");
+  });
+});
+
+describe("aliDnsResolver", () => {
+  let server: SetupServerApi | undefined;
+
+  afterEach(() => {
+    server?.close();
+  });
+
+  test("requests Ali DNS JSON with name, type 16 (TXT), and encoded query", async () => {
+    server = setupServer(
+      http.get("https://dns.alidns.com/resolve", ({ request }) => {
+        const url = new URL(request.url);
+        expect(url.searchParams.get("name")).toBe("ali example.test");
+        expect(url.searchParams.get("type")).toBe("16");
+        return HttpResponse.json(emptyDnsJson);
+      })
+    );
+    server.listen();
+
+    const out = await aliDnsResolver("ali example.test");
+    expect(out).toMatchObject({ Status: 0, Answer: [] });
+  });
+
+  test("throws when Ali DNS returns non-2xx", async () => {
+    server = setupServer(http.get("https://dns.alidns.com/resolve", () => new HttpResponse(null, { status: 503 })));
+    server.listen();
+
+    await expect(aliDnsResolver("ali.example.test")).rejects.toThrow(/HTTP 503/);
+  });
+
+  test("throws when domain is empty", async () => {
+    await expect(aliDnsResolver("")).rejects.toThrow("Domain is required");
+  });
+});

package/src/util/dns-resolvers/google-dns-resolver.ts

@@ -0,0 +1,27 @@
+import type { CustomDnsResolver, IDNSQueryResponse } from "../..";
+
+export const googleDnsResolver: CustomDnsResolver = async (domain) => {
+  const url = new URL("https://dns.google/resolve");
+
+  if (!domain) {
+    throw new Error("Domain is required");
+  }
+
+  url.searchParams.set("name", domain);
+  url.searchParams.set("type", "TXT");
+
+  const res = await fetch(url);
+
+  if (!res.ok) {
+    throw new Error(`Google DNS request failed: HTTP ${res.status}`);
+  }
+
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("Failed to parse DNS response JSON");
+  }
+
+  return data as IDNSQueryResponse;
+};

package/src/util/dns-resolvers/index.ts

@@ -0,0 +1,3 @@
+export * from "./google-dns-resolver";
+export * from "./cloudflare-dns-resolver";
+export * from "./ali-dns-resolver";