@ensdomains/ensjs 3.0.0-alpha.52 → 3.0.0-alpha.54

package/dist/cjs/functions/getProfile.js

@@ -23,11 +23,11 @@ __export(getProfile_exports, {
 module.exports = __toCommonJS(getProfile_exports);
 var import_address_encoder = require("@ensdomains/address-encoder");
 var import_abi = require("@ethersproject/abi");
+var import_address = require("@ethersproject/address");
 var import_bytes = require("@ethersproject/bytes");
 var import_contentHash = require("../utils/contentHash");
 var import_hexEncodedName = require("../utils/hexEncodedName");
 var import_normalise = require("../utils/normalise");
-var import_validation = require("../utils/validation");
 const makeMulticallData = async ({
   _getAddr,
   _getContentHash,
@@ -468,11 +468,8 @@ async function getProfile_default({
       options.fallback.coinTypes = options.fallback.coinTypes.map(mapCoinTypes);
     }
   }
-  const inputType = (0, import_validation.parseInputType)(nameOrAddress);
-  if (inputType.type === "unknown" || inputType.info === "unsupported") {
-    throw new Error("Invalid input type");
-  }
-  if (inputType.type === "address") {
+  const inputIsAddress = (0, import_address.isAddress)(nameOrAddress);
+  if (inputIsAddress) {
     return getProfileFromAddress(
       {
         contracts,

package/dist/cjs/functions/initialGetters.js

@@ -32,7 +32,6 @@ __export(initialGetters_exports, {
   getOwner: () => import_getOwner.default,
   getPrice: () => import_getPrice.default,
   getProfile: () => import_getProfile.default,
-  getRecords: () => import_getRecords.default,
   getSubnames: () => import_getSubnames.default,
   supportsTLD: () => import_supportsTLD.default
 });
@@ -45,7 +44,6 @@ var import_getNames = __toESM(require("./getNames"));
 var import_getOwner = __toESM(require("./getOwner"));
 var import_getPrice = __toESM(require("./getPrice"));
 var import_getProfile = __toESM(require("./getProfile"));
-var import_getRecords = __toESM(require("./getRecords"));
 __reExport(initialGetters_exports, require("./getSpecificRecord"), module.exports);
 var import_getSubnames = __toESM(require("./getSubnames"));
 var import_supportsTLD = __toESM(require("./supportsTLD"));

package/dist/cjs/index.js

@@ -188,11 +188,6 @@ class ENS {
       ],
       "getProfile"
     );
-    this.getRecords = this.generateFunction(
-      "initialGetters",
-      ["getProfile"],
-      "getRecords"
-    );
     this.getName = this.generateRawFunction(
       "initialGetters",
       ["contracts"],

package/dist/cjs/utils/consts.js

@@ -19,8 +19,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var consts_exports = {};
 __export(consts_exports, {
   EMPTY_ADDRESS: () => EMPTY_ADDRESS,
-  MAX_INT_64: () => MAX_INT_64
+  MAX_INT_64: () => MAX_INT_64,
+  MINIMUM_DOT_ETH_CHARS: () => MINIMUM_DOT_ETH_CHARS
 });
 module.exports = __toCommonJS(consts_exports);
 const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
 const MAX_INT_64 = BigInt("18446744073709551615");
+const MINIMUM_DOT_ETH_CHARS = 3;

package/dist/cjs/utils/validation.js

@@ -19,70 +19,64 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var validation_exports = {};
 __export(validation_exports, {
   checkIsDotEth: () => checkIsDotEth,
-  parseInputType: () => parseInputType,
-  validateName: () => validateName,
-  validateTLD: () => validateTLD
+  parseInput: () => parseInput,
+  validateName: () => validateName
 });
 module.exports = __toCommonJS(validation_exports);
-var import_address = require("@ethersproject/address");
+var import_consts = require("./consts");
 var import_labels = require("./labels");
 var import_normalise = require("./normalise");
 const validateName = (name) => {
   const nameArray = name.split(".");
-  const hasEmptyLabels = nameArray.some((label) => label.length === 0);
-  if (hasEmptyLabels)
-    throw new Error("Name cannot have empty labels");
-  const normalizedArray = nameArray.map((label) => {
+  const normalisedArray = nameArray.map((label) => {
+    if (label.length === 0)
+      throw new Error("Name cannot have empty labels");
     if (label === "[root]") {
+      if (name !== label)
+        throw new Error("Root label must be the only label");
       return label;
     }
-    return (0, import_labels.isEncodedLabelhash)(label) ? label : (0, import_normalise.normalise)(label);
+    return (0, import_labels.isEncodedLabelhash)(label) ? (0, import_labels.checkLabel)(label) || label : (0, import_normalise.normalise)(label);
   });
-  const normalizedName = normalizedArray.join(".");
-  (0, import_labels.saveName)(normalizedName);
-  return normalizedName;
+  const normalisedName = normalisedArray.join(".");
+  (0, import_labels.saveName)(normalisedName);
+  return normalisedName;
 };
-const validateTLD = (name) => {
-  const labels = name.split(".");
-  return validateName(labels[labels.length - 1]);
-};
-const parseInputType = (input) => {
-  const validTLD = validateTLD(input);
-  const regex = /[^.]+$/;
+const parseInput = (input) => {
+  var _a;
+  let nameReference = input;
+  let isValid = false;
   try {
-    validateName(input);
-  } catch (e) {
-    return {
-      type: "unknown"
-    };
-  }
-  if (input.indexOf(".") !== -1) {
-    const termArray = input.split(".");
-    const tld = input.match(regex) ? input.match(regex)[0] : "";
-    if (validTLD) {
-      if (tld === "eth" && [...termArray[termArray.length - 2]].length < 3) {
-        return {
-          type: "name",
-          info: "short"
-        };
-      }
-      return {
-        type: "name",
-        info: "supported"
-      };
-    }
-    return {
-      type: "name",
-      info: "unsupported"
-    };
+    nameReference = validateName(input);
+    isValid = true;
+  } catch {
   }
-  if ((0, import_address.isAddress)(input)) {
+  const normalisedName = isValid ? nameReference : void 0;
+  const labels = nameReference.split(".");
+  const tld = labels[labels.length - 1];
+  const isETH = tld === "eth";
+  const labelDataArray = (0, import_normalise.split)(nameReference);
+  const isShort = (((_a = labelDataArray[0].output) == null ? void 0 : _a.length) || 0) < import_consts.MINIMUM_DOT_ETH_CHARS;
+  if (labels.length === 1) {
     return {
-      type: "address"
+      type: "label",
+      normalised: normalisedName,
+      isShort,
+      isValid,
+      is2LD: false,
+      isETH,
+      labelDataArray
     };
   }
+  const is2LD = labels.length === 2;
   return {
-    type: "label"
+    type: "name",
+    normalised: normalisedName,
+    isShort: isETH && is2LD ? isShort : false,
+    isValid,
+    is2LD,
+    isETH,
+    labelDataArray
   };
 };
 const checkIsDotEth = (labels) => labels.length === 2 && labels[1] === "eth";

package/dist/esm/functions/getProfile.mjs

@@ -1,11 +1,11 @@
 // src/functions/getProfile.ts
 import { formatsByName } from "@ensdomains/address-encoder";
 import { defaultAbiCoder } from "@ethersproject/abi";
+import { isAddress } from "@ethersproject/address";
 import { hexStripZeros, isBytesLike } from "@ethersproject/bytes";
 import { decodeContenthash } from "../utils/contentHash.mjs";
 import { hexEncodeName } from "../utils/hexEncodedName.mjs";
 import { namehash } from "../utils/normalise.mjs";
-import { parseInputType } from "../utils/validation.mjs";
 var makeMulticallData = async ({
   _getAddr,
   _getContentHash,
@@ -446,11 +446,8 @@ async function getProfile_default({
       options.fallback.coinTypes = options.fallback.coinTypes.map(mapCoinTypes);
     }
   }
-  const inputType = parseInputType(nameOrAddress);
-  if (inputType.type === "unknown" || inputType.info === "unsupported") {
-    throw new Error("Invalid input type");
-  }
-  if (inputType.type === "address") {
+  const inputIsAddress = isAddress(nameOrAddress);
+  if (inputIsAddress) {
     return getProfileFromAddress(
       {
         contracts,

package/dist/esm/functions/initialGetters.mjs

@@ -7,10 +7,9 @@ import { default as default5 } from "./getNames.mjs";
 import { default as default6 } from "./getOwner.mjs";
 import { default as default7 } from "./getPrice.mjs";
 import { default as default8 } from "./getProfile.mjs";
-import { default as default9 } from "./getRecords.mjs";
 export * from "./getSpecificRecord.mjs";
-import { default as default10 } from "./getSubnames.mjs";
-import { default as default11 } from "./supportsTLD.mjs";
+import { default as default9 } from "./getSubnames.mjs";
+import { default as default10 } from "./supportsTLD.mjs";
 export {
   default2 as batch,
   default3 as getExpiry,
@@ -19,7 +18,6 @@ export {
   default6 as getOwner,
   default7 as getPrice,
   default8 as getProfile,
-  default9 as getRecords,
-  default10 as getSubnames,
-  default11 as supportsTLD
+  default9 as getSubnames,
+  default10 as supportsTLD
 };

package/dist/esm/index.mjs

@@ -165,11 +165,6 @@ var ENS = class {
     ],
     "getProfile"
   );
-  getRecords = this.generateFunction(
-    "initialGetters",
-    ["getProfile"],
-    "getRecords"
-  );
   getName = this.generateRawFunction(
     "initialGetters",
     ["contracts"],

package/dist/esm/utils/consts.mjs

@@ -1,7 +1,9 @@
 // src/utils/consts.ts
 var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
 var MAX_INT_64 = BigInt("18446744073709551615");
+var MINIMUM_DOT_ETH_CHARS = 3;
 export {
   EMPTY_ADDRESS,
-  MAX_INT_64
+  MAX_INT_64,
+  MINIMUM_DOT_ETH_CHARS
 };

package/dist/esm/utils/validation.mjs

@@ -1,69 +1,62 @@
 // src/utils/validation.ts
-import { isAddress } from "@ethersproject/address";
-import { isEncodedLabelhash, saveName } from "./labels.mjs";
-import { normalise } from "./normalise.mjs";
+import { MINIMUM_DOT_ETH_CHARS } from "./consts.mjs";
+import { checkLabel, isEncodedLabelhash, saveName } from "./labels.mjs";
+import { normalise, split } from "./normalise.mjs";
 var validateName = (name) => {
   const nameArray = name.split(".");
-  const hasEmptyLabels = nameArray.some((label) => label.length === 0);
-  if (hasEmptyLabels)
-    throw new Error("Name cannot have empty labels");
-  const normalizedArray = nameArray.map((label) => {
+  const normalisedArray = nameArray.map((label) => {
+    if (label.length === 0)
+      throw new Error("Name cannot have empty labels");
     if (label === "[root]") {
+      if (name !== label)
+        throw new Error("Root label must be the only label");
       return label;
     }
-    return isEncodedLabelhash(label) ? label : normalise(label);
+    return isEncodedLabelhash(label) ? checkLabel(label) || label : normalise(label);
   });
-  const normalizedName = normalizedArray.join(".");
-  saveName(normalizedName);
-  return normalizedName;
+  const normalisedName = normalisedArray.join(".");
+  saveName(normalisedName);
+  return normalisedName;
 };
-var validateTLD = (name) => {
-  const labels = name.split(".");
-  return validateName(labels[labels.length - 1]);
-};
-var parseInputType = (input) => {
-  const validTLD = validateTLD(input);
-  const regex = /[^.]+$/;
+var parseInput = (input) => {
+  let nameReference = input;
+  let isValid = false;
   try {
-    validateName(input);
-  } catch (e) {
-    return {
-      type: "unknown"
-    };
-  }
-  if (input.indexOf(".") !== -1) {
-    const termArray = input.split(".");
-    const tld = input.match(regex) ? input.match(regex)[0] : "";
-    if (validTLD) {
-      if (tld === "eth" && [...termArray[termArray.length - 2]].length < 3) {
-        return {
-          type: "name",
-          info: "short"
-        };
-      }
-      return {
-        type: "name",
-        info: "supported"
-      };
-    }
-    return {
-      type: "name",
-      info: "unsupported"
-    };
+    nameReference = validateName(input);
+    isValid = true;
+  } catch {
   }
-  if (isAddress(input)) {
+  const normalisedName = isValid ? nameReference : void 0;
+  const labels = nameReference.split(".");
+  const tld = labels[labels.length - 1];
+  const isETH = tld === "eth";
+  const labelDataArray = split(nameReference);
+  const isShort = (labelDataArray[0].output?.length || 0) < MINIMUM_DOT_ETH_CHARS;
+  if (labels.length === 1) {
     return {
-      type: "address"
+      type: "label",
+      normalised: normalisedName,
+      isShort,
+      isValid,
+      is2LD: false,
+      isETH,
+      labelDataArray
     };
   }
+  const is2LD = labels.length === 2;
   return {
-    type: "label"
+    type: "name",
+    normalised: normalisedName,
+    isShort: isETH && is2LD ? isShort : false,
+    isValid,
+    is2LD,
+    isETH,
+    labelDataArray
   };
 };
 var checkIsDotEth = (labels) => labels.length === 2 && labels[1] === "eth";
 export {
   checkIsDotEth,
-  parseInputType,
-  validateName,
-  validateTLD
+  parseInput,
+  validateName
 };

package/dist/types/functions/initialGetters.d.ts

@@ -6,7 +6,6 @@ export { default as getNames } from './getNames';
 export { default as getOwner } from './getOwner';
 export { default as getPrice } from './getPrice';
 export { default as getProfile } from './getProfile';
-export { default as getRecords } from './getRecords';
 export * from './getSpecificRecord';
 export { default as getSubnames } from './getSubnames';
 export { default as supportsTLD } from './supportsTLD';

package/dist/types/functions/types.d.ts

@@ -13,7 +13,6 @@ import type getNames from './getNames';
 import type getOwner from './getOwner';
 import type getPrice from './getPrice';
 import type getProfile from './getProfile';
-import type getRecords from './getRecords';
 import type getResolver from './getResolver';
 import type { getABI, getAddr, getContentHash, getText, _getABI, _getAddr, _getContentHash, _getText } from './getSpecificRecord';
 import type getSubnames from './getSubnames';
@@ -53,7 +52,6 @@ declare type Function = {
     getOwner: typeof getOwner;
     getPrice: typeof getPrice;
     getProfile: typeof getProfile;
-    getRecords: typeof getRecords;
     getResolver: typeof getResolver;
     getAddr: typeof getAddr;
     getContentHash: typeof getContentHash;

package/dist/types/index.d.ts

@@ -182,38 +182,6 @@ export declare class ENS {
         isInvalidResolverAddress?: boolean | undefined;
         reverseResolverAddress?: string | undefined;
     } | undefined>;
-    getRecords: (name: string, options?: {
-        contentHash?: boolean | undefined;
-        texts?: boolean | string[] | undefined;
-        coinTypes?: boolean | string[] | undefined;
-        resolverAddress?: string | undefined;
-    } | undefined) => Promise<{
-        isMigrated: boolean | null;
-        createdAt: string | null;
-        address?: string | undefined;
-        name?: string | null | undefined;
-        decryptedName?: string | null | undefined;
-        match?: boolean | undefined;
-        message?: string | undefined;
-        records?: {
-            contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
-            texts?: {
-                key: string | number;
-                type: "text" | "addr" | "contentHash";
-                coin?: string | undefined;
-                value: string;
-            }[] | undefined;
-            coinTypes?: {
-                key: string | number;
-                type: "text" | "addr" | "contentHash";
-                coin?: string | undefined;
-                value: string;
-            }[] | undefined;
-        } | undefined;
-        resolverAddress?: string | undefined;
-        isInvalidResolverAddress?: boolean | undefined;
-        reverseResolverAddress?: string | undefined;
-    } | undefined>;
     getName: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, address: string) => Promise<{
             to: string;

package/dist/types/utils/consts.d.ts

@@ -1,2 +1,3 @@
 export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
 export declare const MAX_INT_64: bigint;
+export declare const MINIMUM_DOT_ETH_CHARS = 3;

package/dist/types/utils/validation.d.ts

@@ -1,9 +1,13 @@
+import { Label } from './normalise';
 export declare const validateName: (name: string) => string;
-export declare const validateTLD: (name: string) => string;
-declare type InputType = {
-    type: 'name' | 'label' | 'address' | 'unknown';
-    info?: 'short' | 'supported' | 'unsupported';
+export declare type ParsedInputResult = {
+    type: 'name' | 'label';
+    normalised: string | undefined;
+    isValid: boolean;
+    isShort: boolean;
+    is2LD: boolean;
+    isETH: boolean;
+    labelDataArray: Label[];
 };
-export declare const parseInputType: (input: string) => InputType;
+export declare const parseInput: (input: string) => ParsedInputResult;
 export declare const checkIsDotEth: (labels: string[]) => boolean;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.52",
+  "version": "3.0.0-alpha.54",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -62,8 +62,7 @@
     "@adraffy/ens-normalize": "1.9.0",
     "@ensdomains/address-encoder": "^0.2.18",
     "@ensdomains/content-hash": "^2.5.7",
-    "@ensdomains/dnsprovejs": "^0.4.1",
-    "@ensdomains/dnssecoraclejs": "^0.2.7",
+    "@ensdomains/dnssecoraclejs": "^0.2.8",
     "cbor": "^8.1.0",
     "dns-packet": "^5.3.1",
     "graphql": "^16.3.0",

package/src/functions/getProfile.ts

@@ -1,11 +1,11 @@
 import { formatsByName } from '@ensdomains/address-encoder'
 import { defaultAbiCoder } from '@ethersproject/abi'
+import { isAddress } from '@ethersproject/address'
 import { hexStripZeros, isBytesLike } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
-import { parseInputType } from '../utils/validation'
 
 type InternalProfileOptions = {
   contentHash?: boolean | string | DecodedContentHash
@@ -653,13 +653,9 @@ export default async function (
     }
   }
 
-  const inputType = parseInputType(nameOrAddress)
+  const inputIsAddress = isAddress(nameOrAddress)
 
-  if (inputType.type === 'unknown' || inputType.info === 'unsupported') {
-    throw new Error('Invalid input type')
-  }
-
-  if (inputType.type === 'address') {
+  if (inputIsAddress) {
     return getProfileFromAddress(
       {
         contracts,

package/src/functions/initialGetters.ts

@@ -6,7 +6,6 @@ export { default as getNames } from './getNames'
 export { default as getOwner } from './getOwner'
 export { default as getPrice } from './getPrice'
 export { default as getProfile } from './getProfile'
-export { default as getRecords } from './getRecords'
 export * from './getSpecificRecord'
 export { default as getSubnames } from './getSubnames'
 export { default as supportsTLD } from './supportsTLD'

package/src/functions/types.ts

@@ -17,7 +17,6 @@ import type getNames from './getNames'
 import type getOwner from './getOwner'
 import type getPrice from './getPrice'
 import type getProfile from './getProfile'
-import type getRecords from './getRecords'
 import type getResolver from './getResolver'
 import type {
   getABI,
@@ -71,7 +70,6 @@ type Function = {
   getOwner: typeof getOwner
   getPrice: typeof getPrice
   getProfile: typeof getProfile
-  getRecords: typeof getRecords
   getResolver: typeof getResolver
   getAddr: typeof getAddr
   getContentHash: typeof getContentHash

package/src/index.ts

@@ -431,12 +431,6 @@ export class ENS {
     'getProfile',
   )
 
-  public getRecords = this.generateFunction<FunctionTypes['getRecords']>(
-    'initialGetters',
-    ['getProfile'],
-    'getRecords',
-  )
-
   public getName = this.generateRawFunction<FunctionTypes['getName']>(
     'initialGetters',
     ['contracts'],

package/src/utils/consts.ts

@@ -1,2 +1,3 @@
 export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
 export const MAX_INT_64 = BigInt('18446744073709551615')
+export const MINIMUM_DOT_ETH_CHARS = 3

package/src/utils/validation.test.ts

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { parseInput, validateName } from './validation'
+
+declare namespace localStorage {
+  const getItem: jest.MockedFn<Storage['getItem']>
+  const setItem: jest.MockedFn<Storage['setItem']>
+  const removeItem: jest.MockedFn<Storage['removeItem']>
+}
+
+const labelsMock = {
+  '0x68371d7e884c168ae2022c82bd837d51837718a7f7dfb7aa3f753074a35e1d87':
+    'something',
+  '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0': 'eth',
+}
+
+const labelsMockJSON = JSON.stringify(labelsMock)
+
+describe('validateName()', () => {
+  beforeEach(() => {
+    localStorage.getItem.mockClear()
+    localStorage.setItem.mockClear()
+    localStorage.getItem.mockImplementation(() => labelsMockJSON)
+  })
+  it('should throw if the name has an empty label', () => {
+    expect(() => validateName('foo..bar')).toThrowError(
+      'Name cannot have empty labels',
+    )
+    expect(() => validateName('.foo.bar')).toThrowError(
+      'Name cannot have empty labels',
+    )
+    expect(() => validateName('foo.bar.')).toThrowError(
+      'Name cannot have empty labels',
+    )
+  })
+  it('should allow names with [root] as a label', () => {
+    expect(validateName('[root]')).toEqual('[root]')
+  })
+  it('should throw if the name has [root] as a label and is not the only label', () => {
+    expect(() => validateName('foo.[root].bar')).toThrowError(
+      'Root label must be the only label',
+    )
+  })
+
+  it('should get the decoded label hash from local storage', () => {
+    expect(
+      validateName(
+        'thing.[68371d7e884c168ae2022c82bd837d51837718a7f7dfb7aa3f753074a35e1d87].eth',
+      ),
+    ).toEqual('thing.something.eth')
+    expect(localStorage.getItem).toHaveBeenCalled()
+  })
+  it('should fallback to encoded label hash if the decoded label hash is not in local storage', () => {
+    expect(
+      validateName(
+        'something.[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17].eth',
+      ),
+    ).toEqual(
+      'something.[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17].eth',
+    )
+    expect(localStorage.getItem).toHaveBeenCalled()
+    expect(
+      validateName(
+        '[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17]',
+      ),
+    ).toEqual(
+      '[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17]',
+    )
+  })
+  it('should normalise the name', () => {
+    expect(validateName('aAaaA.eth')).toEqual('aaaaa.eth')
+  })
+  it('should save the normalised name to local storage', () => {
+    validateName('swAgCity.eth')
+    expect(localStorage.setItem).toHaveBeenCalledWith(
+      'ensjs:labels',
+      JSON.stringify({
+        ...labelsMock,
+        '0xee3bbc5c1db3f1dbd5ec4cdfd627fb76aba6215d814354b6c0f8d74253adf1a8':
+          'swagcity',
+      }),
+    )
+  })
+  it('should return the normalised name', () => {
+    expect(validateName('swAgCity.eth')).toEqual('swagcity.eth')
+  })
+})
+
+describe('parseInput()', () => {
+  it('should parse the input', () => {
+    expect(parseInput('bar.eth')).toEqual({
+      type: 'name',
+      normalised: 'bar.eth',
+      isShort: false,
+      isValid: true,
+      is2LD: true,
+      isETH: true,
+      labelDataArray: expect.any(Array),
+    })
+  })
+  it('should return a normalised name', () => {
+    expect(parseInput('bAr.etH').normalised).toEqual('bar.eth')
+  })
+  it('should parse the input if it is invalid', () => {
+    expect(parseInput('bar..eth')).toEqual({
+      type: 'name',
+      normalised: undefined,
+      isShort: false,
+      isValid: false,
+      is2LD: false,
+      isETH: true,
+      labelDataArray: expect.any(Array),
+    })
+  })
+  it('should return type as label if input is a label', () => {
+    expect(parseInput('bar').type).toEqual('label')
+  })
+  describe('should return correct value', () => {
+    describe('isShort', () => {
+      it('should return true if input is label and less than 3 characters', () => {
+        expect(parseInput('ba').isShort).toEqual(true)
+      })
+      it('should return true if input is less than 3 char emoji', () => {
+        expect(parseInput('🇺🇸').isShort).toEqual(true)
+      })
+      it('should return false if input is 3 char emoji', () => {
+        expect(parseInput('🏳️‍🌈').isShort).toEqual(false)
+      })
+      it('should return false if input is label and 3 characters', () => {
+        expect(parseInput('bar').isShort).toEqual(false)
+      })
+      it('should return true if input is 2LD .eth name and label is less than 3 characters', () => {
+        expect(parseInput('ba.eth').isShort).toEqual(true)
+      })
+      it('should return false if input is 2LD .eth name and label is 3 characters', () => {
+        expect(parseInput('bar.eth').isShort).toEqual(false)
+      })
+      it('should return false if input is 2LD other name and label is less than 3 characters', () => {
+        expect(parseInput('ba.com').isShort).toEqual(false)
+      })
+      it('should return false if input is 3LD .eth name and label is less than 3 characters', () => {
+        expect(parseInput('ba.bar.eth').isShort).toEqual(false)
+      })
+    })
+    describe('is2LD', () => {
+      it('should return true if input is 2LD name', () => {
+        expect(parseInput('bar.eth').is2LD).toEqual(true)
+      })
+      it('should return false if input is 3LD name', () => {
+        expect(parseInput('bar.foo.eth').is2LD).toEqual(false)
+      })
+      it('should return false if input is label', () => {
+        expect(parseInput('bar').is2LD).toEqual(false)
+      })
+    })
+    describe('isETH', () => {
+      it('should return true if input is .eth name', () => {
+        expect(parseInput('bar.eth').isETH).toEqual(true)
+      })
+      it('should return false if input is other name', () => {
+        expect(parseInput('bar.com').isETH).toEqual(false)
+      })
+    })
+  })
+})

package/src/utils/validation.ts

@@ -1,73 +1,73 @@
-import { isAddress } from '@ethersproject/address'
-import { isEncodedLabelhash, saveName } from './labels'
-import { normalise } from './normalise'
+import { MINIMUM_DOT_ETH_CHARS } from './consts'
+import { checkLabel, isEncodedLabelhash, saveName } from './labels'
+import { Label, normalise, split } from './normalise'
 
 export const validateName = (name: string) => {
   const nameArray = name.split('.')
-  const hasEmptyLabels = nameArray.some((label) => label.length === 0)
-  if (hasEmptyLabels) throw new Error('Name cannot have empty labels')
-  const normalizedArray = nameArray.map((label) => {
+  const normalisedArray = nameArray.map((label) => {
+    if (label.length === 0) throw new Error('Name cannot have empty labels')
     if (label === '[root]') {
+      if (name !== label) throw new Error('Root label must be the only label')
       return label
     }
-    return isEncodedLabelhash(label) ? label : normalise(label)
+    return isEncodedLabelhash(label)
+      ? checkLabel(label) || label
+      : normalise(label)
   })
-  const normalizedName = normalizedArray.join('.')
-  saveName(normalizedName)
-  return normalizedName
+  const normalisedName = normalisedArray.join('.')
+  saveName(normalisedName)
+  return normalisedName
 }
 
-export const validateTLD = (name: string) => {
-  const labels = name.split('.')
-  return validateName(labels[labels.length - 1])
+export type ParsedInputResult = {
+  type: 'name' | 'label'
+  normalised: string | undefined
+  isValid: boolean
+  isShort: boolean
+  is2LD: boolean
+  isETH: boolean
+  labelDataArray: Label[]
 }
 
-type InputType = {
-  type: 'name' | 'label' | 'address' | 'unknown'
-  info?: 'short' | 'supported' | 'unsupported'
-}
-
-export const parseInputType = (input: string): InputType => {
-  const validTLD = validateTLD(input)
-  const regex = /[^.]+$/
+export const parseInput = (input: string): ParsedInputResult => {
+  let nameReference = input
+  let isValid = false
 
   try {
-    validateName(input)
-  } catch (e) {
-    return {
-      type: 'unknown',
-    }
-  }
+    nameReference = validateName(input)
+    isValid = true
+  } catch {}
 
-  if (input.indexOf('.') !== -1) {
-    const termArray = input.split('.')
-    const tld = input.match(regex) ? input.match(regex)![0] : ''
-    if (validTLD) {
-      if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {
-        // code-point length
-        return {
-          type: 'name',
-          info: 'short',
-        }
-      }
-      return {
-        type: 'name',
-        info: 'supported',
-      }
-    }
+  const normalisedName = isValid ? nameReference : undefined
 
+  const labels = nameReference.split('.')
+  const tld = labels[labels.length - 1]
+  const isETH = tld === 'eth'
+  const labelDataArray = split(nameReference)
+  const isShort =
+    (labelDataArray[0].output?.length || 0) < MINIMUM_DOT_ETH_CHARS
+
+  if (labels.length === 1) {
     return {
-      type: 'name',
-      info: 'unsupported',
-    }
-  }
-  if (isAddress(input)) {
-    return {
-      type: 'address',
+      type: 'label',
+      normalised: normalisedName,
+      isShort,
+      isValid,
+      is2LD: false,
+      isETH,
+      labelDataArray,
     }
   }
+
+  const is2LD = labels.length === 2
   return {
-    type: 'label',
+    type: 'name',
+    normalised: normalisedName,
+    isShort: isETH && is2LD ? isShort : false,
+    isValid,
+    is2LD,
+    isETH,
+    labelDataArray,
   }
 }
 

package/dist/cjs/functions/getRecords.js

@@ -1,31 +0,0 @@
-"use strict";
-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 getRecords_exports = {};
-__export(getRecords_exports, {
-  default: () => getRecords_default
-});
-module.exports = __toCommonJS(getRecords_exports);
-var import_validation = require("../utils/validation");
-async function getRecords_default({ getProfile }, name, options) {
-  const inputType = (0, import_validation.parseInputType)(name);
-  if (inputType.type !== "name" && inputType.type !== "label") {
-    throw new Error("Input must be an ENS name");
-  }
-  return getProfile(name, options);
-}

package/dist/esm/functions/getRecords.mjs

@@ -1,12 +0,0 @@
-// src/functions/getRecords.ts
-import { parseInputType } from "../utils/validation.mjs";
-async function getRecords_default({ getProfile }, name, options) {
-  const inputType = parseInputType(name);
-  if (inputType.type !== "name" && inputType.type !== "label") {
-    throw new Error("Input must be an ENS name");
-  }
-  return getProfile(name, options);
-}
-export {
-  getRecords_default as default
-};

package/dist/types/functions/getRecords.d.ts

@@ -1,35 +0,0 @@
-import { ENSArgs } from '..';
-declare type ProfileOptions = {
-    contentHash?: boolean;
-    texts?: boolean | string[];
-    coinTypes?: boolean | string[];
-    resolverAddress?: string;
-};
-export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): Promise<{
-    isMigrated: boolean | null;
-    createdAt: string | null;
-    address?: string | undefined;
-    name?: string | null | undefined;
-    decryptedName?: string | null | undefined;
-    match?: boolean | undefined;
-    message?: string | undefined;
-    records?: {
-        contentHash?: string | import("../utils/contentHash").DecodedContentHash | null | undefined;
-        texts?: {
-            key: string | number;
-            type: "text" | "addr" | "contentHash";
-            coin?: string | undefined;
-            value: string;
-        }[] | undefined;
-        coinTypes?: {
-            key: string | number;
-            type: "text" | "addr" | "contentHash";
-            coin?: string | undefined;
-            value: string;
-        }[] | undefined;
-    } | undefined;
-    resolverAddress?: string | undefined;
-    isInvalidResolverAddress?: boolean | undefined;
-    reverseResolverAddress?: string | undefined;
-} | undefined>;
-export {};

package/src/functions/getRecords.ts

@@ -1,23 +0,0 @@
-import { ENSArgs } from '..'
-import { parseInputType } from '../utils/validation'
-
-type ProfileOptions = {
-  contentHash?: boolean
-  texts?: boolean | string[]
-  coinTypes?: boolean | string[]
-  resolverAddress?: string
-}
-
-export default async function (
-  { getProfile }: ENSArgs<'getProfile'>,
-  name: string,
-  options?: ProfileOptions,
-) {
-  const inputType = parseInputType(name)
-
-  if (inputType.type !== 'name' && inputType.type !== 'label') {
-    throw new Error('Input must be an ENS name')
-  }
-
-  return getProfile(name, options)
-}