@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.60

package/dist/esm/functions/getSpecificRecord.mjs

@@ -0,0 +1,253 @@
+// src/functions/getSpecificRecord.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { arrayify, hexStripZeros, isBytesLike } from "@ethersproject/bytes";
+import { toUtf8String } from "@ethersproject/strings";
+import { decodeContenthash } from "../utils/contentHash.mjs";
+import { namehash } from "../utils/normalise.mjs";
+var _getContentHash = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("contenthash", [
+        namehash(name)
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    let response;
+    const publicResolver = await contracts?.getPublicResolver();
+    try {
+      ;
+      [response] = publicResolver.interface.decodeFunctionResult(
+        "contenthash",
+        data
+      );
+    } catch {
+      return;
+    }
+    if (!response) {
+      return;
+    }
+    const decodedContent = decodeContenthash(response);
+    if (!decodedContent || isBytesLike(decodedContent.decoded) && hexStripZeros(decodedContent.decoded) === "0x" || Object.keys(decodedContent).length === 0) {
+      return;
+    }
+    return decodedContent;
+  }
+};
+var getContentHash = {
+  raw: async ({ contracts, universalWrapper }, name) => {
+    const prData = await _getContentHash.raw({ contracts }, name);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getContentHash.decode({ contracts }, urData.data);
+  }
+};
+var _getText = {
+  raw: async ({ contracts }, name, key) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("text", [
+        namehash(name),
+        key
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const [response] = publicResolver.interface.decodeFunctionResult(
+      "text",
+      data
+    );
+    if (!response) {
+      return;
+    }
+    return response;
+  }
+};
+var getText = {
+  raw: async ({ contracts, universalWrapper }, name, key) => {
+    const prData = await _getText.raw({ contracts }, name, key);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getText.decode({ contracts }, urData.data);
+  }
+};
+var _getAddr = {
+  raw: async ({ contracts }, name, coinType, bypassFormat) => {
+    if (!coinType) {
+      coinType = 60;
+    }
+    const publicResolver = await contracts?.getPublicResolver();
+    if (coinType === 60 || coinType === "60") {
+      return {
+        to: "0x0000000000000000000000000000000000000000",
+        data: publicResolver.interface.encodeFunctionData("addr(bytes32)", [
+          namehash(name)
+        ])
+      };
+    }
+    if (bypassFormat) {
+      return {
+        to: "0x0000000000000000000000000000000000000000",
+        data: publicResolver.interface.encodeFunctionData(
+          "addr(bytes32,uint256)",
+          [namehash(name), coinType]
+        )
+      };
+    }
+    const formatter = typeof coinType === "string" && Number.isNaN(parseInt(coinType)) ? formatsByName[coinType] : formatsByCoinType[typeof coinType === "number" ? coinType : parseInt(coinType)];
+    if (!formatter) {
+      throw new Error(`No formatter found for coin: ${coinType}`);
+    }
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData(
+        "addr(bytes32,uint256)",
+        [namehash(name), formatter.coinType]
+      )
+    };
+  },
+  decode: async ({ contracts }, data, _name, coinType) => {
+    let returnCoinType = true;
+    if (!coinType) {
+      coinType = 60;
+      returnCoinType = false;
+    }
+    const publicResolver = await contracts?.getPublicResolver();
+    const formatter = typeof coinType === "string" && Number.isNaN(parseInt(coinType)) ? formatsByName[coinType] : formatsByCoinType[typeof coinType === "number" ? coinType : parseInt(coinType)];
+    let response;
+    if (coinType === 60 || coinType === "60") {
+      ;
+      [response] = publicResolver.interface.decodeFunctionResult(
+        "addr(bytes32)",
+        data
+      );
+    } else {
+      ;
+      [response] = publicResolver.interface.decodeFunctionResult(
+        "addr(bytes32,uint256)",
+        data
+      );
+    }
+    if (!response)
+      return;
+    if (hexStripZeros(response) === "0x") {
+      return;
+    }
+    const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), "hex"));
+    if (!decodedAddr) {
+      return;
+    }
+    if (!returnCoinType) {
+      return decodedAddr;
+    }
+    return { coin: formatter.name, addr: decodedAddr };
+  }
+};
+var getAddr = {
+  raw: async ({ contracts, universalWrapper }, name, coinType) => {
+    const prData = await _getAddr.raw({ contracts }, name, coinType);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data, _name, coinType) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getAddr.decode({ contracts }, urData.data, _name, coinType);
+  }
+};
+var supportedContentTypes = "0xf";
+var _getABI = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("ABI", [
+        namehash(name),
+        supportedContentTypes
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const [bnContentType, encodedABIData] = publicResolver.interface.decodeFunctionResult("ABI", data);
+    if (!bnContentType || !data) {
+      return;
+    }
+    const contentType = bnContentType.toNumber();
+    if (!contentType) {
+      return;
+    }
+    let abiData;
+    let decoded = false;
+    switch (contentType) {
+      case 1:
+        abiData = JSON.parse(toUtf8String(encodedABIData));
+        decoded = true;
+        break;
+      case 2: {
+        const { inflate } = await import("pako/dist/pako_inflate.min.js");
+        abiData = JSON.parse(
+          inflate(arrayify(encodedABIData), { to: "string" })
+        );
+        decoded = true;
+        break;
+      }
+      case 4: {
+        const { decodeFirst } = await import("cbor");
+        abiData = await decodeFirst(arrayify(encodedABIData));
+        decoded = true;
+        break;
+      }
+      case 8:
+        abiData = toUtf8String(encodedABIData);
+        decoded = false;
+        break;
+      default:
+        try {
+          abiData = toUtf8String(encodedABIData);
+        } catch {
+          abiData = encodedABIData;
+        }
+        decoded = false;
+    }
+    return {
+      contentType,
+      decoded,
+      abi: abiData
+    };
+  }
+};
+var getABI = {
+  raw: async ({ contracts, universalWrapper }, name) => {
+    const prData = await _getABI.raw({ contracts }, name);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getABI.decode({ contracts }, urData.data);
+  }
+};
+export {
+  _getABI,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  getABI,
+  getAddr,
+  getContentHash,
+  getText
+};

package/dist/esm/functions/getSubnames.mjs

@@ -0,0 +1,116 @@
+// src/functions/getSubnames.ts
+import { truncateFormat } from "../utils/format.mjs";
+import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
+import { decryptName } from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.mjs";
+var largeQuery = async ({ gqlInstance }, {
+  name,
+  pageSize = 10,
+  orderDirection,
+  orderBy,
+  lastSubnames = [],
+  search = ""
+}) => {
+  const { client } = gqlInstance;
+  const lastSubname = lastSubnames?.[lastSubnames.length - 1];
+  const lastCreatedAt = lastSubname?.createdAt;
+  const lastLabelName = lastSubname?.labelName;
+  let whereFilter = "";
+  if (orderBy === "createdAt" && lastCreatedAt) {
+    whereFilter += orderDirection === "asc" ? "createdAt_gt: $lastCreatedAt" : "createdAt_lt: $lastCreatedAt";
+  } else if (orderBy === "labelName" && lastLabelName) {
+    whereFilter += orderDirection === "asc" ? "labelName_gt: $lastLabelName" : "labelName_lt: $lastLabelName";
+  }
+  if (search) {
+    whereFilter += " labelName_contains: $search";
+  }
+  const finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $lastCreatedAt: BigInt
+      $lastLabelName: String
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+      $search: String
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+          where: { 
+            ${whereFilter}
+          }
+        ) {
+          id
+          labelName
+          labelhash
+          isMigrated
+          name
+          subdomainCount
+          createdAt
+          owner {
+            id
+          }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
+        }
+      }
+    }
+  `;
+  const queryVars = {
+    id: namehash(name),
+    first: pageSize,
+    lastCreatedAt,
+    lastLabelName,
+    orderBy,
+    orderDirection,
+    search: search?.toLowerCase()
+  };
+  const response = await client.request(finalQuery, queryVars);
+  const domain = response?.domain;
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }) => {
+      const decrypted = decryptName(subname.name);
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || "",
+        name: decrypted,
+        truncatedName: truncateFormat(decrypted),
+        owner: subname.owner.id,
+        type: "domain"
+      };
+      if (wrappedDomain) {
+        obj.type = "wrappedDomain";
+        const expiryDateAsDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date();
+        obj.expiryDate = expiryDateAsDate;
+        obj.fuses = decodeFuses(hasExpired ? 0 : wrappedDomain.fuses);
+        obj.pccExpired = hasExpired ? checkPCCBurned(wrappedDomain.fuses) : false;
+        obj.owner = obj.pccExpired ? void 0 : wrappedDomain.owner.id;
+      }
+      return obj;
+    }
+  );
+  return {
+    subnames: subdomains,
+    subnameCount: domain.subdomainCount
+  };
+};
+var getSubnames = (injected, functionArgs) => {
+  return largeQuery(injected, functionArgs);
+};
+var getSubnames_default = getSubnames;
+export {
+  getSubnames_default as default
+};

package/dist/esm/functions/getWrapperData.mjs

@@ -0,0 +1,46 @@
+// src/functions/getWrapperData.ts
+import { MAX_DATE_INT } from "../utils/consts.mjs";
+import { decodeFuses } from "../utils/fuses.mjs";
+import { namehash } from "../utils/normalise.mjs";
+var raw = async ({ contracts }, name) => {
+  const nameWrapper = await contracts?.getNameWrapper();
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData("getData", [namehash(name)])
+  };
+};
+var decode = async ({ contracts }, data) => {
+  const nameWrapper = await contracts?.getNameWrapper();
+  try {
+    const [owner, fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      "getData",
+      data
+    );
+    const fuseObj = decodeFuses(fuses);
+    let expiryDate;
+    if (expiry.gt(0)) {
+      const msBigNumber = expiry.mul(1e3);
+      if (msBigNumber.gte(MAX_DATE_INT)) {
+        expiryDate = new Date(MAX_DATE_INT);
+      } else {
+        expiryDate = new Date(msBigNumber.toNumber());
+      }
+    }
+    return {
+      ...fuseObj,
+      expiryDate,
+      rawFuses: fuses,
+      owner
+    };
+  } catch (e) {
+    console.error("Error decoding wrapper data: ", e);
+    return;
+  }
+};
+var getWrapperData_default = {
+  raw,
+  decode
+};
+export {
+  getWrapperData_default as default
+};

package/dist/esm/functions/importDNSSECName.mjs

@@ -0,0 +1,40 @@
+// src/functions/importDNSSECName.ts
+import { Oracle as NewOracle } from "@ensdomains/dnssecoraclejs";
+import packet from "dns-packet";
+import { EMPTY_ADDRESS } from "../utils/consts.mjs";
+var DNS_OVER_HTTP_ENDPOINT = "https://1.1.1.1/dns-query";
+async function importDNSSECName_default({ contracts, provider }, name, { address, proverResult }) {
+  const dnsRegistrarContract = await contracts?.getDNSRegistrar();
+  const resolverContract = await contracts?.getPublicResolver();
+  const registrarOracle = await dnsRegistrarContract?.oracle();
+  if (!registrarOracle) {
+    throw new Error("No oracle found");
+  }
+  const oracle = new NewOracle(registrarOracle, provider);
+  const proofData = await oracle.getProofData(proverResult);
+  const encodedName = `0x${packet.name.encode(name).toString("hex")}`;
+  const data = proofData.rrsets.map(
+    (x) => Object.values(x)
+  );
+  const { proof } = proofData;
+  if (address === EMPTY_ADDRESS) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaim(
+      encodedName,
+      data,
+      proof
+    );
+  }
+  if (address) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaimWithResolver(
+      encodedName,
+      data,
+      proof,
+      resolverContract.address,
+      address
+    );
+  }
+}
+export {
+  DNS_OVER_HTTP_ENDPOINT,
+  importDNSSECName_default as default
+};

package/dist/esm/functions/initialGetters.mjs

@@ -0,0 +1,23 @@
+// src/functions/initialGetters.ts
+import { default as default2 } from "./batch.mjs";
+export * from "./batchWrappers.mjs";
+import { default as default3 } from "./getExpiry.mjs";
+import { default as default4 } from "./getName.mjs";
+import { default as default5 } from "./getNames.mjs";
+import { default as default6 } from "./getOwner.mjs";
+import { default as default7 } from "./getPrice.mjs";
+import { default as default8 } from "./getProfile.mjs";
+export * from "./getSpecificRecord.mjs";
+import { default as default9 } from "./getSubnames.mjs";
+import { default as default10 } from "./supportsTLD.mjs";
+export {
+  default2 as batch,
+  default3 as getExpiry,
+  default4 as getName,
+  default5 as getNames,
+  default6 as getOwner,
+  default7 as getPrice,
+  default8 as getProfile,
+  default9 as getSubnames,
+  default10 as supportsTLD
+};

package/dist/esm/functions/registerName.mjs

@@ -0,0 +1,27 @@
+// src/functions/registerName.ts
+import {
+  makeRegistrationData
+} from "../utils/registerHelpers.mjs";
+import { wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
+async function registerName_default({ contracts }, name, { resolverAddress, value, ...params }) {
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth")
+    throw new Error("Currently only .eth TLD registrations are supported");
+  wrappedLabelLengthCheck(labels[0]);
+  const controller = await contracts.getEthRegistrarController();
+  const _resolver = await contracts.getPublicResolver(
+    void 0,
+    resolverAddress
+  );
+  const generatedParams = makeRegistrationData({
+    name,
+    resolver: _resolver,
+    ...params
+  });
+  return controller.populateTransaction.register(...generatedParams, {
+    value
+  });
+}
+export {
+  registerName_default as default
+};

package/dist/esm/functions/renewNames.mjs

@@ -0,0 +1,36 @@
+// src/functions/renewNames.ts
+import { MAX_INT_64 } from "../utils/consts.mjs";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.mjs";
+async function extendWrappedName({ contracts }, name, options) {
+  const expiry = options?.duration || MAX_INT_64;
+  const labels = name.split(".");
+  const labelHash = labelhash(labels.shift());
+  const parentNode = namehash(labels.join("."));
+  const nameWrapper = await contracts.getNameWrapper();
+  return nameWrapper.populateTransaction.extendExpiry(
+    parentNode,
+    labelHash,
+    expiry
+  );
+}
+async function renewNames_default({ contracts }, nameOrNames, { duration, value }) {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  const labels = names.map((name) => {
+    const label = name.split(".");
+    if (label.length !== 2 || label[1] !== "eth") {
+      throw new Error("Currently only .eth TLD renewals are supported");
+    }
+    return label[0];
+  });
+  if (labels.length === 1) {
+    const controller = await contracts.getEthRegistrarController();
+    return controller.populateTransaction.renew(labels[0], duration, { value });
+  }
+  const bulkRenewal = await contracts.getBulkRenewal();
+  return bulkRenewal.populateTransaction.renewAll(labels, duration, { value });
+}
+export {
+  renewNames_default as default,
+  extendWrappedName
+};

package/dist/esm/functions/setFuses.mjs

@@ -0,0 +1,30 @@
+// src/functions/setFuses.ts
+import { encodeFuses } from "../utils/fuses.mjs";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.mjs";
+async function setChildFuses({ contracts, signer }, name, {
+  fuses,
+  expiry = 0
+}) {
+  const encodedFuses = encodeFuses(fuses);
+  const labels = name.split(".");
+  const labelHash = labelhash(labels.shift());
+  const parentNode = namehash(labels.join("."));
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  return nameWrapper.populateTransaction.setChildFuses(
+    parentNode,
+    labelHash,
+    encodedFuses,
+    expiry
+  );
+}
+async function setFuses_default({ contracts, signer }, name, props) {
+  const encodedFuses = encodeFuses(props, "child");
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  const hash = namehash(name);
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
+}
+export {
+  setFuses_default as default,
+  setChildFuses
+};

package/dist/esm/functions/setName.mjs

@@ -0,0 +1,23 @@
+// src/functions/setName.ts
+async function setName_default({ contracts, signer }, name, {
+  address,
+  resolver
+} = {}) {
+  const signerAddress = await signer.getAddress();
+  const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
+    signer
+  );
+  if (address) {
+    const publicResolver = await contracts?.getPublicResolver();
+    return reverseRegistrar.populateTransaction.setNameForAddr(
+      address,
+      signerAddress,
+      resolver || publicResolver.address,
+      name
+    );
+  }
+  return reverseRegistrar.populateTransaction.setName(name);
+}
+export {
+  setName_default as default
+};

package/dist/esm/functions/setRecord.mjs

@@ -0,0 +1,36 @@
+// src/functions/setRecord.ts
+import { namehash } from "../utils/normalise.mjs";
+import { generateSingleRecordCall } from "../utils/recordHelpers.mjs";
+async function setRecord_default({
+  contracts,
+  provider,
+  getResolver,
+  signer
+}, name, {
+  record,
+  type,
+  resolverAddress
+}) {
+  if (!name.includes(".")) {
+    throw new Error("Input is not an ENS name");
+  }
+  let resolverToUse;
+  if (resolverAddress) {
+    resolverToUse = resolverAddress;
+  } else {
+    resolverToUse = await getResolver(name);
+  }
+  if (!resolverToUse) {
+    throw new Error("No resolver found for input address");
+  }
+  const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+  const hash = namehash(name);
+  const call = generateSingleRecordCall(hash, resolver, type)(record);
+  return {
+    to: resolver.address,
+    data: call
+  };
+}
+export {
+  setRecord_default as default
+};

package/dist/esm/functions/setRecords.mjs

@@ -0,0 +1,32 @@
+// src/functions/setRecords.ts
+import { namehash } from "../utils/normalise.mjs";
+import { generateRecordCallArray } from "../utils/recordHelpers.mjs";
+async function setRecords_default({
+  contracts,
+  provider,
+  getResolver,
+  signer
+}, name, {
+  records,
+  resolverAddress
+}) {
+  if (!name.includes(".")) {
+    throw new Error("Input is not an ENS name");
+  }
+  let resolverToUse;
+  if (resolverAddress) {
+    resolverToUse = resolverAddress;
+  } else {
+    resolverToUse = await getResolver(name);
+  }
+  if (!resolverToUse) {
+    throw new Error("No resolver found for input address");
+  }
+  const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+  const hash = namehash(name);
+  const calls = generateRecordCallArray(hash, records, resolver);
+  return resolver.populateTransaction.multicall(calls);
+}
+export {
+  setRecords_default as default
+};

package/dist/esm/functions/setResolver.mjs

@@ -0,0 +1,29 @@
+// src/functions/setResolver.ts
+import { namehash } from "../utils/normalise.mjs";
+async function setResolver_default({ contracts, signer }, name, {
+  contract,
+  resolver
+}) {
+  if (!resolver) {
+    resolver = (await contracts.getPublicResolver()).address;
+  }
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts?.getRegistry()).connect(signer);
+      return registry.populateTransaction.setResolver(namehash(name), resolver);
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.setResolver(
+        namehash(name),
+        resolver
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
+}
+export {
+  setResolver_default as default
+};