@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.51

package/dist/esm/functions/commitName.mjs

@@ -0,0 +1,29 @@
+// 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 } = makeCommitment({
+    name,
+    resolver,
+    ...params
+  });
+  return {
+    ...await controller.populateTransaction.commit(commitment),
+    customData: {
+      secret,
+      commitment
+    }
+  };
+}
+export {
+  commitName_default as default
+};

package/dist/esm/functions/createSubname.mjs

@@ -0,0 +1,61 @@
+// src/functions/createSubname.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import { encodeFuses } from "../utils/fuses.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 = 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 ? encodeFuses(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,52 @@
+// src/functions/deleteSubname.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import { namehash } from "../utils/normalise.mjs";
+async function deleteSubname_default({ contracts, signer }, name, { contract, ...args }) {
+  const labels = name.split(".");
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`);
+  }
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      const label = labels.shift();
+      const labelhash = solidityKeccak256(["string"], [label]);
+      const parentNodehash = namehash(labels.join("."));
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0
+      );
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      const { method } = args;
+      if (method === "setRecord") {
+        const node = namehash(name);
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          "0x0000000000000000000000000000000000000000",
+          "0x0000000000000000000000000000000000000000",
+          0
+        );
+      }
+      const label = labels.shift();
+      const parentNodehash = namehash(labels.join("."));
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        "0x0000000000000000000000000000000000000000",
+        0,
+        0
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
+}
+export {
+  deleteSubname_default as default
+};

package/dist/esm/functions/getAvailable.mjs

@@ -0,0 +1,36 @@
+// src/functions/getAvailable.ts
+import { labelhash } from "../utils/labels.mjs";
+var raw = async ({ contracts }, name) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth") {
+    throw new Error("Currently only .eth names can be checked for availability");
+  }
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData("available", [
+      labelhash(labels[0])
+    ])
+  };
+};
+var decode = async ({ contracts }, data) => {
+  if (data === null)
+    return;
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      "available",
+      data
+    );
+    return result["0"];
+  } catch {
+    return;
+  }
+};
+var getAvailable_default = {
+  raw,
+  decode
+};
+export {
+  getAvailable_default as default
+};

package/dist/esm/functions/getDNSOwner.mjs

@@ -0,0 +1,60 @@
+// src/functions/getDNSOwner.ts
+import { _fetchData } from "@ethersproject/web";
+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 url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: "application/dns-udpwireformat",
+    dns: packet.encode(q)?.toString("base64"),
+    ts: Date.now().toString()
+  })}`;
+  const response = await _fetchData(url, void 0);
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset
+  );
+  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/getDecryptedName.mjs

@@ -0,0 +1,96 @@
+// src/functions/getDecryptedName.ts
+import { hexStripZeros } from "@ethersproject/bytes";
+import { hexDecodeName } from "../utils/hexEncodedName.mjs";
+import {
+  checkIsDecrypted,
+  decodeLabelhash,
+  getEncryptedLabelAmount,
+  isEncodedLabelhash
+} from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.mjs";
+var raw = async ({ contracts }, name, allowIncomplete) => {
+  const nameWrapper = await contracts?.getNameWrapper();
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData("names", [namehash(name)])
+  };
+};
+var generateNameQuery = (labels) => {
+  let query = "";
+  for (let i = 0; i < labels.length; i += 1) {
+    const label = labels[i];
+    if (isEncodedLabelhash(label)) {
+      query += `
+        label${i}: domains(where: { labelhash: "${decodeLabelhash(
+        label
+      ).toLowerCase()}", labelName_not: null }) {
+          labelName
+        }
+      `;
+    }
+  }
+  return query;
+};
+var decode = async ({ contracts, gqlInstance }, data, name, allowIncomplete = false) => {
+  if (data !== null) {
+    const nameWrapper = await contracts?.getNameWrapper();
+    try {
+      const result = nameWrapper.interface.decodeFunctionResult("names", data);
+      if (hexStripZeros(result["0"]) !== "0x") {
+        const decoded = hexDecodeName(result["0"]);
+        if (decoded && decoded !== ".")
+          return decoded;
+      }
+    } catch (e) {
+      console.error("Error decoding name: ", e);
+      return;
+    }
+  }
+  if (checkIsDecrypted(name))
+    return name;
+  const labels = name.split(".");
+  const decryptedNameQuery = gqlInstance.gql`
+        query decodedName($id: String!) {
+          namehashLookup: domains(where: { id: $id }) {
+            name
+          }
+          ${generateNameQuery(labels)}
+        }
+      `;
+  const decryptedNameResult = await gqlInstance.client.request(
+    decryptedNameQuery,
+    {
+      id: namehash(name)
+    }
+  );
+  if (!decryptedNameResult)
+    return;
+  const namehashLookupResult = decryptedNameResult?.namehashLookup[0]?.name;
+  let bestResult = namehashLookupResult;
+  if (namehashLookupResult && checkIsDecrypted(namehashLookupResult)) {
+    return namehashLookupResult;
+  }
+  const { namehashLookup: _, ...labelNames } = decryptedNameResult;
+  if (Object.keys(labelNames).length !== 0) {
+    for (const [key, value] of Object.entries(
+      labelNames
+    )) {
+      if (value.length && value[0].labelName) {
+        labels[parseInt(key.replace("label", ""))] = value[0].labelName;
+      }
+    }
+    const labelLookupResult = labels.join(".");
+    if (!namehashLookupResult || getEncryptedLabelAmount(namehashLookupResult) > getEncryptedLabelAmount(labelLookupResult))
+      bestResult = labelLookupResult;
+  }
+  if (!bestResult || !allowIncomplete && !checkIsDecrypted(bestResult))
+    return;
+  return bestResult;
+};
+var getDecryptedName_default = {
+  raw,
+  decode
+};
+export {
+  getDecryptedName_default as default
+};

package/dist/esm/functions/getExpiry.mjs

@@ -0,0 +1,96 @@
+// src/functions/getExpiry.ts
+import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+import { namehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.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 (checkIsDotEth(labels)) {
+    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
+};

package/dist/esm/functions/getHistory.mjs

@@ -0,0 +1,245 @@
+// src/functions/getHistory.ts
+import { formatsByCoinType } from "@ensdomains/address-encoder";
+import { hexStripZeros } from "@ethersproject/bytes";
+import { decodeContenthash } from "../utils/contentHash.mjs";
+import { namehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
+var eventFormat = {
+  Domain: {
+    NewOwner: (args) => ({ owner: args.owner.id }),
+    NewResolver: (args) => ({
+      resolver: args.resolver.id.split("-")[0]
+    }),
+    Transfer: (args) => ({ owner: args.owner.id }),
+    NewTTL: (args) => ({ ttl: args.ttl }),
+    WrappedTransfer: (args) => ({ owner: args.owner.id }),
+    NameWrapped: (args) => ({
+      fuses: args.fuses,
+      owner: args.owner.id,
+      expiryDate: args.expiryDate
+    }),
+    NameUnwrapped: (args) => ({ owner: args.owner.id }),
+    FusesSet: (args) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args) => ({ expiryDate: args.expiryDate })
+  },
+  Registration: {
+    NameRegistered: (args) => ({
+      registrant: args.registrant.id,
+      expiryDate: args.expiryDate
+    }),
+    NameRenewed: (args) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args) => ({ owner: args.newOwner.id })
+  },
+  Resolver: {
+    AddrChanged: (args) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (args) => {
+      const format = formatsByCoinType[parseInt(args.coinType)];
+      if (!format) {
+        return {
+          coinType: args.coinType,
+          rawAddr: args.multiaddr
+        };
+      }
+      if (hexStripZeros(args.multiaddr) === "0x") {
+        return {
+          coinType: args.coinType,
+          coinName: format.name,
+          rawAddr: "0x"
+        };
+      }
+      return {
+        coinType: args.coinType,
+        coinName: format.name,
+        addr: format.encoder(Buffer.from(args.multiaddr.slice(2), "hex"))
+      };
+    },
+    NameChanged: (args) => ({ name: args.name }),
+    AbiChanged: (args) => ({ contentType: args.contentType }),
+    PubkeyChanged: (args) => ({ x: args.x, y: args.y }),
+    TextChanged: (args) => ({ key: args.key, value: args.value }),
+    ContenthashChanged: (args) => ({
+      hash: decodeContenthash(args.hash)
+    }),
+    InterfaceChanged: (args) => ({
+      interfaceId: args.interfaceID,
+      implementer: args.implementer
+    }),
+    AuthorisationChanged: (args) => ({
+      owner: args.owner,
+      target: args.target,
+      isAuthorized: args.isAuthorized
+    }),
+    VersionChanged: (args) => ({ version: args.version })
+  }
+};
+var mapEvents = (eventArray, type) => eventArray.map(
+  (event) => ({
+    type: event.__typename,
+    blockNumber: event.blockNumber,
+    transactionHash: event.transactionID,
+    id: event.id,
+    data: eventFormat[type][event.__typename](event)
+  })
+);
+async function getHistory({ gqlInstance }, name) {
+  const { client } = gqlInstance;
+  const query = gqlInstance.gql`
+      query getHistory($namehash: String!) {
+        domain(id: $namehash) {
+          events {
+            id
+            blockNumber
+            transactionID
+            __typename
+            ...on Transfer {
+              owner {
+                id
+              }
+            }
+            ...on NewOwner {
+              owner {
+                id
+              }
+            }
+            ...on NewResolver {
+              resolver {
+                id
+              }
+            }
+            ...on NewTTL {
+              ttl
+            }
+            ...on WrappedTransfer {
+              owner {
+                id
+              }
+            }
+            ...on NameWrapped {
+              fuses
+              expiryDate
+              owner {
+                id
+              }
+            }
+            ...on NameUnwrapped {
+              owner {
+                id
+              }
+            }
+            ...on FusesSet {
+              fuses
+            }
+            ...on ExpiryExtended {
+              expiryDate
+            }
+          }
+          registration {
+            events {
+              id
+              blockNumber
+              transactionID
+              __typename
+              ...on NameRegistered {
+                registrant {
+                  id
+                }
+                expiryDate
+              }
+              ...on NameRenewed {
+                expiryDate
+              }
+              ...on NameTransferred {
+                newOwner {
+                  id
+                }
+              }
+            }
+          }
+          resolver {
+            events {
+              id
+              blockNumber
+              transactionID
+              __typename
+              ...on AddrChanged {
+                addr {
+                  id
+                }
+              }
+              ...on MulticoinAddrChanged {
+                coinType
+                multiaddr: addr
+              }
+              ...on NameChanged {
+                name
+              }
+              ...on AbiChanged {
+                contentType
+              }
+              ...on PubkeyChanged {
+                x
+                y
+              }
+              ...on TextChanged {
+                key
+                value
+              }
+              ...on ContenthashChanged {
+                hash
+              }
+              ...on InterfaceChanged {
+                interfaceID
+                implementer
+              }
+              ...on AuthorisationChanged {
+                owner
+                target
+                isAuthorized
+              }
+              ...on VersionChanged {
+                version
+              }
+            }
+          }
+        }
+      }
+      `;
+  const nameHash = namehash(name);
+  const labels = name.split(".");
+  const is2ldEth = checkIsDotEth(labels);
+  const response = await client.request(query, {
+    namehash: nameHash
+  });
+  const domain = response?.domain;
+  if (!domain)
+    return;
+  const {
+    events: domainEvents,
+    resolver: { events: resolverEvents }
+  } = domain;
+  const domainHistory = mapEvents(domainEvents, "Domain");
+  const resolverHistory = mapEvents(
+    resolverEvents.filter(
+      (event) => !event.coinType || event.coinType !== "60"
+    ),
+    "Resolver"
+  );
+  if (is2ldEth) {
+    const {
+      registration: { events: registrationEvents }
+    } = domain;
+    const registrationHistory = mapEvents(registrationEvents, "Registration");
+    return {
+      domain: domainHistory,
+      registration: registrationHistory,
+      resolver: resolverHistory
+    };
+  }
+  return {
+    domain: domainHistory,
+    resolver: resolverHistory
+  };
+}
+export {
+  getHistory
+};