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

package/dist/esm/functions/getSubnames.mjs

@@ -0,0 +1,91 @@
+// 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 { domain } = await client.request(finalQuery, queryVars);
+  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/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";
+import { default as default9 } from "./getRecords.mjs";
+export * from "./getSpecificRecord.mjs";
+import { default as default10 } from "./getSubnames.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
+};

package/dist/esm/functions/registerName.mjs

@@ -0,0 +1,25 @@
+// src/functions/registerName.ts
+import {
+  makeRegistrationData
+} from "../utils/registerHelpers.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");
+  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,23 @@
+// src/functions/renewNames.ts
+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
+};

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/transferName.mjs

@@ -0,0 +1,45 @@
+// src/functions/transferName.ts
+import { ethers } from "ethers";
+import { namehash } from "../utils/normalise.mjs";
+async function transferName_default({ contracts, signer }, name, {
+  newOwner,
+  contract
+}) {
+  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");
+      }
+      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](
+        address,
+        newOwner,
+        ethers.utils.solidityKeccak256(["string"], [labels[0]])
+      );
+    }
+    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 { ethers } from "ethers";
+import { namehash } from "../utils/normalise.mjs";
+import { makeExpiry } from "../utils/wrapperExpiry.mjs";
+async function transferSubname_default({
+  contracts,
+  signer,
+  getExpiry
+}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+  const labels = name.split(".");
+  const label = labels.shift();
+  const labelhash = ethers.utils.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 { utils } from "ethers";
+import { namehash } from "../utils/normalise.mjs";
+async function unwrapName_default({ contracts, signer }, name, {
+  newController,
+  newRegistrant
+}) {
+  const labels = name.split(".");
+  const labelhash = utils.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,103 @@
+// src/functions/wrapName.ts
+import { ethers } from "ethers";
+import generateFuseInput from "../utils/generateFuseInput.mjs";
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+import { makeExpiry } from "../utils/wrapperExpiry.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 = ethers.utils.solidityKeccak256(["string"], [labels[0]]);
+  const data = ethers.utils.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(".");
+  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
+};