@ensdomains/ensjs 3.0.0-alpha.16 → 3.0.0-alpha.19

package/dist/cjs/functions/getName.js

@@ -1,34 +1,57 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hexEncodedName_1 = require("../utils/hexEncodedName");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getName_exports = {};
+__export(getName_exports, {
+  default: () => getName_default
+});
+module.exports = __toCommonJS(getName_exports);
+var import_hexEncodedName = require("../utils/hexEncodedName");
 const 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', [
-            (0, hexEncodedName_1.hexEncodeName)(reverseNode),
-        ]),
-    };
+  const universalResolver = await contracts?.getUniversalResolver();
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData("reverse", [
+      (0, import_hexEncodedName.hexEncodeName)(reverseNode)
+    ])
+  };
 };
 const 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: undefined };
-    }
+  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 };
+  }
 };
-exports.default = {
-    raw,
-    decode,
+var getName_default = {
+  raw,
+  decode
 };

package/dist/cjs/functions/getNames.js

@@ -1,32 +1,60 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const format_1 = require("../utils/format");
-const labels_1 = require("../utils/labels");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getNames_exports = {};
+__export(getNames_exports, {
+  default: () => getNames_default
+});
+module.exports = __toCommonJS(getNames_exports);
+var import_format = require("../utils/format");
+var import_labels = require("../utils/labels");
 const mapDomain = (domain) => {
-    const decrypted = (0, labels_1.decryptName)(domain.name);
-    return {
-        ...domain,
-        name: decrypted,
-        truncatedName: (0, format_1.truncateFormat)(decrypted),
-        createdAt: new Date(parseInt(domain.createdAt) * 1000),
-        type: 'domain',
-    };
+  const decrypted = (0, import_labels.decryptName)(domain.name);
+  return {
+    ...domain,
+    name: decrypted,
+    truncatedName: (0, import_format.truncateFormat)(decrypted),
+    createdAt: new Date(parseInt(domain.createdAt) * 1e3),
+    type: "domain"
+  };
 };
 const mapRegistration = (registration) => {
-    const decrypted = (0, labels_1.decryptName)(registration.domain.name);
-    return {
-        expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
-        registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
-        ...registration.domain,
-        name: decrypted,
-        truncatedName: (0, format_1.truncateFormat)(decrypted),
-        type: 'registration',
-    };
+  const decrypted = (0, import_labels.decryptName)(registration.domain.name);
+  return {
+    expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
+    registrationDate: new Date(parseInt(registration.registrationDate) * 1e3),
+    ...registration.domain,
+    name: decrypted,
+    truncatedName: (0, import_format.truncateFormat)(decrypted),
+    type: "registration"
+  };
 };
-const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSize = 10, orderDirection, orderBy, }) => {
-    const address = _address.toLowerCase();
-    const client = gqlInstance.client;
-    const domainQueryData = `
+const getNames = async ({ gqlInstance }, {
+  address: _address,
+  type,
+  page,
+  pageSize = 10,
+  orderDirection,
+  orderBy
+}) => {
+  const address = _address.toLowerCase();
+  const client = gqlInstance.client;
+  const domainQueryData = `
     id
     labelName
     labelhash
@@ -36,10 +64,10 @@ const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSi
         name
     }
   `;
-    let queryVars = {};
-    let finalQuery = '';
-    if (type === 'all') {
-        finalQuery = gqlInstance.gql `
+  let queryVars = {};
+  let finalQuery = "";
+  if (type === "all") {
+    finalQuery = gqlInstance.gql`
       query getNames(
         $id: ID!
         $expiryDate: Int
@@ -62,14 +90,13 @@ const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSi
         }
       }
     `;
-        queryVars = {
-            id: address,
-            expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-        };
-    }
-    else if (type === 'owner') {
-        if (typeof page !== 'number') {
-            finalQuery = gqlInstance.gql `
+    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 
@@ -83,14 +110,13 @@ const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSi
           }
         }
       `;
-            queryVars = {
-                id: address,
-                orderBy,
-                orderDirection,
-            };
-        }
-        else {
-            finalQuery = gqlInstance.gql `
+      queryVars = {
+        id: address,
+        orderBy,
+        orderDirection
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
         query getNames(
           $id: ID!
           $first: Int
@@ -111,18 +137,16 @@ const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSi
           }
         }
       `;
-            queryVars = {
-                id: address,
-                first: pageSize,
-                skip: (page || 0) * pageSize,
-                orderBy,
-                orderDirection,
-            };
-        }
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection
+      };
     }
-    else {
-        if (typeof page !== 'number') {
-            finalQuery = gqlInstance.gql `
+  } else if (typeof page !== "number") {
+    finalQuery = gqlInstance.gql`
         query getNames(
           $id: ID!
           $orderBy: Registration_orderBy
@@ -144,15 +168,14 @@ const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSi
           }
         }
       `;
-            queryVars = {
-                id: address,
-                orderBy,
-                orderDirection,
-                expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-            };
-        }
-        else {
-            finalQuery = gqlInstance.gql `
+    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
@@ -178,45 +201,36 @@ const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSi
           }
         }
       `;
-            queryVars = {
-                id: address,
-                first: pageSize,
-                skip: (page || 0) * pageSize,
-                orderBy: orderBy,
-                orderDirection: orderDirection,
-                expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-            };
+    queryVars = {
+      id: address,
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  }
+  const { account } = await client.request(finalQuery, queryVars);
+  if (type === "all") {
+    return [
+      ...account.domains.map(mapDomain),
+      ...account.registrations.map(mapRegistration)
+    ].sort((a, b) => {
+      if (orderDirection === "desc") {
+        if (orderBy === "labelName") {
+          return b.name.localeCompare(a.name);
         }
-    }
-    const { account } = await client.request(finalQuery, queryVars);
-    if (type === 'all') {
-        return [
-            ...account.domains.map(mapDomain),
-            ...account.registrations.map(mapRegistration),
-        ].sort((a, b) => {
-            if (orderDirection === 'desc') {
-                if (orderBy === 'labelName') {
-                    return b.name.localeCompare(a.name);
-                }
-                else {
-                    return b.createdAt.getTime() - a.createdAt.getTime();
-                }
-            }
-            else {
-                if (orderBy === 'labelName') {
-                    return a.name.localeCompare(b.name);
-                }
-                else if (orderBy === 'creationDate') {
-                    return a.createdAt.getTime() - b.createdAt.getTime();
-                }
-            }
-        });
-    }
-    else if (type === 'owner') {
-        return account.domains.map(mapDomain);
-    }
-    else {
-        return account.registrations.map(mapRegistration);
-    }
+        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);
+  }
+  return account.registrations.map(mapRegistration);
 };
-exports.default = getNames;
+var getNames_default = getNames;

package/dist/cjs/functions/getOwner.js

@@ -1,140 +1,162 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const labels_1 = require("../utils/labels");
-const normalise_1 = require("../utils/normalise");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getOwner_exports = {};
+__export(getOwner_exports, {
+  default: () => getOwner_default
+});
+module.exports = __toCommonJS(getOwner_exports);
+var import_ethers = require("ethers");
+var import_labels = require("../utils/labels");
+var import_normalise = require("../utils/normalise");
 const 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', [
-                    (0, labels_1.labelhash)(labels[0]),
-                ]),
-            };
-        }
+  switch (contract) {
+    case "nameWrapper": {
+      const nameWrapper = await contracts?.getNameWrapper();
+      return {
+        to: nameWrapper.address,
+        data: nameWrapper.interface.encodeFunctionData("ownerOf", [namehash])
+      };
     }
-};
-const raw = async ({ contracts, multicallWrapper }, name, contract) => {
-    const namehash = (0, normalise_1.namehash)(name);
-    const labels = name.split('.');
-    if (contract || labels.length === 1) {
-        return await singleContractOwnerRaw({ contracts }, contract || 'registry', namehash, labels);
+    case "registry": {
+      const registry = await contracts?.getRegistry();
+      return {
+        to: registry.address,
+        data: registry.interface.encodeFunctionData("owner", [namehash])
+      };
     }
-    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 (labels.length == 2 && labels[1] === 'eth') {
-        data.push(registrarData);
+    case "registrar": {
+      const registrar = await contracts?.getBaseRegistrar();
+      return {
+        to: registrar.address,
+        data: registrar.interface.encodeFunctionData("ownerOf", [
+          (0, import_labels.labelhash)(labels[0])
+        ])
+      };
     }
-    return multicallWrapper.raw(data);
+  }
+};
+const raw = async ({ contracts, multicallWrapper }, name, contract) => {
+  const namehash = (0, import_normalise.namehash)(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 (labels.length === 2 && labels[1] === "eth") {
+    data.push(registrarData);
+  }
+  return multicallWrapper.raw(data);
 };
-const singleContractOwnerDecode = (data) => ethers_1.ethers.utils.defaultAbiCoder.decode(['address'], data)[0];
+const singleContractOwnerDecode = (data) => import_ethers.ethers.utils.defaultAbiCoder.decode(["address"], data)[0];
 const decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
-    if (data === null)
-        return;
-    const labels = name.split('.');
-    if (contract || labels.length === 1) {
-        const singleOwner = singleContractOwnerDecode(data);
-        let obj = {
-            ownershipLevel: contract || 'registry',
-        };
-        if (contract === 'registrar') {
-            return {
-                ...obj,
-                registrant: singleOwner,
-            };
-        }
-        else {
-            return {
-                ...obj,
-                owner: singleOwner,
-            };
-        }
+  if (data === null)
+    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
+      };
     }
-    const result = await multicallWrapper.decode(data);
-    if (result === null)
-        return;
-    const nameWrapper = await contracts?.getNameWrapper();
-    const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map((ret) => ret &&
-        ret !== '0x' &&
-        ethers_1.ethers.utils.defaultAbiCoder.decode(['address'], ret));
-    const registryOwner = decodedData[0][0];
-    const nameWrapperOwner = decodedData[1][0];
-    const registrarOwner = decodedData[2]?.[0];
-    // check for only .eth names
-    if (labels[labels.length - 1] === 'eth') {
-        // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
-        // there is no "registrant" for wrapped names
-        if (registrarOwner === nameWrapper.address) {
-            return {
-                owner: nameWrapperOwner,
-                ownershipLevel: 'nameWrapper',
-            };
-        }
-        // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
-        // this means that it's an unwrapped second-level name
-        // the registrant is the owner of the NFT
-        // the owner is the controller of the records
-        if (registrarOwner) {
-            return {
-                registrant: registrarOwner,
-                owner: registryOwner,
-                ownershipLevel: 'registrar',
-            };
-        }
-        if (labels.length > 2 &&
-            ethers_1.ethers.utils.hexStripZeros(registryOwner) !== '0x') {
-            // this means that the subname is wrapped
-            if (registryOwner === nameWrapper.address) {
-                return {
-                    owner: nameWrapperOwner,
-                    ownershipLevel: 'nameWrapper',
-                };
-            }
-            // unwrapped subnames do not have NFTs associated, so do not have a registrant
-            return {
-                owner: registryOwner,
-                ownershipLevel: 'registry',
-            };
-        }
-        // .eth names with no registrar owner are either unregistered or expired
-        return;
+    return {
+      ...obj,
+      owner: singleOwner
+    };
+  }
+  const result = await multicallWrapper.decode(data);
+  if (result === null)
+    return;
+  const nameWrapper = await contracts?.getNameWrapper();
+  const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
+    (ret) => ret && ret !== "0x" && import_ethers.ethers.utils.defaultAbiCoder.decode(["address"], ret)
+  );
+  const registryOwner = decodedData[0][0];
+  const nameWrapperOwner = decodedData[1][0];
+  const registrarOwner = decodedData[2]?.[0];
+  if (labels[labels.length - 1] === "eth") {
+    if (registrarOwner === nameWrapper.address) {
+      return {
+        owner: nameWrapperOwner,
+        ownershipLevel: "nameWrapper"
+      };
     }
-    // non .eth names inherit the owner from the registry
-    // there will only ever be an owner for non .eth names, not a registrant
-    // this is because for unwrapped names, there is no associated NFT
-    // and for wrapped names, owner and registrant are the same thing
-    if (registryOwner == nameWrapper.address) {
-        return {
-            owner: nameWrapperOwner,
-            ownershipLevel: 'nameWrapper',
-        };
+    if (registrarOwner) {
+      return {
+        registrant: registrarOwner,
+        owner: registryOwner,
+        ownershipLevel: "registrar"
+      };
     }
-    // for unwrapped non .eth names, the owner is the registry owner
-    if (ethers_1.ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+    if (labels.length > 2 && import_ethers.ethers.utils.hexStripZeros(registryOwner) !== "0x") {
+      if (registryOwner === nameWrapper.address && import_ethers.ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
         return {
-            owner: registryOwner,
-            ownershipLevel: 'registry',
+          owner: nameWrapperOwner,
+          ownershipLevel: "nameWrapper"
         };
+      }
+      return {
+        owner: registryOwner,
+        ownershipLevel: "registry"
+      };
     }
-    // for anything else, return
     return;
+  }
+  if (registryOwner === nameWrapper.address && import_ethers.ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+    return {
+      owner: nameWrapperOwner,
+      ownershipLevel: "nameWrapper"
+    };
+  }
+  if (import_ethers.ethers.utils.hexStripZeros(registryOwner) !== "0x") {
+    return {
+      owner: registryOwner,
+      ownershipLevel: "registry"
+    };
+  }
+  return;
 };
-exports.default = { raw, decode };
+var getOwner_default = { raw, decode };