@xyo-network/payload-plugins 7.0.3 → 7.1.0

package/dist/neutral/xns-record.mjs

@@ -0,0 +1,987 @@
+// src/modules/xns-record/Address/Payload.ts
+import {
+  AddressZod,
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import { asSchema as asSchema3, PayloadZodOfSchema as PayloadZodOfSchema3 } from "@xyo-network/sdk";
+import * as z4 from "zod/mini";
+
+// src/modules/xns-record/Domain/Domain.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@ariestools/sdk";
+import { asSchema, PayloadZodOfSchema } from "@xyo-network/sdk";
+import * as z from "zod/mini";
+var DomainSchema = asSchema("network.xyo.ns.domain", true);
+var TopLevelDomainZod = z.literal("xyo");
+var DomainFieldsZod = z.object({
+  /**
+   * The XNS domain of the record
+   */
+  domain: z.string(),
+  /**
+   * The Top-Level Domain of the domain
+   */
+  tld: TopLevelDomainZod
+});
+var DomainZod = z.extend(PayloadZodOfSchema(DomainSchema), { ...DomainFieldsZod.shape });
+var isDomain = zodIsFactory(DomainZod);
+var asDomain = zodAsFactory(DomainZod, "asDomain");
+var toDomain = zodToFactory(DomainZod, "toDomain");
+
+// src/modules/xns-record/Domain/DomainLease.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk";
+import * as z3 from "zod/mini";
+
+// src/modules/xns-record/Duration/Duration.ts
+import * as z2 from "zod/mini";
+var DurationFieldsZod = z2.object({
+  /**
+   * A timestamp that indicates the expiration time of the record
+   */
+  exp: z2.number(),
+  /**
+   * A timestamp that indicates the time before which the record is not valid
+   */
+  nbf: z2.number()
+});
+
+// src/modules/xns-record/Duration/validation/validateBoundWitness.ts
+import { BoundWitnessValidator } from "@xyo-network/sdk";
+var validateBoundWitness = async (recordBw, requiredSchemas = []) => {
+  if (requiredSchemas.some((requiredSchema) => !recordBw.payload_schemas.includes(requiredSchema))) return false;
+  const validator = new BoundWitnessValidator(recordBw);
+  const errors = await validator.validate();
+  return errors.length === 0;
+};
+
+// src/modules/xns-record/Duration/validation/validateBoundWitnessAndDuration.ts
+import { PayloadBuilder } from "@xyo-network/sdk";
+var validateBoundWitnessAndDuration = async (recordBw, recordPayload) => {
+  if (!await recordIsInBoundWitness(recordBw, recordPayload)) return false;
+  return recordIsTemporallyValidToBoundWitness(recordBw, recordPayload);
+};
+var recordIsInBoundWitness = async (recordBw, recordPayload) => {
+  const hash = await PayloadBuilder.dataHash(recordPayload);
+  return recordBw.payload_hashes.includes(hash);
+};
+var recordIsTemporallyValidToBoundWitness = (_recordBw, _recordPayload) => {
+  return true;
+};
+
+// src/modules/xns-record/Duration/validation/validateDuration.ts
+var validateDuration = (recordPayload) => {
+  return isWithinDelegatedTimeframe(recordPayload);
+};
+var isWithinDelegatedTimeframe = (recordPayload, now = Date.now()) => {
+  return recordPayload.nbf < now && now < recordPayload.exp;
+};
+
+// src/modules/xns-record/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/modules/xns-record/Domain/DomainLease.ts
+var DomainLeaseSchema = asSchema2("network.xyo.ns.domain.lease", true);
+var DomainLeaseFieldsZod = z3.object({
+  ...DomainFieldsZod.shape,
+  ...DurationFieldsZod.shape
+});
+var DomainLeaseZod = z3.extend(PayloadZodOfSchema2(DomainLeaseSchema), { ...DomainLeaseFieldsZod.shape });
+var isDomainLease = zodIsFactory2(DomainLeaseZod);
+var asDomainLease = zodAsFactory2(DomainLeaseZod, "asDomainLease");
+var toDomainLease = zodToFactory2(DomainLeaseZod, "toDomainLease");
+
+// src/modules/xns-record/Address/Payload.ts
+var AddressRecordSchema = asSchema3("network.xyo.ns.record.address", true);
+var AddressRecordFieldsZod = z4.object({
+  ...DomainFieldsZod.shape,
+  /**
+   * The address the record points to
+   */
+  address: z4.array(AddressZod)
+});
+var AddressRecordZod = z4.extend(PayloadZodOfSchema3(AddressRecordSchema), { ...AddressRecordFieldsZod.shape });
+var isAddressRecord = zodIsFactory3(AddressRecordZod);
+var asAddressRecord = zodAsFactory3(AddressRecordZod, "asAddressRecord");
+var toAddressRecord = zodToFactory3(AddressRecordZod, "toAddressRecord");
+
+// src/modules/xns-record/diviner/DomainLeaseEstimateDiviner/Schema.ts
+import { asSchema as asSchema4 } from "@xyo-network/sdk";
+var DomainLeaseEstimateDivinerValidationErrorDetailsSchema = asSchema4("network.xyo.diviner.ns.domain.registration.lease.estimate.validation.error.details", true);
+
+// src/modules/xns-record/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/modules/xns-record/diviner/DomainLeaseEstimateDiviner/ErrorDetails/Payload.ts
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema4 } from "@xyo-network/sdk";
+import * as z5 from "zod/mini";
+var ErrorDetailsZod = z5.object({
+  /**
+   * A string code indicating the error type.
+   */
+  code: z5.optional(z5.string()),
+  /**
+   * A human-readable explanation specific to this occurrence of the problem
+   */
+  detail: z5.optional(z5.string()),
+  /**
+   * A short, human-readable summary of the problem type.
+   */
+  title: z5.optional(z5.string())
+});
+var DomainLeaseEstimateDivinerValidationErrorDetailsZod = z5.extend(
+  PayloadZodOfSchema4(DomainLeaseEstimateDivinerValidationErrorDetailsSchema),
+  { ...ErrorDetailsZod.shape }
+);
+var baseIsDomainLeaseEstimateDivinerValidationErrorDetails = zodIsFactory4(DomainLeaseEstimateDivinerValidationErrorDetailsZod);
+var isDomainLeaseEstimateDivinerValidationErrorDetails = (x) => baseIsDomainLeaseEstimateDivinerValidationErrorDetails(x);
+var asDomainLeaseEstimateDivinerValidationErrorDetails = zodAsFactory4(
+  DomainLeaseEstimateDivinerValidationErrorDetailsZod,
+  "asDomainLeaseEstimateDivinerValidationErrorDetails"
+);
+var toDomainLeaseEstimateDivinerValidationErrorDetails = zodToFactory4(
+  DomainLeaseEstimateDivinerValidationErrorDetailsZod,
+  "toDomainLeaseEstimateDivinerValidationErrorDetails"
+);
+
+// src/modules/xns-record/diviner/lib/parseEstimatesFromArray.ts
+import { exists, findAs } from "@ariestools/sdk";
+import { asHashLeaseEstimate, HashLeaseEstimateSchema } from "@xyo-network/diviner-hash-lease";
+import { isBoundWitness, PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+
+// src/modules/xns-record/DomainRegistration/DomainRegistration.ts
+import {
+  AddressZod as AddressZod2,
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory5
+} from "@ariestools/sdk";
+import { asSchema as asSchema5, PayloadZodOfSchema as PayloadZodOfSchema5 } from "@xyo-network/sdk";
+import * as z6 from "zod/mini";
+var DomainRegistrationSchema = asSchema5(`${DomainSchema}.registration`, true);
+var DomainRegistrationFieldsZod = z6.object({
+  ...DomainFieldsZod.shape,
+  /**
+   * The registrant of the domain
+   */
+  registrant: z6.array(AddressZod2),
+  /**
+   * The registrar of the domain
+   */
+  registrar: z6.array(AddressZod2)
+});
+var DomainRegistrationZod = z6.extend(PayloadZodOfSchema5(DomainRegistrationSchema), { ...DomainRegistrationFieldsZod.shape });
+var isDomainRegistration = zodIsFactory5(DomainRegistrationZod);
+var asDomainRegistration = zodAsFactory5(DomainRegistrationZod, "asDomainRegistration");
+var toDomainRegistration = zodToFactory5(DomainRegistrationZod, "toDomainRegistration");
+
+// src/modules/xns-record/DomainRegistration/DomainRegistrationLease.ts
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@ariestools/sdk";
+import { asSchema as asSchema6, PayloadZodOfSchema as PayloadZodOfSchema6 } from "@xyo-network/sdk";
+import * as z7 from "zod/mini";
+var DomainRegistrationLeaseSchema = asSchema6(`${DomainRegistrationSchema}.lease`, true);
+var DomainRegistrationLeaseFieldsZod = z7.object({
+  ...DomainRegistrationFieldsZod.shape,
+  ...DurationFieldsZod.shape
+});
+var DomainRegistrationLeaseZod = z7.extend(PayloadZodOfSchema6(DomainRegistrationLeaseSchema), { ...DomainRegistrationLeaseFieldsZod.shape });
+var isDomainRegistrationLease = zodIsFactory6(DomainRegistrationLeaseZod);
+var asDomainRegistrationLease = zodAsFactory6(DomainRegistrationLeaseZod, "asDomainRegistrationLease");
+var toDomainRegistrationLease = zodToFactory6(DomainRegistrationLeaseZod, "toDomainRegistrationLease");
+
+// src/modules/xns-record/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 PayloadBuilder2.toAllHashMap(payloads);
+  return bws.map((bw) => {
+    const hashLeaseEstimate = getPayloadBySchemaFromBoundWitness(
+      bw,
+      HashLeaseEstimateSchema,
+      hashMap,
+      asHashLeaseEstimate
+    );
+    if (!hashLeaseEstimate) return;
+    const domainLease = getPayloadBySchemaFromBoundWitness(
+      bw,
+      DomainRegistrationLeaseSchema,
+      hashMap,
+      asDomainRegistrationLease
+    );
+    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/modules/xns-record/Dns/types/Answer.ts
+import * as z10 from "zod/mini";
+
+// src/modules/xns-record/Dns/types/Record.ts
+import * as z9 from "zod/mini";
+
+// src/modules/xns-record/Dns/types/ResourceRecord.ts
+import * as z8 from "zod/mini";
+var DNSResourceRecordTypeZod = z8.enum([
+  "A",
+  "NS",
+  "MD",
+  "MF",
+  "CNAME",
+  "SOA",
+  "MB",
+  "MG",
+  "MR",
+  "NULL",
+  "WKS",
+  "PTR",
+  "HINFO",
+  "MINFO",
+  "MX",
+  "TXT",
+  "RP",
+  "AFSDB",
+  "X25",
+  "ISDN",
+  "RT",
+  "NSAP",
+  "NSAP-PTR",
+  "SIG",
+  "KEY",
+  "PX",
+  "GPOS",
+  "AAAA",
+  "LOC",
+  "NXT",
+  "EID",
+  "NIMLOC",
+  "SRV",
+  "ATMA",
+  "NAPTR",
+  "KX",
+  "CERT",
+  "A6",
+  "DNAME",
+  "SINK",
+  "OPT",
+  "APL",
+  "DS",
+  "SSHFP",
+  "IPSECKEY",
+  "RRSIG",
+  "NSEC",
+  "DNSKEY",
+  "DHCID",
+  "NSEC3",
+  "NSEC3PARAM",
+  "TLSA",
+  "SMIMEA",
+  "HIP",
+  "NINFO",
+  "RKEY",
+  "TALINK",
+  "CDS",
+  "CDNSKEY",
+  "OPENPGPKEY",
+  "CSYNC",
+  "ZONEMD",
+  "SVCB",
+  "HTTPS",
+  "SPF",
+  "UINFO",
+  "UID",
+  "GID",
+  "UNSPEC",
+  "NID",
+  "L32",
+  "L64",
+  "LP",
+  "EUI48",
+  "EUI64",
+  "NXNAME",
+  "TKEY",
+  "TSIG",
+  "IXFR",
+  "AXFR",
+  "MAILB",
+  "MAILA",
+  "*",
+  "URI",
+  "CAA",
+  "AVC",
+  "DOA",
+  "AMTRELAY",
+  "RESINFO",
+  "WALLET",
+  "CLA",
+  "IPN",
+  "TA",
+  "DLV",
+  // Custom types here
+  "XYOA",
+  "XYOH"
+]);
+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 DNSResourceRecordTypeValueZod = z8.number();
+var findDNSResourceRecordTypesByValue = (value) => {
+  for (const key in DNSResourceRecordTypes) {
+    const resourceRecordType = key;
+    if (DNSResourceRecordTypes[resourceRecordType] === value) {
+      return resourceRecordType;
+    }
+  }
+  return void 0;
+};
+
+// src/modules/xns-record/Dns/types/Record.ts
+var DNSRecordZod = z9.object({
+  name: z9.string(),
+  // The domain name that was queried
+  type: DNSResourceRecordTypeValueZod,
+  // The record type (e.g., 1 for A record)
+  TTL: z9.number(),
+  // Time to Live (how long the record can be cached)
+  data: z9.string()
+  // The actual data, such as an IP address or TXT record
+});
+
+// src/modules/xns-record/Dns/types/Answer.ts
+var DNSAnswerZod = z10.extend(DNSRecordZod, { class: z10.optional(z10.number()) });
+
+// src/modules/xns-record/Dns/types/Header.ts
+import * as z13 from "zod/mini";
+
+// src/modules/xns-record/Dns/types/OperationCodes.ts
+import * as z11 from "zod/mini";
+var DNSQueryOpcodeZod = z11.union([
+  z11.literal(0),
+  z11.literal(1),
+  z11.literal(2),
+  z11.literal(4),
+  z11.literal(5),
+  z11.literal(6)
+]);
+var DNSQueryOpcodeNameZod = z11.enum(["QUERY", "IQUERY", "STATUS", "NOTIFY", "UPDATE", "DSO"]);
+var DNSQueryOpcodes = {
+  QUERY: 0,
+  IQUERY: 1,
+  STATUS: 2,
+  NOTIFY: 4,
+  UPDATE: 5,
+  DSO: 6
+};
+
+// src/modules/xns-record/Dns/types/ResponseCodes.ts
+import * as z12 from "zod/mini";
+var DNSRcodeZod = z12.union([
+  z12.literal(0),
+  z12.literal(1),
+  z12.literal(2),
+  z12.literal(3),
+  z12.literal(4),
+  z12.literal(5),
+  z12.literal(6),
+  z12.literal(7),
+  z12.literal(8),
+  z12.literal(9),
+  z12.literal(10),
+  z12.literal(16),
+  z12.literal(17),
+  z12.literal(18)
+]);
+var DNSRcodeNameZod = z12.enum([
+  "NOERROR",
+  "FORMERR",
+  "SERVFAIL",
+  "NXDOMAIN",
+  "NOTIMP",
+  "REFUSED",
+  "YXDOMAIN",
+  "YXRRSET",
+  "NXRRSET",
+  "NOTAUTH",
+  "NOTZONE",
+  "BADSIG",
+  "BADKEY",
+  "BADTIME"
+]);
+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/modules/xns-record/Dns/types/Header.ts
+var NumericBooleanZod = z13.union([z13.literal(0), z13.literal(1), z13.literal(true), z13.literal(false)]);
+var NumericBooleanFalsyZod = z13.union([z13.literal(0), z13.literal(false)]);
+var NumericBooleanTruthyZod = z13.union([z13.literal(1), z13.literal(true)]);
+var DNSHeaderZod = z13.object({
+  /**
+   * Transaction ID, typically a random number. Integer whose value is 0 to 65535
+   */
+  ID: z13.optional(z13.number()),
+  /**
+   * Query/Response Flag (0 = Query, 1 = Response)
+   */
+  QR: z13.optional(NumericBooleanZod),
+  /**
+   * Operation Code (0 for standard query)
+   */
+  Opcode: z13.optional(DNSQueryOpcodeZod),
+  /**
+   * Authoritative Answer (set in response)
+   */
+  AA: z13.optional(NumericBooleanZod),
+  /**
+   * Truncated Flag
+   */
+  TC: z13.optional(NumericBooleanZod),
+  // Truncation
+  /**
+   * Recursion Desired
+   */
+  RD: z13.optional(NumericBooleanZod),
+  // Recursion Desired (set in query)
+  /**
+   * Response Code (0 for no error, non-0 for errors)
+   */
+  RCODE: z13.optional(DNSRcodeZod),
+  /**
+   * Number of questions in the query (usually 1)
+   */
+  QDCOUNT: z13.optional(z13.number()),
+  /**
+   * Number of answer records in the response
+   */
+  ANCOUNT: z13.optional(z13.number()),
+  /**
+   * Number of authority records in the response
+   */
+  NSCOUNT: z13.optional(z13.number()),
+  /**
+   * Number of additional records in the response
+   */
+  ARCOUNT: z13.optional(z13.number())
+});
+var DNSRequestHeaderZod = z13.extend(DNSHeaderZod, {
+  QR: NumericBooleanFalsyZod,
+  // Query/Response Flag (0 = Query)
+  Opcode: DNSQueryOpcodeZod,
+  // Operation Code (0 for standard query)
+  AA: NumericBooleanFalsyZod,
+  // Authoritative Answer (0 in query)
+  TC: NumericBooleanFalsyZod,
+  // Truncation (0 for non-truncated)
+  RCODE: z13.literal(DNSRcodes.NOERROR),
+  // Response Code (always 0 in query)
+  ANCOUNT: z13.literal(0),
+  // Number of answer records (always 0 in query)
+  NSCOUNT: z13.literal(0),
+  // Number of authority records (always 0 in query)
+  ARCOUNT: z13.literal(0)
+  // Number of additional records (always 0 in query)
+});
+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
+};
+var DNSResponseHeaderZod = z13.extend(DNSHeaderZod, {
+  QR: NumericBooleanTruthyZod,
+  // Query/Response Flag (1 = Response)
+  Opcode: DNSQueryOpcodeZod,
+  // Operation Code (0 for standard query)
+  AA: NumericBooleanZod,
+  // Authoritative Answer (1 if the response is authoritative)
+  TC: NumericBooleanZod,
+  // Truncation (1 if the message is truncated)
+  RA: NumericBooleanZod
+  // Recursion Available (1 if the server supports recursion)
+});
+
+// src/modules/xns-record/Dns/types/Request.ts
+import * as z14 from "zod/mini";
+var DNSQuestionZod = z14.object({
+  name: z14.string(),
+  // The domain name that was queried
+  type: DNSResourceRecordTypeValueZod,
+  // The record type (e.g., 1 for A record)
+  class: z14.optional(z14.number())
+  // Query Class (typically 1 for IN - Internet)
+});
+var DNSRequestFieldsZod = z14.extend(DNSRequestHeaderZod, { Question: z14.array(DNSQuestionZod) });
+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/modules/xns-record/Dns/types/Response.ts
+import * as z15 from "zod/mini";
+var DNSResponseFieldsZod = z15.extend(DNSResponseHeaderZod, {
+  Question: z15.array(DNSQuestionZod),
+  // The questions that were asked
+  Answer: z15.array(DNSAnswerZod),
+  // Reusing DNSAnswer for the Answer Section
+  Authority: z15.optional(z15.array(DNSRecordZod)),
+  Additional: z15.optional(z15.array(DNSRecordZod))
+});
+
+// src/modules/xns-record/Dns/Witness/Config.ts
+import { asSchema as asSchema8 } from "@xyo-network/sdk";
+
+// src/modules/xns-record/Dns/Witness/Schema.ts
+import { asSchema as asSchema7 } from "@xyo-network/sdk";
+var DNSSchema = asSchema7("network.xyo.dns", true);
+
+// src/modules/xns-record/Dns/Witness/Config.ts
+var DNSWitnessConfigSchema = asSchema8(`${DNSSchema}.witness.config`, true);
+
+// src/modules/xns-record/Dns/Witness/Payload/Request.ts
+import {
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory7
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema7 } from "@xyo-network/sdk";
+import * as z16 from "zod/mini";
+var DNSRequestZod = z16.extend(PayloadZodOfSchema7(DNSSchema), { ...DNSRequestFieldsZod.shape });
+var isDNSRequest = zodIsFactory7(DNSRequestZod);
+var asDNSRequest = zodAsFactory7(DNSRequestZod, "asDNSRequest");
+var toDNSRequest = zodToFactory7(DNSRequestZod, "toDNSRequest");
+var getDnsRequestFor = (domain, type = DNSResourceRecordTypes.A) => {
+  return { ...getRequestFor(domain, type), schema: DNSSchema };
+};
+
+// src/modules/xns-record/Dns/Witness/Payload/Response.ts
+import {
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory8
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema8 } from "@xyo-network/sdk";
+import * as z17 from "zod/mini";
+var DNSResponseZod = z17.extend(PayloadZodOfSchema8(DNSSchema), { ...DNSResponseFieldsZod.shape });
+var isDNSResponse = zodIsFactory8(DNSResponseZod);
+var asDNSResponse = zodAsFactory8(DNSResponseZod, "asDNSResponse");
+var toDNSResponse = zodToFactory8(DNSResponseZod, "toDNSResponse");
+
+// src/modules/xns-record/Hash/Payload.ts
+import {
+  HashZod,
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory9,
+  zodToFactory as zodToFactory9
+} from "@ariestools/sdk";
+import { asSchema as asSchema9, PayloadZodOfSchema as PayloadZodOfSchema9 } from "@xyo-network/sdk";
+import * as z18 from "zod/mini";
+var HashRecordSchema = asSchema9("network.xyo.ns.record.hash", true);
+var HashRecordFieldsZod = z18.object({
+  ...DomainFieldsZod.shape,
+  /**
+   * The hash the record points to
+   */
+  hash: z18.array(HashZod)
+});
+var HashRecordZod = z18.extend(PayloadZodOfSchema9(HashRecordSchema), { ...HashRecordFieldsZod.shape });
+var isHashRecord = zodIsFactory9(HashRecordZod);
+var asHashRecord = zodAsFactory9(HashRecordZod, "asHashRecord");
+var toHashRecord = zodToFactory9(HashRecordZod, "toHashRecord");
+export {
+  AddressRecordFieldsZod,
+  AddressRecordSchema,
+  AddressRecordZod,
+  DNSAnswerZod,
+  DNSHeaderZod,
+  DNSQueryOpcodeNameZod,
+  DNSQueryOpcodeZod,
+  DNSQueryOpcodes,
+  DNSQuestionZod,
+  DNSRcodeNameZod,
+  DNSRcodeZod,
+  DNSRcodes,
+  DNSRecordZod,
+  DNSRequestFieldsZod,
+  DNSRequestHeaderZod,
+  DNSRequestZod,
+  DNSResourceRecordTypeValueZod,
+  DNSResourceRecordTypeZod,
+  DNSResourceRecordTypes,
+  DNSResponseFieldsZod,
+  DNSResponseHeaderZod,
+  DNSResponseZod,
+  DNSSchema,
+  DNSWitnessConfigSchema,
+  DomainFieldsZod,
+  DomainLeaseEstimateDivinerErrorDetailsDictionary,
+  DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+  DomainLeaseEstimateDivinerValidationErrorDetailsZod,
+  DomainLeaseFieldsZod,
+  DomainLeaseSchema,
+  DomainLeaseZod,
+  DomainRegistrationFieldsZod,
+  DomainRegistrationLeaseFieldsZod,
+  DomainRegistrationLeaseSchema,
+  DomainRegistrationLeaseZod,
+  DomainRegistrationSchema,
+  DomainRegistrationZod,
+  DomainSchema,
+  DomainZod,
+  DurationFieldsZod,
+  ErrorDetailsZod,
+  HashRecordFieldsZod,
+  HashRecordSchema,
+  HashRecordZod,
+  NumericBooleanFalsyZod,
+  NumericBooleanTruthyZod,
+  NumericBooleanZod,
+  StandardRequestHeader,
+  TopLevelDomainZod,
+  asAddressRecord,
+  asDNSRequest,
+  asDNSResponse,
+  asDomain,
+  asDomainLease,
+  asDomainLeaseEstimateDivinerValidationErrorDetails,
+  asDomainRegistration,
+  asDomainRegistrationLease,
+  asHashRecord,
+  findDNSResourceRecordTypesByValue,
+  getDnsRequestFor,
+  getRandomId,
+  getRequestFor,
+  isAddressRecord,
+  isDNSRequest,
+  isDNSResponse,
+  isDomain,
+  isDomainLease,
+  isDomainLeaseEstimateDivinerValidationErrorDetails,
+  isDomainRegistration,
+  isDomainRegistrationLease,
+  isHashRecord,
+  isWithinDelegatedTimeframe,
+  parseEstimatesFromArray,
+  toAddressRecord,
+  toDNSRequest,
+  toDNSResponse,
+  toDomain,
+  toDomainLease,
+  toDomainLeaseEstimateDivinerValidationErrorDetails,
+  toDomainRegistration,
+  toDomainRegistrationLease,
+  toHashRecord,
+  validateBoundWitnessWithDuration,
+  validateDuration
+};
+//# sourceMappingURL=xns-record.mjs.map