@tradetrust-tt/dnsprove 2.8.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020 Government Technology Agency, Singapore
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,160 @@
+# Open Attestation (dnsprove)
+
+A helper library to retrieve OpenAttestation DNS-TXT records from domains using Google's public DNS service.
+
+A valid OpenAttestation DNS-TXT record looks like:
+
+```js
+[
+  {
+    name: "example.openattestation.com.",
+    type: 16,
+    TTL: 110,
+    data: '"openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf1979936301D8341D58C36C"',
+  },
+];
+```
+
+Validation is run on all retrieved records to ensure they conform to the expected format, and records that fail validation will simply be omitted from the returned results.
+
+## Installation
+
+```bash
+npm i @tradetrust/dnsprove
+```
+
+***
+
+## Debug
+
+To see validation failures run the library with the debug flag turned on, either
+
+In Browser:
+
+`localStorage.debug="dnsprove*"`
+
+In NodeJS:
+
+```sh
+DEBUG="dnsprove*" npm run test
+```
+
+## Types
+
+This library uses [runtypes](https://github.com/pelotom/runtypes) for compile time static type checking as well as run time input validation. The generated documentation below is inaccurate for any Runtypes generated types due to documentation generator limitations.
+
+## API
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+#### Table of Contents
+
+*   [OpenAttestationDNSTextRecord](#openattestationdnstextrecord)
+*   [OpenAttestationDnsDidRecord](#openattestationdnsdidrecord)
+*   [IDNSRecord](#idnsrecord)
+*   [IDNSQueryResponse](#idnsqueryresponse)
+*   [CustomDnsResolver](#customdnsresolver)
+*   [defaultDnsResolvers](#defaultdnsresolvers)
+*   [queryDns](#querydns)
+    *   [Parameters](#parameters)
+*   [parseOpenAttestationRecord](#parseopenattestationrecord)
+    *   [Parameters](#parameters-1)
+*   [parseDocumentStoreResults](#parsedocumentstoreresults)
+    *   [Parameters](#parameters-2)
+*   [parseDnsDidResults](#parsednsdidresults)
+    *   [Parameters](#parameters-3)
+*   [getDocumentStoreRecords](#getdocumentstorerecords)
+    *   [Parameters](#parameters-4)
+    *   [Examples](#examples)
+*   [getDnsDidRecords](#getdnsdidrecords)
+    *   [Parameters](#parameters-5)
+
+### OpenAttestationDNSTextRecord
+
+### OpenAttestationDnsDidRecord
+
+### IDNSRecord
+
+### IDNSQueryResponse
+
+### CustomDnsResolver
+
+Type: function (domain: [string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)): [Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)<[IDNSQueryResponse](#idnsqueryresponse)>
+
+### defaultDnsResolvers
+
+Type: [Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[CustomDnsResolver](#customdnsresolver)>
+
+### queryDns
+
+#### Parameters
+
+*   `domain` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
+*   `customDnsResolvers` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[CustomDnsResolver](#customdnsresolver)>** 
+
+Returns **[Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)<[IDNSQueryResponse](#idnsqueryresponse)>** 
+
+### parseOpenAttestationRecord
+
+Parses one openattestation DNS-TXT record and turns it into an OpenAttestationsDNSTextRecord object
+
+#### Parameters
+
+*   `record` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** e.g: '"openatts net=ethereum netId=3 addr=0x0c9d5E6C766030cc6f0f49951D275Ad0701F81EC"'
+
+Returns **GenericObject** 
+
+### parseDocumentStoreResults
+
+Takes a DNS-TXT Record set and returns openattestation document store records if any
+
+#### 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)** 
+
+Returns **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[OpenAttestationDNSTextRecord](#openattestationdnstextrecord)>** 
+
+### parseDnsDidResults
+
+#### Parameters
+
+*   `recordSet` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[IDNSRecord](#idnsrecord)>**  (optional, default `[]`)
+*   `dnssec` **[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** 
+
+Returns **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[OpenAttestationDnsDidRecord](#openattestationdnsdidrecord)>** 
+
+### getDocumentStoreRecords
+
+Queries a given domain and parses the results to retrieve openattestation document store records if any
+
+#### 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)>?** 
+
+#### Examples
+
+```javascript
+> getDocumentStoreRecords("example.openattestation.com")
+> [ { type: 'openatts',
+net: 'ethereum',
+netId: '3',
+addr: '0x2f60375e8144e16Adf1979936301D8341D58C36C',
+dnssec: true } ]
+```
+
+Returns **[Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)<[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[OpenAttestationDNSTextRecord](#openattestationdnstextrecord)>>** 
+
+### getDnsDidRecords
+
+#### Parameters
+
+*   `domain` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
+*   `customDnsResolvers` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[CustomDnsResolver](#customdnsresolver)>?** 
+
+Returns **[Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)<[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[OpenAttestationDnsDidRecord](#openattestationdnsdidrecord)>>** 
+
+## License
+
+MIT

package/dist/common/error.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CodedError = exports.DnsproveStatusCode = void 0;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+let DnsproveStatusCode;
+exports.DnsproveStatusCode = DnsproveStatusCode;
+
+(function (DnsproveStatusCode) {
+  DnsproveStatusCode[DnsproveStatusCode["IDNS_QUERY_ERROR_GENERAL"] = 0] = "IDNS_QUERY_ERROR_GENERAL";
+})(DnsproveStatusCode || (exports.DnsproveStatusCode = DnsproveStatusCode = {}));
+
+class CodedError extends Error {
+  constructor(message, code, codeString) {
+    super(message);
+
+    _defineProperty(this, "code", void 0);
+
+    _defineProperty(this, "codeString", void 0);
+
+    this.code = code;
+    this.codeString = codeString;
+  }
+
+}
+
+exports.CodedError = CodedError;

package/dist/index.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "OpenAttestationDNSTextRecord", {
+  enumerable: true,
+  get: function get() {
+    return _dnsTxt.OpenAttestationDNSTextRecord;
+  }
+});
+Object.defineProperty(exports, "OpenAttestationDnsDidRecord", {
+  enumerable: true,
+  get: function get() {
+    return _dnsDid.OpenAttestationDnsDidRecord;
+  }
+});
+exports.getDnsDidRecords = exports.getDocumentStoreRecords = exports.parseDnsDidResults = exports.parseDocumentStoreResults = exports.parseOpenAttestationRecord = exports.queryDns = exports.defaultDnsResolvers = void 0;
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _dnsTxt = require("./records/dnsTxt");
+
+var _dnsDid = require("./records/dnsDid");
+
+var _logger = require("./util/logger");
+
+var _error = require("./common/error");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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 = [/*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (domain) {
+    const _yield$axios = yield (0, _axios.default)({
+      method: "GET",
+      url: `https://dns.google/resolve?name=${domain}&type=TXT`
+    }),
+          data = _yield$axios.data;
+
+    return data;
+  });
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+}(), /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(function* (domain) {
+    const _yield$axios2 = yield (0, _axios.default)({
+      method: "GET",
+      url: `https://cloudflare-dns.com/dns-query?name=${domain}&type=TXT`,
+      headers: {
+        accept: "application/dns-json",
+        contentType: "application/json",
+        connection: "keep-alive"
+      }
+    }),
+          data = _yield$axios2.data;
+
+    return data;
+  });
+
+  return function (_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}()];
+/**
+ * Returns true for strings that are openattestation records
+ * @param txtDataString e.g: '"openatts net=ethereum netId=3 addr=0x0c9d5E6C766030cc6f0f49951D275Ad0701F81EC"'
+ */
+
+exports.defaultDnsResolvers = defaultDnsResolvers;
+
+const isOpenAttestationRecord = txtDataString => {
+  return txtDataString.startsWith("openatts");
+};
+
+const trimValue = str => {
+  return str.endsWith(";") ? str.substring(0, str.length - 1).trim() : str.trim();
+};
+/**
+ * Takes a string in the format of "key=value" and adds it to a JS object as key: value
+ * @param obj Object that will be modified
+ * @param keyValuePair A key value pair to add to the given object
+ * @example addKeyValuePairToObject(objectToModify, "foo=bar")
+ */
+
+
+const addKeyValuePairToObject = (obj, keyValuePair) => {
+  const _keyValuePair$split = keyValuePair.split("="),
+        _keyValuePair$split2 = _toArray(_keyValuePair$split),
+        key = _keyValuePair$split2[0],
+        values = _keyValuePair$split2.slice(1);
+
+  const value = values.join("="); // in case there were values with = in them
+
+  /* eslint-disable no-param-reassign */
+  // this is necessary because we modify the accumulator in .reduce
+
+  obj[key.trim()] = trimValue(value);
+  return obj;
+};
+
+const formatDnsDidRecord = ({
+  a,
+  v,
+  p,
+  type
+}) => {
+  return {
+    type,
+    algorithm: a,
+    publicKey: p,
+    version: v
+  };
+};
+
+const queryDns = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(function* (domain, customDnsResolvers) {
+    let data;
+    let i = 0;
+
+    while (!data && i < customDnsResolvers.length) {
+      try {
+        const customDnsResolver = customDnsResolvers[i]; // eslint-disable-next-line no-await-in-loop
+
+        data = yield customDnsResolver(domain);
+      } catch (e) {
+        i += 1;
+      }
+    }
+
+    if (!data) {
+      throw new _error.CodedError("Unable to query DNS", _error.DnsproveStatusCode.IDNS_QUERY_ERROR_GENERAL, "IDNS_QUERY_ERROR_GENERAL");
+    }
+
+    return data;
+  });
+
+  return function queryDns(_x3, _x4) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Parses one openattestation DNS-TXT record and turns it into an OpenAttestationsDNSTextRecord object
+ * @param record e.g: '"openatts net=ethereum netId=3 addr=0x0c9d5E6C766030cc6f0f49951D275Ad0701F81EC"'
+ */
+
+
+exports.queryDns = queryDns;
+
+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();
+  keyValuePairs.reduce(addKeyValuePairToObject, recordObject);
+  return recordObject;
+};
+/**
+ * Currying function that applies a given dnssec result
+ */
+
+
+exports.parseOpenAttestationRecord = parseOpenAttestationRecord;
+
+const applyDnssecResults = dnssecStatus => record => {
+  return _objectSpread(_objectSpread({}, record), {}, {
+    dnssec: dnssecStatus
+  });
+};
+/**
+ * Some DNS servers return TXT records with quoted strings, others don't :D
+ * @param record
+ * @returns unquoted DNS record
+ */
+
+
+const trimDoubleQuotes = record => {
+  return record.startsWith('"') ? record.slice(1, -1) : record;
+};
+/**
+ * Takes a record set and breaks that info array of key value pairs
+ * @param recordSet e.g: [{name: "google.com", type: 16, TTL: 3599, data: '"openatts net=ethereum netId=3 addr=0x2f60375e8144e16Adf1979936301D8341D58C36C"}]
+ */
+
+
+const parseOpenAttestationRecords = (recordSet = []) => {
+  trace(`Parsing DNS results: ${JSON.stringify(recordSet)}`);
+  return recordSet.map(record => record.data).map(trimDoubleQuotes) // removing leading and trailing quotes if they exist
+  .filter(isOpenAttestationRecord).map(parseOpenAttestationRecord);
+};
+/**
+ * Takes a DNS-TXT Record set and returns openattestation document store records if any
+ * @param recordSet Refer to tests for examples
+ */
+
+
+const parseDocumentStoreResults = (recordSet = [], dnssec) => {
+  return parseOpenAttestationRecords(recordSet).reduce((prev, curr) => {
+    return _dnsTxt.OpenAttestationDNSTextRecordT.guard(curr) ? [...prev, curr] : prev;
+  }, []).map(applyDnssecResults(dnssec));
+};
+
+exports.parseDocumentStoreResults = parseDocumentStoreResults;
+
+const parseDnsDidResults = (recordSet = [], dnssec) => {
+  return parseOpenAttestationRecords(recordSet).map(formatDnsDidRecord).reduce((prev, curr) => {
+    return _dnsDid.OpenAttestationDnsDidRecordT.guard(curr) ? [...prev, curr] : prev;
+  }, []).map(applyDnssecResults(dnssec));
+};
+/**
+ * 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 } ]
+ */
+
+
+exports.parseDnsDidResults = parseDnsDidResults;
+
+const getDocumentStoreRecords = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(function* (domain, customDnsResolvers) {
+    trace(`Received request to resolve ${domain}`);
+    const dnsResolvers = 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);
+  };
+}();
+
+exports.getDocumentStoreRecords = getDocumentStoreRecords;
+
+const getDnsDidRecords = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator(function* (domain, customDnsResolvers) {
+    trace(`Received request to resolve ${domain}`);
+    const dnsResolvers = 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);
+  };
+}();
+
+exports.getDnsDidRecords = getDnsDidRecords;