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

package/dist/esm/functions/commitName.mjs

@@ -0,0 +1,28 @@
+// src/functions/commitName.ts
+import { makeCommitment } from "../utils/registerHelpers.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");
+  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,60 @@
+// src/functions/createSubname.ts
+import { ethers } from "ethers";
+import generateFuseInput from "../utils/generateFuseInput.mjs";
+import { namehash } from "../utils/normalise.mjs";
+import { makeExpiry } from "../utils/wrapperExpiry.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": {
+      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,45 @@
+// 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("ENS.js currently only supports deleting 2LDs, not TLDs");
+  }
+  if (labels[2] !== "eth") {
+    throw new Error("ENS.js currently only supports deleting .eth 2LDs");
+  }
+  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
+};

package/dist/esm/functions/getFuses.mjs

@@ -0,0 +1,50 @@
+// src/functions/getFuses.ts
+import { BigNumber } from "ethers";
+import { fuseEnum } 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: _fuses,
+      expiry
+    } = nameWrapper.interface.decodeFunctionResult("getData", data);
+    const fuses = BigNumber.from(_fuses);
+    const fuseObj = Object.fromEntries(
+      Object.keys(fuseEnum).map((fuse) => [
+        fuse,
+        fuses.and(fuseEnum[fuse]).gt(0)
+      ])
+    );
+    if (fuses.eq(0)) {
+      fuseObj.CAN_DO_EVERYTHING = true;
+    } else {
+      fuseObj.CAN_DO_EVERYTHING = false;
+    }
+    const expiryDate = new Date(expiry * 1e3);
+    return {
+      fuseObj,
+      expiryDate,
+      rawFuses: fuses,
+      owner
+    };
+  } catch (e) {
+    console.error("Error decoding fuses data: ", e);
+    return;
+  }
+};
+var getFuses_default = {
+  raw,
+  decode
+};
+export {
+  getFuses_default as default
+};

package/dist/esm/functions/getHistory.mjs

@@ -0,0 +1,196 @@
+// src/functions/getHistory.ts
+import { formatsByCoinType } from "@ensdomains/address-encoder";
+import { ethers } from "ethers";
+import { decodeContenthash } from "../utils/contentHash.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 })
+  },
+  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 (ethers.utils.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
+    })
+  }
+};
+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($name: String!, $label: String!) {
+        domains(where: { name: $name }) {
+          events {
+            id
+            blockNumber
+            transactionID
+            __typename
+            ...on Transfer {
+              owner {
+                id
+              }
+            }
+            ...on NewOwner {
+              owner {
+                id
+              }
+            }
+            ...on NewResolver {
+              resolver {
+                id
+              }
+            }
+            ...on NewTTL {
+              ttl
+            }
+          }
+          owner {
+            registrations (where: { labelName: $label }) {
+              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
+              }
+            }
+          }
+        }
+      }
+      `;
+  const label = name.split(".")[0];
+  const { domains } = await client.request(query, { name, label });
+  if (!domains || domains.length === 0)
+    return;
+  const [
+    {
+      events: domainEvents,
+      owner: {
+        registrations: [{ events: registrationEvents }]
+      },
+      resolver: { events: resolverEvents }
+    }
+  ] = domains;
+  const domainHistory = mapEvents(domainEvents, "Domain");
+  const registrationHistory = mapEvents(registrationEvents, "Registration");
+  const resolverHistory = mapEvents(
+    resolverEvents.filter(
+      (event) => !event.coinType || event.coinType !== "60"
+    ),
+    "Resolver"
+  );
+  return {
+    domain: domainHistory,
+    registration: registrationHistory,
+    resolver: resolverHistory
+  };
+}
+export {
+  getHistory
+};

package/dist/esm/functions/getName.mjs

@@ -0,0 +1,38 @@
+// src/functions/getName.ts
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+var raw = async ({ contracts }, address) => {
+  const universalResolver = await contracts?.getUniversalResolver();
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData("reverse", [
+      hexEncodeName(reverseNode)
+    ])
+  };
+};
+var decode = async ({ contracts }, data, address) => {
+  if (data === null)
+    return;
+  const universalResolver = await contracts?.getUniversalResolver();
+  try {
+    const result = universalResolver.interface.decodeFunctionResult(
+      "reverse",
+      data
+    );
+    return {
+      name: result["0"],
+      match: result["1"].toLowerCase() === address.toLowerCase(),
+      reverseResolverAddress: result["2"],
+      resolverAddress: result["3"]
+    };
+  } catch {
+    return { name: void 0 };
+  }
+};
+var getName_default = {
+  raw,
+  decode
+};
+export {
+  getName_default as default
+};