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

package/dist/esm/functions/getSubnames.mjs

@@ -0,0 +1,155 @@
+// 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 = [] }) => {
+  const { client } = gqlInstance;
+  const finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $lastCreatedAt: BigInt
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+          where: { createdAt_lt: $lastCreatedAt }
+        ) {
+          id
+          labelName
+          labelhash
+          isMigrated
+          name
+          subdomainCount
+          createdAt
+          owner {
+            id
+          }
+        }
+      }
+    }
+  `;
+  const queryVars = {
+    id: namehash(name),
+    first: pageSize,
+    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    orderBy,
+    orderDirection
+  };
+  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 smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
+  const { client } = gqlInstance;
+  const subdomainsGql = `
+  id
+  labelName
+  labelhash
+  isMigrated
+  name
+  subdomainCount
+  createdAt
+  owner {
+    id
+  }
+`;
+  let queryVars = {};
+  let finalQuery = "";
+  if (typeof page !== "number") {
+    finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomains(
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+        ) {
+          ${subdomainsGql}
+        }
+      }
+    }
+  `;
+    queryVars = {
+      id: namehash(name),
+      orderBy,
+      orderDirection
+    };
+  } else {
+    finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $skip: Int
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          skip: $skip
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+        ) {
+          ${subdomainsGql}
+        }
+      }
+    }
+  `;
+    queryVars = {
+      id: namehash(name),
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection
+    };
+  }
+  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) => {
+  if (functionArgs.isLargeQuery) {
+    return largeQuery(injected, functionArgs);
+  }
+  return smallQuery(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/renewName.mjs

@@ -0,0 +1,14 @@
+// src/functions/renewName.ts
+async function renewName_default({ contracts }, name, {
+  duration,
+  value
+}) {
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth")
+    throw new Error("Currently only .eth TLD renewals are supported");
+  const controller = await contracts.getEthRegistrarController();
+  return controller.populateTransaction.renew(labels[0], duration, { value });
+}
+export {
+  renewName_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
+};