@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.40

package/dist/esm/functions/getSubnames.mjs

@@ -0,0 +1,92 @@
+// src/functions/getSubnames.ts
+import { truncateFormat } from "../utils/format.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
+          }
+        }
+      }
+    }
+  `;
+  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((subname) => {
+    const decrypted = decryptName(subname.name);
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted)
+    };
+  });
+  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,39 @@
+// src/functions/getWrapperData.ts
+import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
+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 fuses = BigNumber.from(_fuses);
+    const fuseObj = decodeFuses(fuses);
+    const expiryDate = new Date(expiry * 1e3);
+    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,25 @@
+// 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";
+import { default as default9 } from "./getRecords.mjs";
+export * from "./getSpecificRecord.mjs";
+import { default as default10 } from "./getSubnames.mjs";
+import { default as default11 } 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 getRecords,
+  default10 as getSubnames,
+  default11 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,43 @@
+// src/functions/renewNames.ts
+import { validateFuses } from "../utils/fuses.mjs";
+import { MAX_INT_64 } from "../utils/registerHelpers.mjs";
+async function renewNameWithData({ contracts }, name, {
+  duration,
+  value,
+  fuses,
+  wrapperExpiry = MAX_INT_64
+}) {
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth") {
+    throw new Error("Currently only .eth TLD renewals are supported");
+  }
+  const encodedFuses = fuses ? validateFuses(fuses) : 0;
+  const controller = await contracts.getEthRegistrarController();
+  return controller.populateTransaction.renewWithFuses(
+    labels[0],
+    duration,
+    encodedFuses,
+    wrapperExpiry,
+    { value }
+  );
+}
+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,
+  renewNameWithData
+};

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
+};

package/dist/esm/functions/supportsTLD.mjs

@@ -0,0 +1,29 @@
+// src/functions/supportsTLD.ts
+import { DNSRegistrar__factory } from "../generated/factories/DNSRegistrar__factory.mjs";
+var DNSSEC_CLAIM_INTERFACE_IDS = ["0x2f435428", "0x17d8f49b", "0x1aa2e641"];
+async function supportsTLD_default({ getOwner, provider }, name) {
+  try {
+    const labels = name.split(".");
+    const tld = labels[labels.length - 1];
+    if (tld === "eth")
+      return true;
+    const tldOwner = await getOwner(tld, "registry");
+    if (!tldOwner?.owner)
+      return false;
+    const dnsRegistrar = DNSRegistrar__factory.connect(
+      tldOwner.owner,
+      provider
+    );
+    const supports = await Promise.all(
+      DNSSEC_CLAIM_INTERFACE_IDS.map(
+        (interfaceId) => dnsRegistrar.supportsInterface(interfaceId)
+      )
+    );
+    return supports.some((s) => !!s);
+  } catch {
+    return false;
+  }
+}
+export {
+  supportsTLD_default as default
+};

package/dist/esm/functions/transferController.mjs

@@ -0,0 +1,23 @@
+// src/functions/transferController.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+async function transferController_default({ contracts, signer }, name, {
+  newOwner,
+  isOwner
+}) {
+  const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
+  const registry = (await contracts?.getRegistry()).connect(signer);
+  const labels = name.split(".");
+  if (isOwner) {
+    return registry.populateTransaction.setOwner(
+      solidityKeccak256(["string"], [labels[0]]),
+      newOwner
+    );
+  }
+  return baseRegistrar.populateTransaction.reclaim(
+    solidityKeccak256(["string"], [labels[0]]),
+    newOwner
+  );
+}
+export {
+  transferController_default as default
+};

package/dist/esm/functions/transferName.mjs

@@ -0,0 +1,46 @@
+// src/functions/transferName.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import { namehash } from "../utils/normalise.mjs";
+async function transferName_default({ contracts, signer }, name, {
+  newOwner,
+  contract,
+  reclaim
+}) {
+  const address = await signer.getAddress();
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts?.getRegistry()).connect(signer);
+      return registry.populateTransaction.setOwner(namehash(name), newOwner);
+    }
+    case "baseRegistrar": {
+      const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(
+        signer
+      );
+      const labels = name.split(".");
+      if (labels.length > 2 || labels[labels.length - 1] !== "eth") {
+        throw new Error("Invalid name for baseRegistrar");
+      }
+      const tokenId = solidityKeccak256(["string"], [labels[0]]);
+      if (reclaim) {
+        return baseRegistrar.populateTransaction.reclaim(tokenId, newOwner);
+      }
+      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](address, newOwner, tokenId);
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.safeTransferFrom(
+        address,
+        newOwner,
+        namehash(name),
+        1,
+        "0x"
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
+}
+export {
+  transferName_default as default
+};

package/dist/esm/functions/transferSubname.mjs

@@ -0,0 +1,45 @@
+// src/functions/transferSubname.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import { namehash } from "../utils/normalise.mjs";
+import { makeExpiry } from "../utils/wrapper.mjs";
+async function transferSubname_default({
+  contracts,
+  signer,
+  getExpiry
+}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+  const labels = name.split(".");
+  const label = labels.shift();
+  const labelhash = solidityKeccak256(["string"], [label]);
+  const parentNodehash = namehash(labels.join("."));
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      return registry.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        labelhash,
+        owner
+      );
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      const expiry = await makeExpiry(
+        { getExpiry },
+        labels.join("."),
+        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      );
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        owner,
+        "0",
+        expiry
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
+}
+export {
+  transferSubname_default as default
+};

package/dist/esm/functions/unwrapName.mjs

@@ -0,0 +1,33 @@
+// src/functions/unwrapName.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import { namehash } from "../utils/normalise.mjs";
+async function unwrapName_default({ contracts, signer }, name, {
+  newController,
+  newRegistrant
+}) {
+  const labels = name.split(".");
+  const labelhash = solidityKeccak256(["string"], [labels[0]]);
+  const parentNodehash = namehash(labels.slice(1).join("."));
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  if (labels.length === 2 && labels[1] === "eth") {
+    if (!newRegistrant) {
+      throw new Error("newRegistrant must be specified for .eth names");
+    }
+    return nameWrapper.populateTransaction.unwrapETH2LD(
+      labelhash,
+      newRegistrant,
+      newController
+    );
+  }
+  if (newRegistrant) {
+    throw new Error("newRegistrant can only be specified for .eth names");
+  }
+  return nameWrapper.populateTransaction.unwrap(
+    parentNodehash,
+    labelhash,
+    newController
+  );
+}
+export {
+  unwrapName_default as default
+};

package/dist/esm/functions/wrapName.mjs

@@ -0,0 +1,105 @@
+// src/functions/wrapName.ts
+import { defaultAbiCoder } from "@ethersproject/abi/lib.esm/abi-coder.js";
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import generateFuseInput from "../utils/generateFuseInput.mjs";
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+import { makeExpiry, wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
+async function wrapETH({ contracts }, labels, wrappedOwner, expiry, decodedFuses, resolverAddress, signer, address) {
+  const nameWrapper = await contracts?.getNameWrapper();
+  const baseRegistrar = (await contracts.getBaseRegistrar()).connect(signer);
+  const labelhash = solidityKeccak256(["string"], [labels[0]]);
+  const data = defaultAbiCoder.encode(
+    ["string", "address", "uint32", "uint64", "address"],
+    [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress]
+  );
+  return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256,bytes)"](address, nameWrapper.address, labelhash, data);
+}
+async function wrapOther({ contracts }, name, wrappedOwner, resolverAddress, address, signer) {
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  const registry = await contracts?.getRegistry();
+  const hasApproval = await registry.isApprovedForAll(
+    address,
+    nameWrapper.address
+  );
+  if (!hasApproval) {
+    throw new Error(
+      "NameWrapper must have approval to wrap a name from this address."
+    );
+  }
+  return nameWrapper.populateTransaction.wrap(
+    hexEncodeName(name),
+    wrappedOwner,
+    resolverAddress
+  );
+}
+async function wrapName_default({
+  contracts,
+  signer,
+  getExpiry
+}, name, {
+  wrappedOwner,
+  fuseOptions,
+  expiry,
+  resolverAddress
+}) {
+  const address = await signer.getAddress();
+  let decodedFuses;
+  const publicResolver = await contracts?.getPublicResolver();
+  if (!resolverAddress)
+    resolverAddress = publicResolver.address;
+  const labels = name.split(".");
+  wrappedLabelLengthCheck(labels[0]);
+  if (labels.length === 2 && labels[1] === "eth") {
+    switch (typeof fuseOptions) {
+      case "object": {
+        decodedFuses = generateFuseInput(fuseOptions);
+        break;
+      }
+      case "number": {
+        decodedFuses = fuseOptions.toString(16);
+        break;
+      }
+      case "string": {
+        decodedFuses = fuseOptions;
+        break;
+      }
+      case "undefined": {
+        decodedFuses = "0";
+        break;
+      }
+      default: {
+        throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
+      }
+    }
+    const expiryToUse = await makeExpiry({ getExpiry }, name, expiry);
+    return wrapETH(
+      { contracts },
+      labels,
+      wrappedOwner,
+      expiryToUse,
+      decodedFuses,
+      resolverAddress,
+      signer,
+      address
+    );
+  }
+  if (fuseOptions)
+    throw new Error(
+      "Fuses can not be initially set when wrapping a non .eth name"
+    );
+  if (expiry)
+    throw new Error(
+      "Expiry can not be initially set when wrapping a non .eth name"
+    );
+  return wrapOther(
+    { contracts },
+    name,
+    wrappedOwner,
+    resolverAddress,
+    address,
+    signer
+  );
+}
+export {
+  wrapName_default as default
+};