@tradetrust-tt/dnsprove 2.19.0 → 2.21.0

package/dist/index.js

@@ -58,7 +58,7 @@ function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symb
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 const _getLogger = (0, _logger.getLogger)("index"),
   trace = _getLogger.trace;
-const defaultDnsResolvers = exports.defaultDnsResolvers = [_dnsResolvers.googleDnsResolver, _dnsResolvers.cloudflareDnsResolver, _dnsResolvers.aliDnsResolver];
+const defaultDnsResolvers = exports.defaultDnsResolvers = [_dnsResolvers.googleDnsResolver, _dnsResolvers.cloudflareDnsResolver, _dnsResolvers.proxyDnsResolver, _dnsResolvers.aliDnsResolver];
 
 /**
  * Returns true for strings that are openattestation records

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/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/index.d.ts

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

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

@@ -0,0 +1,3 @@
+import type { CustomDnsResolver } from "../..";
+/** Server-side DoH proxy that forwards to Google/Cloudflare upstream — reachable from regions where direct access to those endpoints is blocked. */
+export declare const proxyDnsResolver: CustomDnsResolver;

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

@@ -35,4 +35,15 @@ Object.keys(_aliDnsResolver).forEach(function (key) {
       return _aliDnsResolver[key];
     }
   });
+});
+var _proxyDnsResolver = require("./proxy-dns-resolver");
+Object.keys(_proxyDnsResolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _proxyDnsResolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _proxyDnsResolver[key];
+    }
+  });
 });

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.proxyDnsResolver = 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); }); }; }
+/** Server-side DoH proxy that forwards to Google/Cloudflare upstream — reachable from regions where direct access to those endpoints is blocked. */
+const proxyDnsResolver = exports.proxyDnsResolver = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (domain) {
+    const url = new URL("https://dns.opencerts.io/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(`Proxy 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 proxyDnsResolver(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/package.json

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

package/src/index.test.ts

@@ -173,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", () => {

package/src/index.ts

@@ -2,7 +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";
+import { aliDnsResolver, cloudflareDnsResolver, googleDnsResolver, proxyDnsResolver } from "./util/dns-resolvers";
 
 const { trace } = getLogger("index");
 
@@ -24,7 +24,12 @@ interface GenericObject {
 
 export type CustomDnsResolver = (domain: string) => Promise<IDNSQueryResponse>;
 
-export const defaultDnsResolvers: CustomDnsResolver[] = [googleDnsResolver, cloudflareDnsResolver, aliDnsResolver];
+export const defaultDnsResolvers: CustomDnsResolver[] = [
+  googleDnsResolver,
+  cloudflareDnsResolver,
+  proxyDnsResolver,
+  aliDnsResolver,
+];
 
 /**
  * Returns true for strings that are openattestation records

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/dns-resolvers.test.ts

@@ -3,6 +3,7 @@ import { http, HttpResponse } from "msw";
 import { aliDnsResolver } from "./ali-dns-resolver";
 import { cloudflareDnsResolver } from "./cloudflare-dns-resolver";
 import { googleDnsResolver } from "./google-dns-resolver";
+import { proxyDnsResolver } from "./proxy-dns-resolver";
 
 const emptyDnsJson = {
   Status: 0,
@@ -118,3 +119,37 @@ describe("aliDnsResolver", () => {
     await expect(aliDnsResolver("")).rejects.toThrow("Domain is required");
   });
 });
+
+describe("proxyDnsResolver", () => {
+  let server: SetupServerApi | undefined;
+
+  afterEach(() => {
+    server?.close();
+  });
+
+  test("requests proxy DNS JSON with name, TXT type, and encoded query", async () => {
+    server = setupServer(
+      http.get("https://dns.opencerts.io/resolve", ({ request }) => {
+        const url = new URL(request.url);
+        expect(url.searchParams.get("name")).toBe("oc example.test");
+        expect(url.searchParams.get("type")).toBe("TXT");
+        return HttpResponse.json(emptyDnsJson);
+      })
+    );
+    server.listen();
+
+    const out = await proxyDnsResolver("oc example.test");
+    expect(out).toMatchObject({ Status: 0, Answer: [] });
+  });
+
+  test("throws when proxy DNS returns non-2xx", async () => {
+    server = setupServer(http.get("https://dns.opencerts.io/resolve", () => new HttpResponse(null, { status: 502 })));
+    server.listen();
+
+    await expect(proxyDnsResolver("oc.example.test")).rejects.toThrow(/HTTP 502/);
+  });
+
+  test("throws when domain is empty", async () => {
+    await expect(proxyDnsResolver("")).rejects.toThrow("Domain is required");
+  });
+});

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

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

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

@@ -0,0 +1,28 @@
+import type { CustomDnsResolver, IDNSQueryResponse } from "../..";
+
+/** Server-side DoH proxy that forwards to Google/Cloudflare upstream — reachable from regions where direct access to those endpoints is blocked. */
+export const proxyDnsResolver: CustomDnsResolver = async (domain) => {
+  const url = new URL("https://dns.opencerts.io/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(`Proxy 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;
+};