Refine domain logic

.changeset/neat-lamps-sell.md

@@ -2,4 +2,4 @@
 "@namehash/ens-utils": minor
 ---
 
-Add domain related logics to ens-utils (Registration, DomainName, DomainCard, etc.)
+Add domain related logics to ens-utils (Registration, DomainCard, etc.)

packages/ens-utils/src/domain.ts

@@ -1,8 +1,7 @@
 import { NFTRef } from "./nft";
 import { ENSName } from "./ensname";
 import { Address, isAddressEqual } from "./address";
-import { keccak256, labelhash as labelHash } from "viem";
-import { Registration } from "./ethregistrar";
+import { Registration } from "./registrar";
 
 export interface DomainCard {
   name: ENSName;
@@ -25,127 +24,71 @@ export interface DomainCard {
   formerManagerAddress: Address | null;
 }
 
-/* Defines the ownership of a domain for a given address */
+/*
+ * Defines the ownership relation between a domain and a user.
+ */
 export const UserOwnershipOfDomain = {
-  /* NoOwner: If domain has no owner */
+  /*
+   * The domain has no `ActiveOwner` or `FormerOwner`.
+   */
   NoOwner: "NoOwner",
 
-  /* NotOwner: If domain has an owner but user is not the owner */
+  /*
+   * The domain has an `ActiveOwner` or a `FormerOwner` but they are not the
+   * user.
+   */
   NotOwner: "NotOwner",
 
-  /* FormerOwner: If user is owner of the domain and domain is in Grace Period */
+  /*
+   * The user was previously the `ActiveOwner` of the domain, however the
+   * registration of the domain is now in grace period.
+   */
   FormerOwner: "FormerOwner",
 
-  /* ActiveOwner: If user is owner of the domain and domain is not in Grace Period */
+  /*
+   * The user is the owner of the domain that has an active registration (not
+   * in grace period).
+   */
   ActiveOwner: "ActiveOwner",
 };
+
 export type UserOwnershipOfDomain =
   (typeof UserOwnershipOfDomain)[keyof typeof UserOwnershipOfDomain];
 
 /**
- * Returns the ownership status of a domain in comparison to the current user's address
- * @param domain Domain that is being checked. If null, returns UserOwnershipOfDomain.NoOwner
- * @param currentUserAddress Address of the current user.
- *                           If null, returns UserOwnershipOfDomain.NoOwner or UserOwnershipOfDomain.NotOwner
- * @returns UserOwnershipOfDomain
+ * Returns the `UserOwnershipOfDomain` relation between a `DomainCard` and the
+ * `Address` of the current user.
+ *
+ * @param domain The `DomainCard` to check the `UserOwnershipOfDomain`
+ *               relationship with.
+ * @param currentUserAddress `Address` of the current user, or `null` if there
+ *                           is no current user signed in.
+ * @returns The appropriate `UserOwnershipOfDomain` value given the provided
+ *          `domain` and `currentUserAddress`.
  */
 export const getCurrentUserOwnership = (
-  domain: DomainCard | null,
+  domain: DomainCard,
   currentUserAddress: Address | null,
 ): UserOwnershipOfDomain => {
-  const formerDomainOwnerAddress =
-    domain && domain.formerOwnerAddress ? domain.formerOwnerAddress : null;
-  const ownerAddress =
-    domain && domain.ownerAddress ? domain.ownerAddress : null;
-
-  if (currentUserAddress && formerDomainOwnerAddress) {
-    const isFormerOwner =
-      formerDomainOwnerAddress &&
-      isAddressEqual(formerDomainOwnerAddress, currentUserAddress);
-
-    if (isFormerOwner) {
-      return UserOwnershipOfDomain.FormerOwner;
-    }
-
-    const isOwner =
-      ownerAddress && isAddressEqual(currentUserAddress, ownerAddress);
+  if (!domain.ownerAddress && !domain.formerOwnerAddress) {
+    return UserOwnershipOfDomain.NoOwner;
+  }
 
-    if (isOwner) {
+  if (currentUserAddress) {
+    if (
+      domain.ownerAddress &&
+      isAddressEqual(domain.ownerAddress, currentUserAddress)
+    ) {
       return UserOwnershipOfDomain.ActiveOwner;
     }
-  }
 
-  if (!ownerAddress) {
-    return UserOwnershipOfDomain.NoOwner;
+    if (
+      domain.formerOwnerAddress &&
+      isAddressEqual(domain.formerOwnerAddress, currentUserAddress)
+    ) {
+      return UserOwnershipOfDomain.FormerOwner;
+    }
   }
 
   return UserOwnershipOfDomain.NotOwner;
 };
-
-export enum ParseNameErrorCode {
-  Empty = "Empty",
-  TooShort = "TooShort",
-  UnsupportedTLD = "UnsupportedTLD",
-  UnsupportedSubdomain = "UnsupportedSubdomain",
-  MalformedName = "MalformedName",
-  MalformedLabelHash = "MalformedLabelHash",
-}
-
-type ParseNameErrorDetails = {
-  normalizedName: string | null;
-  displayName: string | null;
-};
-export class ParseNameError extends Error {
-  public readonly errorCode: ParseNameErrorCode;
-  public readonly errorDetails: ParseNameErrorDetails | null;
-
-  constructor(
-    message: string,
-    errorCode: ParseNameErrorCode,
-    errorDetails: ParseNameErrorDetails | null,
-  ) {
-    super(message);
-
-    this.errorCode = errorCode;
-    this.errorDetails = errorDetails;
-  }
-}
-
-export const DEFAULT_TLD = "eth";
-
-export const DefaultParseNameError = new ParseNameError(
-  "Empty name",
-  ParseNameErrorCode.Empty,
-  null,
-);
-
-export const hasMissingNameFormat = (label: string) =>
-  new RegExp("\\[([0123456789abcdef]*)\\]").test(label) && label.length === 66;
-
-const labelhash = (label: string) => labelHash(label);
-
-const keccak = (input: Buffer | string) => {
-  let out = null;
-  if (Buffer.isBuffer(input)) {
-    out = keccak256(input);
-  } else {
-    out = labelhash(input);
-  }
-  return out.slice(2); // cut 0x
-};
-
-const initialNode =
-  "0000000000000000000000000000000000000000000000000000000000000000";
-
-export const namehashFromMissingName = (inputName: string): string => {
-  let node = initialNode;
-
-  const split = inputName.split(".");
-  const labels = [split[0].slice(1, -1), keccak(split[1])];
-
-  for (let i = labels.length - 1; i >= 0; i--) {
-    const labelSha = labels[i];
-    node = keccak(Buffer.from(node + labelSha, "hex"));
-  }
-  return "0x" + node;
-};

packages/ens-utils/src/ensname.ts

@@ -5,7 +5,7 @@ import {
   labelhash,
   normalizeEncodedLabelhash,
 } from "./hashutils";
-import { namehash } from "viem";
+import { keccak256, namehash } from "viem";
 
 export const LABEL_SEPARATOR = ".";
 export const ETH_TLD = "eth";
@@ -83,21 +83,6 @@ export interface ENSName {
   node: `0x${string}`;
 }
 
-export const getDomainLabelFromENSName = (ensName: ENSName): string | null => {
-  if (ensName.labels.length !== 2) return null;
-
-  if (ensName.labels[1] !== ETH_TLD) return null;
-
-  // NOTE: now we know we have a direct subname of ".eth"
-
-  const subnameLength = charCount(ensName.labels[0]);
-
-  // ensure this subname is even possible to register
-  if (subnameLength < MIN_ETH_REGISTRABLE_LABEL_LENGTH) return null;
-
-  return ensName.labels[0];
-};
-
 /**
  * Compares two sets of labels for deep equality
  * @param labels1 the first set of labels
@@ -358,3 +343,68 @@ export function getRegistrationPotential(name: ENSName): RegistrationPotential {
 export function charCount(label: string) {
   return [...label].length;
 }
+
+export enum ParseNameErrorCode {
+  Empty = "Empty",
+  TooShort = "TooShort",
+  UnsupportedTLD = "UnsupportedTLD",
+  UnsupportedSubdomain = "UnsupportedSubdomain",
+  MalformedName = "MalformedName",
+  MalformedLabelHash = "MalformedLabelHash"
+}
+
+export type ParseNameErrorDetails = {
+  normalizedName: string | null;
+  displayName: string | null;
+};
+
+export class ParseNameError extends Error {
+  public readonly errorCode: ParseNameErrorCode;
+  public readonly errorDetails: ParseNameErrorDetails | null;
+
+  constructor(
+    message: string,
+    errorCode: ParseNameErrorCode,
+    errorDetails: ParseNameErrorDetails | null
+  ) {
+    super(message);
+
+    this.errorCode = errorCode;
+    this.errorDetails = errorDetails;
+  }
+}
+
+export const DEFAULT_TLD = ETH_TLD;
+
+export const DefaultParseNameError = new ParseNameError(
+  "Empty name",
+  ParseNameErrorCode.Empty,
+  null
+);
+
+export const hasMissingNameFormat = (label: string) => new RegExp("\\[([0123456789abcdef]*)\\]").test(label) && label.length === 66;
+
+export const keccak = (input: Buffer | string) => {
+  let out = null;
+  if (Buffer.isBuffer(input)) {
+    out = keccak256(input);
+  } else {
+    out = labelhash(input);
+  }
+  return out.slice(2); // cut 0x
+};
+
+export const initialNode = "0000000000000000000000000000000000000000000000000000000000000000";
+
+export const namehashFromMissingName = (inputName: string): string => {
+  let node = initialNode;
+
+  const split = inputName.split(".");
+  const labels = [split[0].slice(1, -1), keccak(split[1])];
+
+  for (let i = labels.length - 1; i >= 0; i--) {
+    const labelSha = labels[i];
+    node = keccak(Buffer.from(node + labelSha, "hex"));
+  }
+  return "0x" + node;
+};

packages/ens-utils/src/ethregistrar.test.ts

@@ -1,79 +1,7 @@
-import { describe, it, expect } from "vitest";
-import {
-  Registrar,
-  UNWRAPPED_MAINNET_ETH_REGISTRAR,
-  WRAPPED_MAINNET_ETH_REGISTRAR,
-  buildNFTRefFromENSName,
-} from "./ethregistrar";
-import { ENSName, buildENSName } from "./ensname";
-import { MAINNET, SEPOLIA } from "./chain";
-import { buildNFTRef } from "./nft";
+import { describe, it } from "vitest";
 
 // TODO: add a lot more unit tests here
 
-function testNFTRefFromRegistrar(
-  name: ENSName,
-  registrar: Registrar,
-  isWrapped: boolean,
-): void {
-  const expectedToken = registrar.getTokenId(name, isWrapped);
-  const expectedNFT = buildNFTRef(registrar.contract, expectedToken);
-  const result = buildNFTRefFromENSName(
-    name,
-    registrar.contract.chain,
-    isWrapped,
-  );
-  expect(result).toStrictEqual(expectedNFT);
-}
-
-describe("buildNFTRefFromENSName", () => {
-  it("unrecognized registrar", () => {
-    expect(() =>
-      buildNFTRefFromENSName(buildENSName("foo.eth"), SEPOLIA, false),
-    ).toThrow();
-  });
-
-  it("unwrapped non-.eth TLD", () => {
-    expect(() =>
-      buildNFTRefFromENSName(buildENSName("foo.com"), MAINNET, false),
-    ).toThrow();
-  });
-
-  it("wrapped non-.eth TLD", () => {
-    const name = buildENSName("foo.com");
-    const registrar = WRAPPED_MAINNET_ETH_REGISTRAR;
-    const isWrapped = true;
-    testNFTRefFromRegistrar(name, registrar, isWrapped);
-  });
-
-  it("unwrapped subname of a .eth subname", () => {
-    expect(() =>
-      buildNFTRefFromENSName(buildENSName("x.foo.eth"), MAINNET, false),
-    ).toThrow();
-  });
-
-  it("wrapped subname of a .eth subname", () => {
-    const name = buildENSName("x.foo.eth");
-    const registrar = WRAPPED_MAINNET_ETH_REGISTRAR;
-    const isWrapped = true;
-    testNFTRefFromRegistrar(name, registrar, isWrapped);
-  });
-
-  it("unwrapped direct subname of .eth", () => {
-    const name = buildENSName("foo.eth");
-    const registrar = UNWRAPPED_MAINNET_ETH_REGISTRAR;
-    const isWrapped = false;
-    testNFTRefFromRegistrar(name, registrar, isWrapped);
-  });
-
-  it("wrapped direct subname of .eth", () => {
-    const name = buildENSName("foo.eth");
-    const registrar = WRAPPED_MAINNET_ETH_REGISTRAR;
-    const isWrapped = true;
-    testNFTRefFromRegistrar(name, registrar, isWrapped);
-  });
-});
-
 describe("getPriceDescription", () => {
   /*
     The getPriceDescription returns either PriceDescription | null.
@@ -84,7 +12,7 @@ describe("getPriceDescription", () => {
       - pricePerYearDescription is a string that represents: Price + "/ year" (e.g. "$5.99 / year").
 
     In order to return a PriceDescription object, the getPriceDescription function
-    makes usage of premiumEndsIn function and DOMAIN_HAS_SPECIAL_PRICE_IF_LENGTH_EQUAL_OR_LESS_THAN
+    makes usage of premiumEndsIn function and DOMAIN_HAS_SPECIAL_PRICE_IF_LENGTH_LESS_THAN
     constant, defining by condition the descriptiveTextBeginning, pricePerYear and descriptiveTextEnd.
 
     For every PriceDescription response, the domain price is get from AvailableNameTimelessPriceUSD.