@xyo-network/xns-record-payload-plugins 5.3.2 → 5.3.4

package/dist/browser/index.mjs

@@ -0,0 +1,592 @@
+// src/Address/Payload.ts
+import { asSchema, isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var AddressRecordSchema = asSchema("network.xyo.ns.record.address", true);
+var isAddressRecord = isPayloadOfSchemaType(AddressRecordSchema);
+
+// src/diviner/DomainLeaseEstimateDiviner/Schema.ts
+import { asSchema as asSchema2 } from "@xyo-network/payload-model";
+var DomainLeaseEstimateDivinerValidationErrorDetailsSchema = asSchema2("network.xyo.diviner.ns.domain.registration.lease.estimate.validation.error.details", true);
+
+// src/diviner/DomainLeaseEstimateDiviner/ErrorDetails/ErrorCodes.ts
+var DomainLeaseEstimateDivinerErrorDetailsDictionary = {
+  0: {
+    code: "0",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Success"
+  },
+  1: {
+    code: "1",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Invalid casing"
+  },
+  2: {
+    code: "2",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Invalid coin signature"
+  },
+  3: {
+    code: "3",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Invalid length"
+  },
+  4: {
+    code: "4",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Invalid name"
+  },
+  5: {
+    code: "5",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Reserved fragment"
+  },
+  6: {
+    code: "6",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Reserved name"
+  },
+  7: {
+    code: "7",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Reserved string"
+  },
+  8: {
+    code: "8",
+    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+    title: "Invalid TLD"
+  }
+};
+
+// src/diviner/DomainLeaseEstimateDiviner/ErrorDetails/Payload.ts
+import { isPayloadOfSchemaType as isPayloadOfSchemaType2, isPayloadOfSchemaTypeWithSources } from "@xyo-network/payload-model";
+var isDomainLeaseEstimateDivinerValidationErrorDetails = isPayloadOfSchemaType2(
+  DomainLeaseEstimateDivinerValidationErrorDetailsSchema
+);
+var isDomainLeaseEstimateDivinerValidationErrorDetailsWithSources = isPayloadOfSchemaTypeWithSources(DomainLeaseEstimateDivinerValidationErrorDetailsSchema);
+
+// src/diviner/lib/parseEstimatesFromArray.ts
+import { exists, findAs } from "@xylabs/sdk-js";
+import { isBoundWitness } from "@xyo-network/boundwitness-model";
+import { asHashLeaseEstimate, HashLeaseEstimateSchema } from "@xyo-network/diviner-hash-lease";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
+
+// src/DomainRegistration/DomainRegistration.ts
+import { AsObjectFactory as AsObjectFactory3 } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema5,
+  isPayloadOfSchemaType as isPayloadOfSchemaType5,
+  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources4
+} from "@xyo-network/payload-model";
+
+// src/Domain/Domain.ts
+import { AsObjectFactory } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema3,
+  isPayloadOfSchemaType as isPayloadOfSchemaType3,
+  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources2
+} from "@xyo-network/payload-model";
+var DomainSchema = asSchema3("network.xyo.ns.domain", true);
+var isDomain = isPayloadOfSchemaType3(DomainSchema);
+var asDomain = AsObjectFactory.create(isDomain);
+var asOptionalDomain = AsObjectFactory.createOptional(isDomain);
+var isDomainWithSources = isPayloadOfSchemaTypeWithSources2(DomainSchema);
+var asDomainWithSources = AsObjectFactory.create(isDomainWithSources);
+var asOptionalDomainWithSources = AsObjectFactory.createOptional(isDomainWithSources);
+
+// src/Domain/DomainLease.ts
+import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema4,
+  isPayloadOfSchemaType as isPayloadOfSchemaType4,
+  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources3
+} from "@xyo-network/payload-model";
+var DomainLeaseSchema = asSchema4("network.xyo.ns.domain.lease", true);
+var isDomainLease = isPayloadOfSchemaType4(DomainLeaseSchema);
+var asDomainLease = AsObjectFactory2.create(isDomainLease);
+var asOptionalDomainLease = AsObjectFactory2.createOptional(isDomainLease);
+var isDomainLeaseWithSources = isPayloadOfSchemaTypeWithSources3(DomainLeaseSchema);
+var asDomainLeaseWithSources = AsObjectFactory2.create(isDomainLeaseWithSources);
+var asOptionalDomainLeaseWithSources = AsObjectFactory2.createOptional(isDomainLeaseWithSources);
+
+// src/DomainRegistration/DomainRegistration.ts
+var DomainRegistrationSchema = asSchema5(`${DomainSchema}.registration`, true);
+var isDomainRegistration = isPayloadOfSchemaType5(DomainRegistrationSchema);
+var asDomainRegistration = AsObjectFactory3.create(isDomainRegistration);
+var asOptionalDomainRegistration = AsObjectFactory3.createOptional(isDomainRegistration);
+var isDomainRegistrationWithSources = isPayloadOfSchemaTypeWithSources4(DomainRegistrationSchema);
+var asDomainRegistrationWithSources = AsObjectFactory3.create(isDomainRegistrationWithSources);
+var asOptionalDomainRegistrationWithSources = AsObjectFactory3.createOptional(isDomainRegistrationWithSources);
+
+// src/DomainRegistration/DomainRegistrationLease.ts
+import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema6,
+  isPayloadOfSchemaType as isPayloadOfSchemaType6,
+  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources5
+} from "@xyo-network/payload-model";
+var DomainRegistrationLeaseSchema = asSchema6(`${DomainRegistrationSchema}.lease`, true);
+var isDomainRegistrationLease = isPayloadOfSchemaType6(DomainRegistrationLeaseSchema);
+var asDomainRegistrationLease = AsObjectFactory4.create(isDomainRegistrationLease);
+var asOptionalDomainRegistrationLease = AsObjectFactory4.createOptional(isDomainRegistrationLease);
+var isDomainRegistrationLeaseWithSources = isPayloadOfSchemaTypeWithSources5(DomainRegistrationLeaseSchema);
+var asDomainRegistrationLeaseWithSources = AsObjectFactory4.create(isDomainRegistrationLeaseWithSources);
+var asOptionalDomainRegistrationLeaseWithSources = AsObjectFactory4.createOptional(isDomainRegistrationLeaseWithSources);
+var isDomainRegistrationLeaseSources = isDomainRegistrationLeaseWithSources;
+
+// src/diviner/lib/parseEstimatesFromArray.ts
+var parseEstimatesFromArray = async (payloads) => {
+  if (!payloads) return [];
+  const bws = payloads.filter(isBoundWitness).filter(hasEstimatePayloads) ?? [];
+  if (bws.length === 0) return [];
+  const hashMap = await PayloadBuilder.toAllHashMap(payloads);
+  return bws.map((bw) => {
+    const hashLeaseEstimate = getPayloadBySchemaFromBoundWitness(
+      bw,
+      HashLeaseEstimateSchema,
+      hashMap,
+      asHashLeaseEstimate
+    );
+    if (!hashLeaseEstimate) return;
+    const domainLease = getPayloadBySchemaFromBoundWitness(
+      bw,
+      DomainRegistrationLeaseSchema,
+      hashMap,
+      asDomainRegistrationLeaseWithSources
+    );
+    if (!domainLease) return;
+    return [bw, hashLeaseEstimate, domainLease];
+  }).filter(exists);
+};
+var hasEstimatePayloads = (bw) => {
+  return bw.payload_schemas.includes(DomainRegistrationLeaseSchema) && bw.payload_schemas.includes(HashLeaseEstimateSchema);
+};
+var getPayloadBySchemaFromBoundWitness = (bw, schema, hashMap, identity) => {
+  const schemaIndex = bw.payload_schemas.indexOf(schema);
+  if (schemaIndex === -1) return;
+  const hash = bw.payload_hashes[schemaIndex];
+  return findAs([hashMap[hash]], identity);
+};
+
+// src/DNS/types/OperationCodes.ts
+var DNSQueryOpcodes = {
+  QUERY: 0,
+  IQUERY: 1,
+  STATUS: 2,
+  NOTIFY: 4,
+  UPDATE: 5,
+  DSO: 6
+};
+
+// src/DNS/types/ResponseCodes.ts
+var DNSRcodes = {
+  NOERROR: 0,
+  FORMERR: 1,
+  SERVFAIL: 2,
+  NXDOMAIN: 3,
+  NOTIMP: 4,
+  REFUSED: 5,
+  YXDOMAIN: 6,
+  YXRRSET: 7,
+  NXRRSET: 8,
+  NOTAUTH: 9,
+  NOTZONE: 10,
+  BADSIG: 16,
+  BADKEY: 17,
+  BADTIME: 18
+};
+
+// src/DNS/types/Header.ts
+var StandardRequestHeader = {
+  ID: 0,
+  QR: 0,
+  // Query/Response Flag (0 = Query)
+  Opcode: DNSQueryOpcodes.QUERY,
+  // Operation Code (0 for standard query)
+  AA: 0,
+  // Authoritative Answer (0 in query)
+  TC: 0,
+  // Truncation (0 for non-truncated)
+  RD: 1,
+  // Recursion Desired (1 if recursion is requested)
+  RCODE: DNSRcodes.NOERROR,
+  // Response Code (always 0 in query)
+  QDCOUNT: 1,
+  ANCOUNT: 0,
+  NSCOUNT: 0,
+  ARCOUNT: 0
+};
+
+// src/DNS/types/ResourceRecord.ts
+var DNSResourceRecordTypes = {
+  "A": 1,
+  // a host address
+  "NS": 2,
+  // an authoritative name server
+  "MD": 3,
+  // a mail destination (OBSOLETE - use MX)
+  "MF": 4,
+  // a mail forwarder (OBSOLETE - use MX)
+  "CNAME": 5,
+  // the canonical name for an alias
+  "SOA": 6,
+  // marks the start of a zone of authority
+  "MB": 7,
+  // a mailbox domain name (EXPERIMENTAL)
+  "MG": 8,
+  // a mail group member (EXPERIMENTAL)
+  "MR": 9,
+  // a mail rename domain name (EXPERIMENTAL)
+  "NULL": 10,
+  // a null RR (EXPERIMENTAL)
+  "WKS": 11,
+  // a well known service description
+  "PTR": 12,
+  // a domain name pointer
+  "HINFO": 13,
+  // host information
+  "MINFO": 14,
+  // mailbox or mail list information
+  "MX": 15,
+  // mail exchange
+  "TXT": 16,
+  // text strings
+  "RP": 17,
+  // for Responsible Person
+  "AFSDB": 18,
+  // for AFS Data Base location
+  "X25": 19,
+  // for X.25 PSDN address
+  "ISDN": 20,
+  // for ISDN address
+  "RT": 21,
+  // for Route Through
+  "NSAP": 22,
+  // for NSAP address, NSAP style A record (DEPRECATED)
+  "NSAP-PTR": 23,
+  // for domain name pointer, NSAP style (DEPRECATED)
+  "SIG": 24,
+  // for security signature
+  "KEY": 25,
+  // for security key
+  "PX": 26,
+  // X.400 mail mapping information
+  "GPOS": 27,
+  // Geographical Position
+  "AAAA": 28,
+  // IP6 Address
+  "LOC": 29,
+  // Location Information
+  "NXT": 30,
+  // Next Domain (OBSOLETE)
+  "EID": 31,
+  // Endpoint Identifier
+  "NIMLOC": 32,
+  // Nimrod Locator
+  "SRV": 33,
+  // Server Selection
+  "ATMA": 34,
+  // ATM Address
+  "NAPTR": 35,
+  // Naming Authority Pointer
+  "KX": 36,
+  // Key Exchanger
+  "CERT": 37,
+  // CERT
+  "A6": 38,
+  // A6 (OBSOLETE - use AAAA)
+  "DNAME": 39,
+  // DNAME
+  "SINK": 40,
+  // SINK
+  "OPT": 41,
+  // OPT
+  "APL": 42,
+  // APL
+  "DS": 43,
+  // Delegation Signer
+  "SSHFP": 44,
+  // SSH Key Fingerprint
+  "IPSECKEY": 45,
+  // IPSECKEY
+  "RRSIG": 46,
+  // RRSIG
+  "NSEC": 47,
+  // NSEC
+  "DNSKEY": 48,
+  // DNSKEY
+  "DHCID": 49,
+  // DHCID
+  "NSEC3": 50,
+  // NSEC3
+  "NSEC3PARAM": 51,
+  // NSEC3PARAM
+  "TLSA": 52,
+  // TLSA
+  "SMIMEA": 53,
+  // S/MIME cert association
+  "HIP": 55,
+  // Host Identity Protocol
+  "NINFO": 56,
+  // NINFO
+  "RKEY": 57,
+  // RKEY
+  "TALINK": 58,
+  // Trust Anchor LINK
+  "CDS": 59,
+  // Child DS
+  "CDNSKEY": 60,
+  // DNSKEY(s) the Child wants reflected in DS
+  "OPENPGPKEY": 61,
+  // OpenPGP Key
+  "CSYNC": 62,
+  // Child-To-Parent Synchronization
+  "ZONEMD": 63,
+  // Message Digest Over Zone Data
+  "SVCB": 64,
+  // General-purpose service binding
+  "HTTPS": 65,
+  // SVCB-compatible type for use with HTTP
+  "SPF": 99,
+  "UINFO": 100,
+  "UID": 101,
+  "GID": 102,
+  "UNSPEC": 103,
+  "NID": 104,
+  "L32": 105,
+  "L64": 106,
+  "LP": 107,
+  "EUI48": 108,
+  // an EUI-48 address
+  "EUI64": 109,
+  // an EUI-64 address
+  "NXNAME": 128,
+  // NXDOMAIN indicator for Compact Denial of Existence
+  "TKEY": 249,
+  // Transaction Key
+  "TSIG": 250,
+  // Transaction Signature
+  "IXFR": 251,
+  // incremental transfer
+  "AXFR": 252,
+  // transfer of an entire zone
+  "MAILB": 253,
+  // mailbox-related RRs (MB, MG or MR)
+  "MAILA": 254,
+  // mail agent RRs (OBSOLETE - see MX)
+  "*": 255,
+  // A request for some or all records the server has available
+  "URI": 256,
+  // URI
+  "CAA": 257,
+  // Certification Authority Restriction
+  "AVC": 258,
+  // Application Visibility and Control
+  "DOA": 259,
+  // Digital Object Architecture
+  "AMTRELAY": 260,
+  // Automatic Multicast Tunneling Relay
+  "RESINFO": 261,
+  // Resolver Information as Key/Value Pairs
+  "WALLET": 262,
+  // Public wallet address
+  "CLA": 263,
+  // BP Convergence Layer Adapter
+  "IPN": 264,
+  // BP Node Number
+  "TA": 32768,
+  // DNSSEC Trust Authorities
+  "DLV": 32769,
+  // DNSSEC Lookaside Validation (OBSOLETE)
+  // Custom types here chosen within the Private Use Range
+  // https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4
+  // https://www.rfc-editor.org/rfc/rfc5226
+  // as, per the RFC, the Private Use Range is reserved
+  // "For private or local use only, with the type and
+  // purpose defined by the local site.  No attempt is made to
+  // prevent multiple sites from using the same value in
+  // different (and incompatible) ways.  There is no need for
+  // IANA to review such assignments (since IANA does not record
+  // them) and assignments are not generally useful for broad
+  // interoperability.  It is the responsibility of the sites
+  // making use of the Private Use range to ensure that no
+  // conflicts occur (within the intended scope of use)."
+  // If we want to apply for a custom reserved code later
+  // on, once the usage is proven enough we can absolutely
+  // do that.
+  "XYOA": 65432,
+  // XYO Address
+  "XYOH": 65433
+  // XYO Hash
+};
+var findDNSResourceRecordTypesByValue = (value) => {
+  for (const key in DNSResourceRecordTypes) {
+    const resourceRecordType = key;
+    if (DNSResourceRecordTypes[resourceRecordType] === value) {
+      return resourceRecordType;
+    }
+  }
+  return void 0;
+};
+
+// src/DNS/types/Request.ts
+var getRequestFor = (domain, type = DNSResourceRecordTypes.A) => {
+  return {
+    ...StandardRequestHeader,
+    ID: getRandomId(),
+    Question: [{
+      name: domain,
+      type,
+      class: 1
+    }]
+  };
+};
+var getRandomId = () => {
+  return Math.floor(Math.random() * 65536);
+};
+
+// src/DNS/Witness/Config.ts
+import { asSchema as asSchema8 } from "@xyo-network/payload-model";
+
+// src/DNS/Witness/Schema.ts
+import { asSchema as asSchema7 } from "@xyo-network/payload-model";
+var DNSSchema = asSchema7("network.xyo.dns", true);
+
+// src/DNS/Witness/Config.ts
+var DNSWitnessConfigSchema = asSchema8(`${DNSSchema}.witness.config`, true);
+
+// src/DNS/Witness/Payload/Request.ts
+import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
+import {
+  isPayloadOfSchemaType as isPayloadOfSchemaType7,
+  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources6
+} from "@xyo-network/payload-model";
+var isDNSRequest = isPayloadOfSchemaType7(DNSSchema);
+var asDNSRequest = AsObjectFactory5.create(isDNSRequest);
+var asOptionalDNSRequest = AsObjectFactory5.createOptional(isDNSRequest);
+var isDNSRequestWithSources = isPayloadOfSchemaTypeWithSources6(DNSSchema);
+var asDNSRequestWithSources = AsObjectFactory5.create(isDNSRequestWithSources);
+var asOptionalDNSRequestWithSources = AsObjectFactory5.createOptional(isDNSRequestWithSources);
+var getDnsRequestFor = (domain, type = DNSResourceRecordTypes.A) => {
+  return { ...getRequestFor(domain, type), schema: DNSSchema };
+};
+
+// src/DNS/Witness/Payload/Response.ts
+import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
+import {
+  isPayloadOfSchemaType as isPayloadOfSchemaType8,
+  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources7
+} from "@xyo-network/payload-model";
+var isDNSResponse = isPayloadOfSchemaType8(DNSSchema);
+var asDNSResponse = AsObjectFactory6.create(isDNSResponse);
+var asOptionalDNSResponse = AsObjectFactory6.createOptional(isDNSResponse);
+var isDNSResponseWithSources = isPayloadOfSchemaTypeWithSources7(DNSSchema);
+var asDNSResponseWithSources = AsObjectFactory6.create(isDNSResponseWithSources);
+var asOptionalDNSResponseWithSources = AsObjectFactory6.createOptional(isDNSResponseWithSources);
+
+// src/Duration/validation/validateBoundWitness.ts
+import { BoundWitnessValidator } from "@xyo-network/boundwitness-validator";
+var validateBoundWitness = async (recordBw, requiredSchemas = []) => {
+  if (!requiredSchemas.every((requiredSchema) => recordBw.payload_schemas.includes(requiredSchema))) return false;
+  const validator = new BoundWitnessValidator(recordBw);
+  const errors = await validator.validate();
+  return errors.length === 0;
+};
+
+// src/Duration/validation/validateBoundWitnessAndDuration.ts
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+var validateBoundWitnessAndDuration = async (recordBw, recordPayload) => {
+  if (!await recordIsInBoundWitness(recordBw, recordPayload)) return false;
+  return recordIsTemporallyValidToBoundWitness(recordBw, recordPayload);
+};
+var recordIsInBoundWitness = async (recordBw, recordPayload) => {
+  const hash = await PayloadBuilder2.dataHash(recordPayload);
+  return recordBw.payload_hashes.includes(hash);
+};
+var recordIsTemporallyValidToBoundWitness = (_recordBw, _recordPayload) => {
+  return true;
+};
+
+// src/Duration/validation/validateDuration.ts
+var validateDuration = (recordPayload) => {
+  return isWithinDelegatedTimeframe(recordPayload);
+};
+var isWithinDelegatedTimeframe = (recordPayload, now = Date.now()) => {
+  return recordPayload.nbf < now && now < recordPayload.exp;
+};
+
+// src/Duration/validation/validateBoundWitnessWithDuration.ts
+var validateBoundWitnessWithDuration = async (recordBw, recordPayload) => {
+  if (!await validateBoundWitness(recordBw, [recordPayload.schema])) return false;
+  if (!validateDuration(recordPayload)) return false;
+  return await validateBoundWitnessAndDuration(recordBw, recordPayload);
+};
+
+// src/Hash/Payload.ts
+import { asSchema as asSchema9, isPayloadOfSchemaType as isPayloadOfSchemaType9 } from "@xyo-network/payload-model";
+var HashRecordSchema = asSchema9("network.xyo.ns.record.hash", true);
+var isHashRecord = isPayloadOfSchemaType9(HashRecordSchema);
+export {
+  AddressRecordSchema,
+  DNSQueryOpcodes,
+  DNSRcodes,
+  DNSResourceRecordTypes,
+  DNSSchema,
+  DNSWitnessConfigSchema,
+  DomainLeaseEstimateDivinerErrorDetailsDictionary,
+  DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+  DomainLeaseSchema,
+  DomainRegistrationLeaseSchema,
+  DomainRegistrationSchema,
+  DomainSchema,
+  HashRecordSchema,
+  StandardRequestHeader,
+  asDNSRequest,
+  asDNSRequestWithSources,
+  asDNSResponse,
+  asDNSResponseWithSources,
+  asDomain,
+  asDomainLease,
+  asDomainLeaseWithSources,
+  asDomainRegistration,
+  asDomainRegistrationLease,
+  asDomainRegistrationLeaseWithSources,
+  asDomainRegistrationWithSources,
+  asDomainWithSources,
+  asOptionalDNSRequest,
+  asOptionalDNSRequestWithSources,
+  asOptionalDNSResponse,
+  asOptionalDNSResponseWithSources,
+  asOptionalDomain,
+  asOptionalDomainLease,
+  asOptionalDomainLeaseWithSources,
+  asOptionalDomainRegistration,
+  asOptionalDomainRegistrationLease,
+  asOptionalDomainRegistrationLeaseWithSources,
+  asOptionalDomainRegistrationWithSources,
+  asOptionalDomainWithSources,
+  findDNSResourceRecordTypesByValue,
+  getDnsRequestFor,
+  getRandomId,
+  getRequestFor,
+  isAddressRecord,
+  isDNSRequest,
+  isDNSRequestWithSources,
+  isDNSResponse,
+  isDNSResponseWithSources,
+  isDomain,
+  isDomainLease,
+  isDomainLeaseEstimateDivinerValidationErrorDetails,
+  isDomainLeaseEstimateDivinerValidationErrorDetailsWithSources,
+  isDomainLeaseWithSources,
+  isDomainRegistration,
+  isDomainRegistrationLease,
+  isDomainRegistrationLeaseSources,
+  isDomainRegistrationLeaseWithSources,
+  isDomainRegistrationWithSources,
+  isDomainWithSources,
+  isHashRecord,
+  isWithinDelegatedTimeframe,
+  parseEstimatesFromArray,
+  validateBoundWitnessWithDuration,
+  validateDuration
+};
+//# sourceMappingURL=index.mjs.map