@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/cjs/contracts/universalResolver.js

@@ -1,4 +1,25 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const UniversalResolver__factory_1 = require("../generated/factories/UniversalResolver__factory");
-exports.default = (provider, address) => UniversalResolver__factory_1.UniversalResolver__factory.connect(address, provider);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var universalResolver_exports = {};
+__export(universalResolver_exports, {
+  default: () => universalResolver_default
+});
+module.exports = __toCommonJS(universalResolver_exports);
+var import_UniversalResolver_factory = require("../generated/factories/UniversalResolver__factory");
+var universalResolver_default = (provider, address) => import_UniversalResolver_factory.UniversalResolver__factory.connect(address, provider);

package/dist/cjs/functions/batch.js

@@ -1,21 +1,48 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var batch_exports = {};
+__export(batch_exports, {
+  default: () => batch_default
+});
+module.exports = __toCommonJS(batch_exports);
 const raw = async ({ multicallWrapper }, ...items) => {
-    const rawDataArr = await Promise.all(items.map(({ args, raw }, i) => {
-        if (!raw) {
-            throw new Error(`Function ${i} is not batchable`);
-        }
-        return raw(...args);
-    }));
-    return multicallWrapper.raw(rawDataArr);
+  const rawDataArr = await Promise.all(
+    items.map(({ args, raw: rawRef }, i) => {
+      if (!rawRef) {
+        throw new Error(`Function ${i} is not batchable`);
+      }
+      return rawRef(...args);
+    })
+  );
+  return multicallWrapper.raw(rawDataArr);
 };
 const decode = async ({ multicallWrapper }, data, ...items) => {
-    const response = await multicallWrapper.decode(data);
-    if (!response)
-        return;
-    return Promise.all(response.map((ret, i) => items[i].decode(ret.returnData, ...items[i].args)));
+  const response = await multicallWrapper.decode(data);
+  if (!response)
+    return;
+  return Promise.all(
+    response.map(
+      (ret, i) => items[i].decode(ret.returnData, ...items[i].args)
+    )
+  );
 };
-exports.default = {
-    raw,
-    decode,
+var batch_default = {
+  raw,
+  decode
 };

package/dist/cjs/functions/batchWrappers.js

@@ -1,71 +1,101 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.multicallWrapper = exports.resolverMulticallWrapper = exports.universalWrapper = void 0;
-const hexEncodedName_1 = require("../utils/hexEncodedName");
-exports.universalWrapper = {
-    raw: async ({ contracts }, name, data) => {
-        const universalResolver = await contracts?.getUniversalResolver();
-        return {
-            to: universalResolver.address,
-            data: universalResolver.interface.encodeFunctionData('resolve', [
-                (0, hexEncodedName_1.hexEncodeName)(name),
-                data,
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const universalResolver = await contracts?.getUniversalResolver();
-        const response = universalResolver.interface.decodeFunctionResult('resolve', data);
-        if (!response || !response[0]) {
-            return;
-        }
-        return { data: response[0], resolver: response[1] };
-    },
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.resolverMulticallWrapper = {
-    raw: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const formattedDataArr = data.map((item) => item.data);
-        return {
-            to: publicResolver.address,
-            data: publicResolver.interface.encodeFunctionData('multicall', [
-                formattedDataArr,
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const response = publicResolver.interface.decodeFunctionResult('multicall', data);
-        if (!response) {
-            return;
-        }
-        return response;
-    },
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.multicallWrapper = {
-    raw: async function ({ contracts }, transactions, requireSuccess = false) {
-        const multicall = await contracts?.getMulticall();
-        return {
-            to: multicall.address,
-            data: multicall.interface.encodeFunctionData('tryAggregate', [
-                requireSuccess,
-                transactions.map((tx) => ({
-                    target: tx.to,
-                    callData: tx.data,
-                })),
-            ]),
-        };
-    },
-    decode: async function ({ contracts }, data) {
-        if (!data)
-            return;
-        const multicall = await contracts?.getMulticall();
-        try {
-            const [result] = multicall.interface.decodeFunctionResult('tryAggregate', data);
-            return result;
-        }
-        catch {
-            return;
-        }
-    },
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var batchWrappers_exports = {};
+__export(batchWrappers_exports, {
+  multicallWrapper: () => multicallWrapper,
+  resolverMulticallWrapper: () => resolverMulticallWrapper,
+  universalWrapper: () => universalWrapper
+});
+module.exports = __toCommonJS(batchWrappers_exports);
+var import_hexEncodedName = require("../utils/hexEncodedName");
+const universalWrapper = {
+  raw: async ({ contracts }, name, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    return {
+      to: universalResolver.address,
+      data: universalResolver.interface.encodeFunctionData("resolve", [
+        (0, import_hexEncodedName.hexEncodeName)(name),
+        data
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    const response = universalResolver.interface.decodeFunctionResult(
+      "resolve",
+      data
+    );
+    if (!response || !response[0]) {
+      return;
+    }
+    return { data: response[0], resolver: response[1] };
+  }
+};
+const resolverMulticallWrapper = {
+  raw: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const formattedDataArr = data.map((item) => item.data);
+    return {
+      to: publicResolver.address,
+      data: publicResolver.interface.encodeFunctionData("multicall", [
+        formattedDataArr
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const response = publicResolver.interface.decodeFunctionResult(
+      "multicall",
+      data
+    );
+    if (!response) {
+      return;
+    }
+    return response;
+  }
+};
+const multicallWrapper = {
+  async raw({ contracts }, transactions, requireSuccess = false) {
+    const multicall = await contracts?.getMulticall();
+    return {
+      to: multicall.address,
+      data: multicall.interface.encodeFunctionData("tryAggregate", [
+        requireSuccess,
+        transactions.map((tx) => ({
+          target: tx.to,
+          callData: tx.data
+        }))
+      ])
+    };
+  },
+  async decode({ contracts }, data) {
+    if (!data)
+      return;
+    const multicall = await contracts?.getMulticall();
+    try {
+      const [result] = multicall.interface.decodeFunctionResult(
+        "tryAggregate",
+        data
+      );
+      return result;
+    } catch {
+      return;
+    }
+  }
 };

package/dist/cjs/functions/burnFuses.js

@@ -1,18 +1,68 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, fusesToBurn) {
-    const signer = provider?.getSigner();
-    if (!signer) {
-        throw new Error('No signer found');
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var burnFuses_exports = {};
+__export(burnFuses_exports, {
+  default: () => burnFuses_default
+});
+module.exports = __toCommonJS(burnFuses_exports);
+var import_fuses = require("../utils/fuses");
+var import_normalise = require("../utils/normalise");
+async function burnFuses_default({ contracts, signer }, name, props) {
+  const isNumber = "fuseNumberToBurn" in props;
+  const hasNamedArray = "namedFusesToBurn" in props;
+  const hasUnnamedArray = "unnamedFusesToBurn" in props;
+  let encodedFuses = 0;
+  if (isNumber) {
+    if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${props.fuseNumberToBurn} was too ${props.fuseNumberToBurn < 1 ? "low" : "high"}.`
+      );
+    } else if (props.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`
+      );
+    }
+    encodedFuses = props.fuseNumberToBurn;
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error("Please provide fuses to burn");
+    }
+    if (hasNamedArray) {
+      for (const fuse of props.namedFusesToBurn) {
+        if (!(fuse in import_fuses.fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`);
+        }
+        encodedFuses |= import_fuses.fuseEnum[fuse];
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of props.unnamedFusesToBurn) {
+        if (!import_fuses.unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`
+          );
+        }
+        encodedFuses |= fuse;
+      }
     }
-    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const hash = (0, normalise_1.namehash)(name);
-    const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
-    return nameWrapper.burnFuses(hash, encodedFuses);
+  }
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  const hash = (0, import_normalise.namehash)(name);
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
 }
-exports.default = default_1;

package/dist/cjs/functions/commitName.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var commitName_exports = {};
+__export(commitName_exports, {
+  default: () => commitName_default
+});
+module.exports = __toCommonJS(commitName_exports);
+var import_registerHelpers = require("../utils/registerHelpers");
+async function commitName_default({ contracts }, name, { resolverAddress, ...params }) {
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth")
+    throw new Error("Currently only .eth TLD registrations are supported");
+  const controller = await contracts.getEthRegistrarController();
+  const resolver = await contracts.getPublicResolver(
+    void 0,
+    resolverAddress
+  );
+  const { secret, commitment, wrapperExpiry } = (0, import_registerHelpers.makeCommitment)({
+    name,
+    resolver,
+    ...params
+  });
+  return {
+    ...await controller.populateTransaction.commit(commitment),
+    customData: {
+      secret,
+      commitment,
+      wrapperExpiry
+    }
+  };
+}

package/dist/cjs/functions/createSubname.js

@@ -1,44 +1,85 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
-    const labels = name.split('.');
-    if (labels.length === 1) {
-        throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
-    }
-    if ('fuses' in wrapperArgs && contract === 'registry') {
-        throw new Error('Fuses can only be set on a wrapped name');
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createSubname_exports = {};
+__export(createSubname_exports, {
+  default: () => createSubname_default
+});
+module.exports = __toCommonJS(createSubname_exports);
+var import_ethers = require("ethers");
+var import_generateFuseInput = __toESM(require("../utils/generateFuseInput"));
+var import_normalise = require("../utils/normalise");
+var import_wrapperExpiry = require("../utils/wrapperExpiry");
+async function createSubname_default({
+  contracts,
+  signer,
+  getExpiry
+}, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
+  const labels = name.split(".");
+  if (labels.length === 1) {
+    throw new Error("Subnames in ENS.js can only be created for 2LDs, not TLDs");
+  }
+  if ("fuses" in wrapperArgs && contract === "registry") {
+    throw new Error("Fuses can only be set on a wrapped name");
+  }
+  if (!resolverAddress) {
+    resolverAddress = (await contracts?.getPublicResolver()).address;
+  }
+  const label = labels.shift();
+  const labelhash = import_ethers.ethers.utils.solidityKeccak256(["string"], [label]);
+  const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        owner,
+        resolverAddress,
+        0
+      );
     }
-    if (!resolverAddress) {
-        resolverAddress = (await contracts?.getPublicResolver()).address;
+    case "nameWrapper": {
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      const expiry = await (0, import_wrapperExpiry.makeExpiry)(
+        { getExpiry },
+        name,
+        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      );
+      const generatedFuses = "fuses" in wrapperArgs && wrapperArgs.fuses ? (0, import_generateFuseInput.default)(wrapperArgs.fuses) : "0";
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        owner,
+        resolverAddress,
+        0,
+        generatedFuses,
+        expiry
+      );
     }
-    const label = labels.shift();
-    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
-    switch (contract) {
-        case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
-        }
-        case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
-                ? (0, generateFuseInput_1.default)(wrapperArgs.fuses)
-                : '0';
-            return nameWrapper.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
     }
+  }
 }
-exports.default = default_1;

package/dist/cjs/functions/deleteSubname.js

@@ -1,6 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function default_1({ contracts, provider, transferSubname, }, name, contract, options) {
-    return transferSubname(name, contract, '0x0000000000000000000000000000000000000000', options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deleteSubname_exports = {};
+__export(deleteSubname_exports, {
+  default: () => deleteSubname_default
+});
+module.exports = __toCommonJS(deleteSubname_exports);
+async function deleteSubname_default({ transferSubname, signer }, name, {
+  contract
+}) {
+  return transferSubname.populateTransaction(name, {
+    contract,
+    owner: "0x0000000000000000000000000000000000000000",
+    signer
+  });
 }
-exports.default = default_1;

package/dist/cjs/functions/getDNSOwner.js

@@ -0,0 +1,82 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDNSOwner_exports = {};
+__export(getDNSOwner_exports, {
+  default: () => getDNSOwner_default,
+  dnsQuery: () => dnsQuery,
+  encodeURLParams: () => encodeURLParams,
+  getDNS: () => getDNS
+});
+module.exports = __toCommonJS(getDNSOwner_exports);
+var packet = __toESM(require("dns-packet"));
+function encodeURLParams(p) {
+  return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
+}
+const getDNS = async (q) => {
+  const response = await global.fetch(
+    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+      ct: "application/dns-udpwireformat",
+      dns: packet.encode(q)?.toString("base64"),
+      ts: Date.now().toString()
+    })}`
+  );
+  const arrayBuffer = await response.arrayBuffer();
+  const fromArrayBuffer = Buffer.from(arrayBuffer);
+  return packet.decode(fromArrayBuffer);
+};
+const dnsQuery = async (qtype, qname) => {
+  const query = {
+    type: "query",
+    id: 1,
+    flags: packet.RECURSION_DESIRED,
+    questions: [
+      {
+        type: qtype,
+        class: "IN",
+        name: qname
+      }
+    ],
+    additionals: [
+      {
+        type: "OPT",
+        class: "IN",
+        name: ".",
+        udpPayloadSize: 4096,
+        flags: packet.DNSSEC_OK
+      }
+    ],
+    answers: []
+  };
+  const response = await getDNS(query);
+  if (response.rcode !== "NOERROR") {
+    throw new Error(`DNS query failed: ${response.rcode}`);
+  }
+  return response;
+};
+async function getDNSOwner_default(_, dnsName) {
+  const result = await dnsQuery("TXT", `_ens.${dnsName}`);
+  const address = result?.answers?.[0]?.data?.[0]?.toString()?.split("=")?.[1];
+  return address;
+}