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

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(bytes)", [
+      hexEncodeName(reverseNode)
+    ])
+  };
+};
+var decode = async ({ contracts }, data, address) => {
+  if (data === null)
+    return;
+  const universalResolver = await contracts?.getUniversalResolver();
+  try {
+    const result = universalResolver.interface.decodeFunctionResult(
+      "reverse(bytes)",
+      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
+};

package/dist/esm/functions/getNames.mjs

@@ -0,0 +1,324 @@
+// src/functions/getNames.ts
+import { truncateFormat } from "../utils/format.mjs";
+import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
+import { decryptName } from "../utils/labels.mjs";
+var mapDomain = ({ name, ...domain }) => {
+  const decrypted = name ? decryptName(name) : void 0;
+  return {
+    ...domain,
+    ...domain.registration ? {
+      registration: {
+        expiryDate: new Date(
+          parseInt(domain.registration.expiryDate) * 1e3
+        ),
+        registrationDate: new Date(
+          parseInt(domain.registration.registrationDate) * 1e3
+        )
+      }
+    } : {},
+    name: decrypted,
+    truncatedName: decrypted ? truncateFormat(decrypted) : void 0,
+    createdAt: new Date(parseInt(domain.createdAt) * 1e3),
+    type: "domain"
+  };
+};
+var mapWrappedDomain = (wrappedDomain) => {
+  const expiryDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+  if (expiryDate && expiryDate < new Date() && checkPCCBurned(wrappedDomain.fuses)) {
+    return null;
+  }
+  const domain = mapDomain(wrappedDomain.domain);
+  return {
+    expiryDate,
+    fuses: decodeFuses(wrappedDomain.fuses),
+    ...domain,
+    type: "wrappedDomain"
+  };
+};
+var mapRegistration = (registration) => {
+  const decrypted = decryptName(registration.domain.name);
+  return {
+    expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
+    registrationDate: new Date(parseInt(registration.registrationDate) * 1e3),
+    ...registration.domain,
+    name: decrypted,
+    truncatedName: truncateFormat(decrypted),
+    type: "registration"
+  };
+};
+var getNames = async ({ gqlInstance }, {
+  address: _address,
+  type,
+  page,
+  pageSize = 10,
+  orderDirection,
+  orderBy = "labelName"
+}) => {
+  const address = _address.toLowerCase();
+  const client = gqlInstance.client;
+  const domainQueryData = `
+    id
+    labelName
+    labelhash
+    name
+    isMigrated
+    parent {
+        name
+    }
+    createdAt
+  `;
+  let queryVars = {};
+  let finalQuery = "";
+  if (type === "all") {
+    finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          registrations(
+            first: 1000
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            registrationDate
+            expiryDate
+            domain {
+              ${domainQueryData}
+            }
+          }
+          domains(first: 1000) {
+            ${domainQueryData}
+            registration {
+              registrationDate
+              expiryDate
+            }
+          }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
+        }
+      }
+    `;
+    queryVars = {
+      id: address,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  } else if (type === "owner") {
+    if (typeof page !== "number") {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID! 
+          $orderBy: Domain_orderBy 
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(orderBy: $orderBy, orderDirection: $orderDirection) {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
+        }
+      `;
+      queryVars = {
+        id: address,
+        orderBy,
+        orderDirection
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Domain_orderBy
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+            ) {
+              ${domainQueryData}
+            }
+          }
+        }
+      `;
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection
+      };
+    }
+  } else if (type === "wrappedOwner") {
+    if (typeof page !== "number") {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $first: Int
+        $skip: Int
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            first: $first
+            skip: $skip
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy: orderBy === "labelName" ? "name" : orderBy,
+        orderDirection
+      };
+    }
+  } else if (typeof page !== "number") {
+    finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `;
+    queryVars = {
+      id: address,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  } else {
+    finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `;
+    queryVars = {
+      id: address,
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  }
+  const response = await client.request(finalQuery, queryVars);
+  const account = response?.account;
+  if (type === "all") {
+    return [
+      ...account?.domains.map(mapDomain) || [],
+      ...account?.registrations.map(mapRegistration) || [],
+      ...account?.wrappedDomains.map(mapWrappedDomain).filter((d) => d) || []
+    ].sort((a, b) => {
+      if (orderDirection === "desc") {
+        if (orderBy === "labelName") {
+          return b.name.localeCompare(a.name);
+        }
+        return b.createdAt.getTime() - a.createdAt.getTime();
+      }
+      if (orderBy === "labelName") {
+        return a.name.localeCompare(b.name);
+      }
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+  }
+  if (type === "owner") {
+    return account?.domains.map(mapDomain) || [];
+  }
+  if (type === "wrappedOwner") {
+    return account?.wrappedDomains.map(mapWrappedDomain).filter((d) => d) || [];
+  }
+  return account?.registrations.map(mapRegistration) || [];
+};
+var getNames_default = getNames;
+export {
+  getNames_default as default
+};

package/dist/esm/functions/getOwner.mjs

@@ -0,0 +1,189 @@
+// src/functions/getOwner.ts
+import { defaultAbiCoder } from "@ethersproject/abi";
+import { hexStripZeros } from "@ethersproject/bytes";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash as makeNamehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
+var singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
+  switch (contract) {
+    case "nameWrapper": {
+      const nameWrapper = await contracts?.getNameWrapper();
+      return {
+        to: nameWrapper.address,
+        data: nameWrapper.interface.encodeFunctionData("ownerOf", [namehash])
+      };
+    }
+    case "registry": {
+      const registry = await contracts?.getRegistry();
+      return {
+        to: registry.address,
+        data: registry.interface.encodeFunctionData("owner", [namehash])
+      };
+    }
+    case "registrar": {
+      const registrar = await contracts?.getBaseRegistrar();
+      return {
+        to: registrar.address,
+        data: registrar.interface.encodeFunctionData("ownerOf", [
+          labelhash(labels[0])
+        ])
+      };
+    }
+  }
+};
+var raw = async ({ contracts, multicallWrapper }, name, contract) => {
+  const namehash = makeNamehash(name);
+  const labels = name.split(".");
+  if (contract || labels.length === 1) {
+    return singleContractOwnerRaw(
+      { contracts },
+      contract || "registry",
+      namehash,
+      labels
+    );
+  }
+  const registryData = await singleContractOwnerRaw(
+    { contracts },
+    "registry",
+    namehash,
+    labels
+  );
+  const nameWrapperData = await singleContractOwnerRaw(
+    { contracts },
+    "nameWrapper",
+    namehash,
+    labels
+  );
+  const registrarData = await singleContractOwnerRaw(
+    { contracts },
+    "registrar",
+    namehash,
+    labels
+  );
+  const data = [registryData, nameWrapperData];
+  if (checkIsDotEth(labels)) {
+    data.push(registrarData);
+  }
+  return multicallWrapper.raw(data);
+};
+var registrantQuery = `
+  query GetRegistrant($namehash: String!) {
+    domain(id: $namehash) {
+      registration {
+        registrant {
+          id
+        }
+      }
+    }
+  }
+`;
+var singleContractOwnerDecode = (data) => defaultAbiCoder.decode(["address"], data)[0];
+var decode = async ({
+  contracts,
+  multicallWrapper,
+  gqlInstance
+}, data, name, contract) => {
+  if (!data)
+    return;
+  const labels = name.split(".");
+  if (contract || labels.length === 1) {
+    const singleOwner = singleContractOwnerDecode(data);
+    const obj = {
+      ownershipLevel: contract || "registry"
+    };
+    if (contract === "registrar") {
+      return {
+        ...obj,
+        registrant: singleOwner
+      };
+    }
+    return {
+      ...obj,
+      owner: singleOwner
+    };
+  }
+  const result = await multicallWrapper.decode(data);
+  if (!result)
+    return;
+  const nameWrapper = await contracts?.getNameWrapper();
+  const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
+    (ret) => ret && ret !== "0x" && defaultAbiCoder.decode(["address"], ret)
+  );
+  const registryOwner = decodedData[0][0];
+  const nameWrapperOwner = decodedData[1][0];
+  let registrarOwner = decodedData[2]?.[0];
+  let baseReturnObject = {};
+  if (labels[labels.length - 1] === "eth") {
+    if (labels.length === 2) {
+      if (!registrarOwner) {
+        const graphRegistrantResult = await gqlInstance.client.request(
+          registrantQuery,
+          {
+            namehash: makeNamehash(name)
+          }
+        );
+        registrarOwner = graphRegistrantResult.domain?.registration?.registrant?.id;
+        baseReturnObject = {
+          expired: true
+        };
+      } else {
+        baseReturnObject = {
+          expired: false
+        };
+      }
+    }
+    if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
+      return {
+        owner: nameWrapperOwner,
+        ownershipLevel: "nameWrapper",
+        ...baseReturnObject
+      };
+    }
+    if (registrarOwner) {
+      return {
+        registrant: registrarOwner,
+        owner: registryOwner,
+        ownershipLevel: "registrar",
+        ...baseReturnObject
+      };
+    }
+    if (hexStripZeros(registryOwner) !== "0x") {
+      if (labels.length === 2) {
+        return {
+          registrant: void 0,
+          owner: registryOwner,
+          ownershipLevel: "registrar",
+          expired: true
+        };
+      }
+      if (registryOwner === nameWrapper.address && nameWrapperOwner && hexStripZeros(nameWrapperOwner) !== "0x") {
+        return {
+          owner: nameWrapperOwner,
+          ownershipLevel: "nameWrapper"
+        };
+      }
+      return {
+        owner: registryOwner,
+        ownershipLevel: "registry"
+      };
+    }
+    return;
+  }
+  if (registryOwner === nameWrapper.address && nameWrapperOwner && hexStripZeros(nameWrapperOwner) !== "0x") {
+    return {
+      owner: nameWrapperOwner,
+      ownershipLevel: "nameWrapper"
+    };
+  }
+  if (hexStripZeros(registryOwner) !== "0x") {
+    return {
+      owner: registryOwner,
+      ownershipLevel: "registry"
+    };
+  }
+  return;
+};
+var getOwner_default = { raw, decode };
+export {
+  getOwner_default as default
+};

package/dist/esm/functions/getPrice.mjs

@@ -0,0 +1,107 @@
+// src/functions/getPrice.ts
+import { defaultAbiCoder } from "@ethersproject/abi";
+import { BigNumber } from "@ethersproject/bignumber";
+var raw = async ({ contracts, multicallWrapper }, nameOrNames, duration, legacy) => {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  if (names.length > 1) {
+    const bulkRenewal = await contracts?.getBulkRenewal();
+    const baseCall2 = {
+      to: bulkRenewal.address,
+      data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+        names,
+        duration
+      ])
+    };
+    if (legacy) {
+      return multicallWrapper.raw([
+        baseCall2,
+        {
+          to: bulkRenewal.address,
+          data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+            names,
+            0
+          ])
+        }
+      ]);
+    }
+    return baseCall2;
+  }
+  const controller = await contracts?.getEthRegistrarController();
+  const baseCall = {
+    to: controller.address,
+    data: controller.interface.encodeFunctionData("rentPrice", [
+      names[0],
+      duration
+    ])
+  };
+  if (legacy) {
+    return multicallWrapper.raw([
+      baseCall,
+      {
+        to: controller.address,
+        data: controller.interface.encodeFunctionData("rentPrice", [
+          names[0],
+          0
+        ])
+      }
+    ]);
+  }
+  return baseCall;
+};
+var decode = async ({ contracts, multicallWrapper }, data, _nameOrNames, _duration, legacy) => {
+  if (data === null)
+    return;
+  try {
+    let base;
+    let premium;
+    const isBulkRenewal = Array.isArray(_nameOrNames) && _nameOrNames.length > 1;
+    if (isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else if (isBulkRenewal) {
+      const bulkRenewal = await contracts?.getBulkRenewal();
+      const result = bulkRenewal.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+      [base] = result;
+      premium = BigNumber.from(0);
+    } else if (!isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else {
+      const controller = await contracts?.getEthRegistrarController();
+      const result = controller.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+      [base, premium] = result[0];
+    }
+    return {
+      base,
+      premium
+    };
+  } catch {
+    return;
+  }
+};
+var getPrice_default = { raw, decode };
+export {
+  getPrice_default as default
+};