@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/esm/contracts/index.mjs

@@ -0,0 +1,66 @@
+// src/contracts/index.ts
+import getBaseRegistrar from "./baseRegistrar.mjs";
+import getEthRegistrarController from "./ethRegistrarController.mjs";
+import getMulticall from "./multicall.mjs";
+import getNameWrapper from "./nameWrapper.mjs";
+import getDNSRegistrar from "./dnsRegistrar.mjs";
+import getPublicResolver from "./publicResolver.mjs";
+import getRegistry from "./registry.mjs";
+import getReverseRegistrar from "./reverseRegistrar.mjs";
+import getUniversalResolver from "./universalResolver.mjs";
+import getBulkRenewal from "./bulkRenewal.mjs";
+var ContractManager = class {
+  provider;
+  fetchAddress;
+  constructor(provider, fetchAddress) {
+    this.provider = provider;
+    this.fetchAddress = fetchAddress;
+  }
+  generateContractGetter = (name, func) => {
+    return async (passedProvider, address) => {
+      const inputAddress = address || this.fetchAddress(name);
+      const provider = passedProvider || this.provider;
+      return func(provider, inputAddress);
+    };
+  };
+  getPublicResolver = this.generateContractGetter(
+    "PublicResolver",
+    getPublicResolver
+  );
+  getUniversalResolver = this.generateContractGetter(
+    "UniversalResolver",
+    getUniversalResolver
+  );
+  getRegistry = this.generateContractGetter(
+    "ENSRegistryWithFallback",
+    getRegistry
+  );
+  getReverseRegistrar = this.generateContractGetter(
+    "ReverseRegistrar",
+    getReverseRegistrar
+  );
+  getNameWrapper = this.generateContractGetter(
+    "NameWrapper",
+    getNameWrapper
+  );
+  getDNSRegistrar = this.generateContractGetter(
+    "DNSRegistrar",
+    getDNSRegistrar
+  );
+  getBaseRegistrar = this.generateContractGetter(
+    "BaseRegistrarImplementation",
+    getBaseRegistrar
+  );
+  getEthRegistrarController = this.generateContractGetter(
+    "ETHRegistrarController",
+    getEthRegistrarController
+  );
+  getMulticall = this.generateContractGetter("Multicall", getMulticall);
+  getBulkRenewal = this.generateContractGetter(
+    "BulkRenewal",
+    getBulkRenewal
+  );
+};
+export {
+  ContractManager as default
+};

package/dist/esm/contracts/multicall.mjs

@@ -0,0 +1,6 @@
+// src/contracts/multicall.ts
+import { Multicall__factory } from "../generated/factories/Multicall__factory.mjs";
+var multicall_default = (provider, address) => Multicall__factory.connect(address, provider);
+export {
+  multicall_default as default
+};

package/dist/esm/contracts/nameWrapper.mjs

@@ -0,0 +1,6 @@
+// src/contracts/nameWrapper.ts
+import { NameWrapper__factory } from "../generated/factories/NameWrapper__factory.mjs";
+var nameWrapper_default = (provider, address) => NameWrapper__factory.connect(address, provider);
+export {
+  nameWrapper_default as default
+};

package/dist/esm/contracts/publicResolver.mjs

@@ -0,0 +1,6 @@
+// src/contracts/publicResolver.ts
+import { PublicResolver__factory } from "../generated/factories/PublicResolver__factory.mjs";
+var publicResolver_default = (provider, address) => PublicResolver__factory.connect(address, provider);
+export {
+  publicResolver_default as default
+};

package/dist/esm/contracts/registry.mjs

@@ -0,0 +1,6 @@
+// src/contracts/registry.ts
+import { ENSRegistry__factory } from "../generated/factories/ENSRegistry__factory.mjs";
+var registry_default = (provider, address) => ENSRegistry__factory.connect(address, provider);
+export {
+  registry_default as default
+};

package/dist/esm/contracts/reverseRegistrar.mjs

@@ -0,0 +1,6 @@
+// src/contracts/reverseRegistrar.ts
+import { ReverseRegistrar__factory } from "../generated/factories/ReverseRegistrar__factory.mjs";
+var reverseRegistrar_default = (provider, address) => ReverseRegistrar__factory.connect(address, provider);
+export {
+  reverseRegistrar_default as default
+};

package/dist/esm/contracts/universalResolver.mjs

@@ -0,0 +1,6 @@
+// src/contracts/universalResolver.ts
+import { UniversalResolver__factory } from "../generated/factories/UniversalResolver__factory.mjs";
+var universalResolver_default = (provider, address) => UniversalResolver__factory.connect(address, provider);
+export {
+  universalResolver_default as default
+};

package/dist/esm/functions/batch.mjs

@@ -0,0 +1,29 @@
+// src/functions/batch.ts
+var raw = async ({ multicallWrapper }, ...items) => {
+  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);
+};
+var 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)
+    )
+  );
+};
+var batch_default = {
+  raw,
+  decode
+};
+export {
+  batch_default as default
+};

package/dist/esm/functions/batchWrappers.mjs

@@ -0,0 +1,109 @@
+// src/functions/batchWrappers.ts
+import ccipLookup from "../utils/ccip.mjs";
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+var universalWrapper = {
+  raw: async ({ contracts }, name, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    return {
+      to: universalResolver.address,
+      data: universalResolver.interface.encodeFunctionData(
+        "resolve(bytes,bytes)",
+        [hexEncodeName(name), data]
+      )
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    const response = universalResolver.interface.decodeFunctionResult(
+      "resolve(bytes,bytes)",
+      data
+    );
+    if (!response || !response[0]) {
+      return;
+    }
+    return { data: response[0], resolver: response[1] };
+  }
+};
+var 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 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, provider }, data, transactions) {
+    if (!data)
+      return;
+    const multicall = await contracts?.getMulticall();
+    try {
+      const [result] = multicall.interface.decodeFunctionResult(
+        "tryAggregate",
+        data
+      );
+      const ccipChecked = await Promise.all(
+        result.map(
+          async ([success, returnData], i) => {
+            let newArr = [success, returnData];
+            if (!success && returnData.startsWith("0x556f1830")) {
+              try {
+                const newData = await ccipLookup(
+                  provider,
+                  transactions[i],
+                  returnData
+                );
+                if (newData) {
+                  newArr = [true, newData];
+                }
+              } catch {
+              }
+            }
+            return {
+              ...newArr,
+              success: newArr[0],
+              returnData: newArr[1]
+            };
+          }
+        )
+      );
+      return ccipChecked;
+    } catch (e) {
+      console.error(e);
+      return;
+    }
+  }
+};
+export {
+  multicallWrapper,
+  resolverMulticallWrapper,
+  universalWrapper
+};

package/dist/esm/functions/burnFuses.mjs

@@ -0,0 +1,12 @@
+// src/functions/burnFuses.ts
+import { validateFuses } from "../utils/fuses.mjs";
+import { namehash } from "../utils/normalise.mjs";
+async function burnFuses_default({ contracts, signer }, name, props) {
+  const encodedFuses = validateFuses(props);
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  const hash = namehash(name);
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
+}
+export {
+  burnFuses_default as default
+};

package/dist/esm/functions/commitName.mjs

@@ -0,0 +1,30 @@
+// src/functions/commitName.ts
+import { makeCommitment } from "../utils/registerHelpers.mjs";
+import { wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
+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");
+  wrappedLabelLengthCheck(labels[0]);
+  const controller = await contracts.getEthRegistrarController();
+  const resolver = await contracts.getPublicResolver(
+    void 0,
+    resolverAddress
+  );
+  const { secret, commitment, wrapperExpiry } = makeCommitment({
+    name,
+    resolver,
+    ...params
+  });
+  return {
+    ...await controller.populateTransaction.commit(commitment),
+    customData: {
+      secret,
+      commitment,
+      wrapperExpiry
+    }
+  };
+}
+export {
+  commitName_default as default
+};

package/dist/esm/functions/createSubname.mjs

@@ -0,0 +1,61 @@
+// src/functions/createSubname.ts
+import { ethers } from "ethers";
+import generateFuseInput from "../utils/generateFuseInput.mjs";
+import { namehash } from "../utils/normalise.mjs";
+import { makeExpiry, wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
+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 = ethers.utils.solidityKeccak256(["string"], [label]);
+  const parentNodehash = namehash(labels.join("."));
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        owner,
+        resolverAddress,
+        0
+      );
+    }
+    case "nameWrapper": {
+      wrappedLabelLengthCheck(label);
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      const expiry = await makeExpiry(
+        { getExpiry },
+        name,
+        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      );
+      const generatedFuses = "fuses" in wrapperArgs && wrapperArgs.fuses ? generateFuseInput(wrapperArgs.fuses) : "0";
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        owner,
+        resolverAddress,
+        0,
+        generatedFuses,
+        expiry
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
+}
+export {
+  createSubname_default as default
+};

package/dist/esm/functions/deleteSubname.mjs

@@ -0,0 +1,42 @@
+// src/functions/deleteSubname.ts
+import { ethers } from "ethers";
+import { namehash } from "../utils/normalise.mjs";
+async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+  const labels = name.split(".");
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`);
+  }
+  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.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0
+      );
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0,
+        0,
+        0
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
+}
+export {
+  deleteSubname_default as default
+};

package/dist/esm/functions/getDNSOwner.mjs

@@ -0,0 +1,57 @@
+// src/functions/getDNSOwner.ts
+import * as packet from "dns-packet";
+function encodeURLParams(p) {
+  return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
+}
+var 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);
+};
+var 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;
+}
+export {
+  getDNSOwner_default as default,
+  dnsQuery,
+  encodeURLParams,
+  getDNS
+};

package/dist/esm/functions/getExpiry.mjs

@@ -0,0 +1,95 @@
+// src/functions/getExpiry.ts
+import { solidityKeccak256 } from "ethers/lib/utils.js";
+import { namehash } from "../utils/normalise.mjs";
+var getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
+  if (labels.length > 2 || labels[1] !== "eth") {
+    throw new Error("Only .eth names have expiry dates on the registrar");
+  }
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const expiryCall = baseRegistrar.interface.encodeFunctionData("nameExpires", [
+    solidityKeccak256(["string"], [labels[0]])
+  ]);
+  const gracePeriodCall = baseRegistrar.interface.encodeFunctionData("GRACE_PERIOD");
+  return multicallWrapper.raw([
+    {
+      to: baseRegistrar.address,
+      data: expiryCall
+    },
+    {
+      to: baseRegistrar.address,
+      data: gracePeriodCall
+    }
+  ]);
+};
+var getWrapperExpiry = async ({ contracts }, labels) => {
+  const nameWrapper = await contracts?.getNameWrapper();
+  const expiryCall = nameWrapper.interface.encodeFunctionData("getData", [
+    namehash(labels.join("."))
+  ]);
+  return {
+    to: nameWrapper.address,
+    data: expiryCall
+  };
+};
+var getContractToUse = (contract, labels) => {
+  if (contract)
+    return contract;
+  if (labels.length === 2 && labels[1] === "eth") {
+    return "registrar";
+  }
+  return "nameWrapper";
+};
+var raw = async (ensArgs, name, { contract } = {}) => {
+  const labels = name.split(".");
+  const contractToUse = getContractToUse(contract, labels);
+  return contractToUse === "nameWrapper" ? getWrapperExpiry(ensArgs, labels) : getRegistrarExpiry(ensArgs, labels);
+};
+var decodeRegistrarExpiry = async ({ contracts, multicallWrapper }, data) => {
+  const result = await multicallWrapper.decode(data);
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const [nameExpires] = baseRegistrar.interface.decodeFunctionResult(
+      "nameExpires",
+      result[0].returnData
+    );
+    const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult(
+      "GRACE_PERIOD",
+      result[1].returnData
+    );
+    return {
+      expiry: nameExpires > 0 ? new Date(nameExpires * 1e3) : null,
+      gracePeriod: gracePeriod.toNumber() * 1e3
+    };
+  } catch {
+    return;
+  }
+};
+var decodeWrapperExpiry = async ({ contracts }, data) => {
+  const nameWrapper = await contracts?.getNameWrapper();
+  try {
+    const [, , expiry] = nameWrapper.interface.decodeFunctionResult(
+      "getData",
+      data
+    );
+    return {
+      expiry: new Date(expiry * 1e3),
+      gracePeriod: null
+    };
+  } catch {
+    return;
+  }
+};
+var decode = async (ensArgs, data, name, { contract } = {}) => {
+  if (data === null)
+    return;
+  const labels = name.split(".");
+  const contractToUse = getContractToUse(contract, labels);
+  return contractToUse === "nameWrapper" ? decodeWrapperExpiry(ensArgs, data) : decodeRegistrarExpiry(ensArgs, data);
+};
+var getExpiry_default = {
+  raw,
+  decode
+};
+export {
+  getExpiry_default as default
+};