Refactor/enssdk refactor continued

apps/ensadmin/src/app/mock/registrar-actions/mocks.ts

@@ -1,6 +1,7 @@
+import type { Duration } from "enssdk";
 import { asInterpretedName } from "enssdk";
 
-import { type Duration, type NamedRegistrarAction } from "@ensnode/ensnode-sdk";
+import { type NamedRegistrarAction } from "@ensnode/ensnode-sdk";
 
 export const registrationWithReferral = {
   action: {

apps/ensadmin/src/components/indexing-status/projection-info.tsx

@@ -1,11 +1,9 @@
 "use client";
 
 import { formatRelativeTime, RelativeTime, useNow } from "@namehash/namehash-ui";
-import type { UnixTimestamp } from "enssdk";
+import type { Duration, UnixTimestamp } from "enssdk";
 import { InfoIcon } from "lucide-react";
 
-import type { Duration } from "@ensnode/ensnode-sdk";
-
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
 
 /**

apps/ensadmin/src/components/indexing-status/use-indexing-status-with-swr.ts

@@ -2,6 +2,7 @@
 
 import { useNow } from "@namehash/namehash-ui";
 import { secondsToMilliseconds } from "date-fns";
+import type { Duration } from "enssdk";
 import { useCallback, useMemo } from "react";
 
 import {
@@ -15,7 +16,6 @@ import {
 import {
   CrossChainIndexingStatusSnapshotOmnichain,
   createRealtimeIndexingStatusProjection,
-  Duration,
   type IndexingStatusRequest,
   IndexingStatusResponseCodes,
   IndexingStatusResponseOk,

apps/ensapi/src/handlers/api/meta/realtime-api.routes.ts

@@ -1,7 +1,7 @@
 import { createRoute, z } from "@hono/zod-openapi";
 import { minutesToSeconds } from "date-fns";
+import type { Duration } from "enssdk";
 
-import type { Duration } from "@ensnode/ensnode-sdk";
 import { makeDurationSchema } from "@ensnode/ensnode-sdk/internal";
 
 import { params } from "@/lib/handlers/params.schema";

apps/ensapi/src/handlers/api/resolution/resolution-api.ts

@@ -1,5 +1,6 @@
+import type { Duration } from "enssdk";
+
 import type {
-  Duration,
   ResolvePrimaryNameResponse,
   ResolvePrimaryNamesResponse,
   ResolveRecordsResponse,

apps/ensapi/src/handlers/subgraph/subgraph-api.ts

@@ -1,13 +1,14 @@
 import config from "@/config";
 
+import type { Duration } from "enssdk";
 import { createDocumentationMiddleware } from "ponder-enrich-gql-docs-middleware";
 
 // FIXME: use the import from:
 // import { ensIndexerSchema } from "@/lib/ensdb/singleton";
 // Once the lazy proxy implemented for `ensIndexerSchema` export is improved
 // to support Drizzle ORM in `ponder-subgraph` package.
 import * as ensIndexerSchema from "@ensnode/ensdb-sdk/ensindexer-abstract";
-import { type Duration, hasSubgraphApiConfigSupport } from "@ensnode/ensnode-sdk";
+import { hasSubgraphApiConfigSupport } from "@ensnode/ensnode-sdk";
 import { subgraphGraphQLMiddleware } from "@ensnode/ponder-subgraph";
 
 import { createApp } from "@/lib/hono-factory";

apps/ensapi/src/lib/ensanalytics/referrer-leaderboard/closeout.ts

@@ -1,8 +1,8 @@
 import type { ReferralProgramRules } from "@namehash/ens-referrals/v1";
 import { minutesToSeconds } from "date-fns";
-import type { UnixTimestamp } from "enssdk";
+import type { Duration, UnixTimestamp } from "enssdk";
 
-import { addDuration, type Duration } from "@ensnode/ensnode-sdk";
+import { addDuration } from "@ensnode/ensnode-sdk";
 
 /**
  * Duration after which we assume a closed edition is safe from chain reorganizations.

apps/ensapi/src/lib/resolution/resolve-with-universal-resolver.integration.test.ts

@@ -0,0 +1,72 @@
+import { vi } from "vitest";
+
+// we're testing a function specifically, not fetching through the running ensapi instance, so
+// we need to mock the config when this worker process attempts to import ./resolve-with-universal-resolver
+vi.mock("@/config", () => ({
+  default: {
+    namespace: "ens-test-env",
+    rpcConfigs: new Map([[ensTestEnvChain.id, { httpRPCs: [new URL("http://localhost:8545")] }]]),
+  },
+}));
+
+import {
+  asInterpretedLabel,
+  asInterpretedName,
+  asLiteralLabel,
+  encodeLabelHash,
+  interpretedLabelsToInterpretedName,
+  labelhashLiteralLabel,
+  namehashInterpretedName,
+} from "enssdk";
+import { describe, expect, it } from "vitest";
+
+import { ensTestEnvChain } from "@ensnode/datasources";
+
+import { getPublicClient } from "@/lib/public-client";
+import { makeResolveCalls } from "@/lib/resolution/resolve-calls-and-results";
+
+import { executeResolveCallsWithUniversalResolver } from "./resolve-with-universal-resolver";
+
+const NAME = asInterpretedName("example.eth");
+const NAME_WITH_ENCODED_LABELHASHES = interpretedLabelsToInterpretedName([
+  asInterpretedLabel(encodeLabelHash(labelhashLiteralLabel(asLiteralLabel("example")))),
+  asInterpretedLabel("eth"),
+]);
+
+const EXPECTED_DESCRIPTION = "example.eth";
+
+const CALLS = makeResolveCalls(namehashInterpretedName(NAME), { texts: ["description"] });
+const publicClient = getPublicClient(ensTestEnvChain.id);
+
+describe("executeResolveCallsWithUniversalResolver", () => {
+  it("should resolve interpreted name without encoded labelhashes", async () => {
+    await expect(
+      executeResolveCallsWithUniversalResolver({
+        name: NAME,
+        calls: CALLS,
+        publicClient,
+      }),
+    ).resolves.toMatchObject([{ result: EXPECTED_DESCRIPTION }]);
+  });
+
+  /**
+   * NOTE(shrugs): This was contrary to my expectations, but the NameCoder (in both ENSv1 and ENSv2)
+   * is NOT EncodedLabelHash-aware: all label segments are hashed indiscriminately as LiteralLabels
+   * to traverse the nametree, meaning that InterpretedNames (which may include EncodedLabelHash
+   * segments for labels that are unknown, too long, or unnormalized) are explicitly unresolvable!
+   *
+   * Or, more technically, they resolve to an incorrect name, one addressed by, for example:
+   * [root, labelhash("eth"), labelhash("[6fd43e7cffc31bb581d7421c8698e29aa2bd8e7186a394b85299908b4eb9b175]")]
+   *
+   * Which likely doesn't have the appropriate records set.
+   */
+  it("should NOT resolve interpreted name with encoded labelhashes", async () => {
+    await expect(
+      executeResolveCallsWithUniversalResolver({
+        name: NAME_WITH_ENCODED_LABELHASHES,
+        calls: CALLS,
+        publicClient,
+      }),
+    ).resolves.toMatchObject([{ result: null }]);
+  });
+});

apps/ensapi/src/lib/resolution/resolve-with-universal-resolver.ts

@@ -19,15 +19,13 @@ import {
   type ResolverRecordsSelection,
 } from "@ensnode/ensnode-sdk";
 
-import { lazy, lazyProxy } from "@/lib/lazy";
+import { lazy } from "@/lib/lazy";
 import type {
   ResolveCalls,
   ResolveCallsAndRawResults,
 } from "@/lib/resolution/resolve-calls-and-results";
 
-// lazyProxy defers construction until first use so that this module can be
-// imported without env vars being present (e.g. during OpenAPI generation).
-const universalResolver = lazyProxy(() =>
+const getUniversalResolverV1 = lazy(() =>
   getDatasourceContract(config.namespace, DatasourceNames.ENSRoot, "UniversalResolver"),
 );
 
@@ -60,7 +58,7 @@ export async function executeResolveCallsWithUniversalResolver<
           abi: UniversalResolverABI,
           // NOTE(ensv2-transition): if UniversalResolverV2 is defined, prefer it over UniversalResolver
           // TODO(ensv2-transition): confirm this is correct
-          address: getUniversalResolverV2()?.address ?? universalResolver.address,
+          address: getUniversalResolverV2()?.address ?? getUniversalResolverV1().address,
           functionName: "resolve",
           args: [encodedName, encodedMethod],
         });

apps/ensapi/src/middleware/is-realtime.middleware.ts

@@ -1,4 +1,4 @@
-import type { Duration } from "@ensnode/ensnode-sdk";
+import type { Duration } from "enssdk";
 
 import { factory, producing } from "@/lib/hono-factory";
 import { makeLogger } from "@/lib/logger";

apps/ensapi/src/omnigraph-api/builder.test.ts

@@ -0,0 +1,14 @@
+import type { OmnigraphScalars } from "enssdk/omnigraph";
+import { assertType, describe, it } from "vitest";
+
+import type { BuilderScalars } from "./builder";
+
+type BuilderScalarNames = Record<keyof BuilderScalars, unknown>;
+type OmnigraphScalarNames = Record<keyof OmnigraphScalars, unknown>;
+
+describe("BuilderScalars", () => {
+  it("defines the same scalar names as OmnigraphScalars from enssdk", () => {
+    assertType<BuilderScalarNames>({} as OmnigraphScalarNames);
+    assertType<OmnigraphScalarNames>({} as BuilderScalarNames);
+  });
+});

apps/ensapi/src/omnigraph-api/builder.ts

@@ -56,28 +56,30 @@ const createSpan = createOpenTelemetryWrapper(tracer, {
   },
 });
 
+export type BuilderScalars = {
+  ID: { Input: string; Output: string };
+  BigInt: { Input: bigint; Output: bigint };
+  Address: { Input: Address; Output: NormalizedAddress };
+  Hex: { Input: Hex; Output: Hex };
+  ChainId: { Input: ChainId; Output: ChainId };
+  CoinType: { Input: CoinType; Output: CoinType };
+  Node: { Input: Node; Output: Node };
+  InterpretedName: { Input: InterpretedName; Output: InterpretedName };
+  InterpretedLabel: { Input: InterpretedLabel; Output: InterpretedLabel };
+  DomainId: { Input: DomainId; Output: DomainId };
+  RegistryId: { Input: RegistryId; Output: RegistryId };
+  ResolverId: { Input: ResolverId; Output: ResolverId };
+  PermissionsId: { Input: PermissionsId; Output: PermissionsId };
+  PermissionsResourceId: { Input: PermissionsResourceId; Output: PermissionsResourceId };
+  PermissionsUserId: { Input: PermissionsUserId; Output: PermissionsUserId };
+  RegistrationId: { Input: RegistrationId; Output: RegistrationId };
+  RenewalId: { Input: RenewalId; Output: RenewalId };
+  ResolverRecordsId: { Input: ResolverRecordsId; Output: ResolverRecordsId };
+};
+
 export const builder = new SchemaBuilder<{
   Context: ReturnType<typeof context>;
-  Scalars: {
-    // make sure to keep these scalars up to date with packages/enssdk/src/omnigraph/graphql.ts !
-    BigInt: { Input: bigint; Output: bigint };
-    Address: { Input: Address; Output: NormalizedAddress };
-    Hex: { Input: Hex; Output: Hex };
-    ChainId: { Input: ChainId; Output: ChainId };
-    CoinType: { Input: CoinType; Output: CoinType };
-    Node: { Input: Node; Output: Node };
-    InterpretedName: { Input: InterpretedName; Output: InterpretedName };
-    InterpretedLabel: { Input: InterpretedLabel; Output: InterpretedLabel };
-    DomainId: { Input: DomainId; Output: DomainId };
-    RegistryId: { Input: RegistryId; Output: RegistryId };
-    ResolverId: { Input: ResolverId; Output: ResolverId };
-    PermissionsId: { Input: PermissionsId; Output: PermissionsId };
-    PermissionsResourceId: { Input: PermissionsResourceId; Output: PermissionsResourceId };
-    PermissionsUserId: { Input: PermissionsUserId; Output: PermissionsUserId };
-    RegistrationId: { Input: RegistrationId; Output: RegistrationId };
-    RenewalId: { Input: RenewalId; Output: RenewalId };
-    ResolverRecordsId: { Input: ResolverRecordsId; Output: ResolverRecordsId };
-  };
+  Scalars: BuilderScalars;
 
   // the following ensures via typechecker that every t.connection returns a totalCount field
   Connection: {

apps/ensapi/src/omnigraph-api/lib/get-canonical-path.ts

@@ -61,7 +61,7 @@ export async function getV1CanonicalPath(domainId: ENSv1DomainId): Promise<Canon
     throw new Error(`Invariant(getCanonicalPath): DomainId '${domainId}' did not exist.`);
   }
 
-  // v1Domains are canonical if the TLD's parent is ROOT_NODE (ROOT_NODE itself does not exist in the index)
+  // v1Domains are canonical if the TLD's parent is ENS_ROOT_NODE (ENS_ROOT_NODE itself does not exist in the index)
   const tld = rows[rows.length - 1];
   const isCanonical = tld.parent_id === ENS_ROOT_NODE;
 

apps/ensapi/src/omnigraph-api/lib/write-graphql-schema.ts

@@ -17,7 +17,13 @@ async function _writeGraphQLSchema() {
   const { schema: unsortedSchema } = await import("@/omnigraph-api/schema");
   const schema = lexicographicSortSchema(unsortedSchema);
   const sdl = printSchema(schema);
-  const introspection = minifyIntrospectionQuery(introspectionFromSchema(schema));
+  const introspection = minifyIntrospectionQuery(introspectionFromSchema(schema), {
+    /**
+     * We include Scalar types in the introspection in order to power automatic bigint deserialization
+     * within the Omnigraph's urql GraphCache.
+     */
+    includeScalars: true,
+  });
 
   await Promise.all([
     writeFile(resolve(GENERATED_DIR, "schema.graphql"), sdl),

apps/ensapi/src/omnigraph-api/schema/permissions.integration.test.ts

@@ -1,4 +1,11 @@
-import type { NormalizedAddress } from "enssdk";
+import type {
+  ChainId,
+  NormalizedAddress,
+  PermissionsId,
+  PermissionsResourceId,
+  PermissionsUserId,
+  RegistryId,
+} from "enssdk";
 import { toEventSelector } from "viem";
 import { beforeAll, describe, expect, it } from "vitest";
 
@@ -36,23 +43,23 @@ const EAC_ROLES_CHANGED_SELECTOR = toEventSelector(
 describe("Permissions", () => {
   type PermissionsResult = {
     permissions: {
-      id: string;
-      contract: { chainId: number; address: NormalizedAddress };
+      id: PermissionsId;
+      contract: { chainId: ChainId; address: NormalizedAddress };
       root: {
-        id: string;
+        id: PermissionsResourceId;
         resource: string;
         users: GraphQLConnection<{
-          id: string;
+          id: PermissionsUserId;
           resource: string;
           user: { address: NormalizedAddress };
           roles: string;
         }>;
       };
       resources: GraphQLConnection<{
-        id: string;
+        id: PermissionsResourceId;
         resource: string;
         users: GraphQLConnection<{
-          id: string;
+          id: PermissionsUserId;
           resource: string;
           user: { address: NormalizedAddress };
           roles: string;
@@ -128,7 +135,10 @@ describe("Registry.permissions", () => {
   it("resolves permissions from a registry", async () => {
     const result = await request<{
       registry: {
-        permissions: { id: string; contract: { chainId: number; address: NormalizedAddress } };
+        permissions: {
+          id: PermissionsId;
+          contract: { chainId: ChainId; address: NormalizedAddress };
+        };
       };
     }>(RegistryPermissions, { contract: V2_ETH_REGISTRY });
 
@@ -141,7 +151,7 @@ describe("Domain.permissions", () => {
   type DomainPermissionsResult = {
     domain: {
       permissions: GraphQLConnection<{
-        id: string;
+        id: PermissionsUserId;
         resource: string;
         user: { address: NormalizedAddress };
         roles: string;
@@ -160,7 +170,7 @@ describe("Domain.permissions", () => {
   `;
 
   let allUsers: {
-    id: string;
+    id: PermissionsUserId;
     resource: string;
     user: { address: NormalizedAddress };
     roles: string;
@@ -254,7 +264,7 @@ describe("Account.permissions and Account.registryPermissions", () => {
     const result = await request<{
       account: {
         permissions: GraphQLConnection<{
-          id: string;
+          id: PermissionsUserId;
           resource: string;
           user: { address: NormalizedAddress };
           roles: string;
@@ -274,8 +284,8 @@ describe("Account.permissions and Account.registryPermissions", () => {
     const result = await request<{
       account: {
         registryPermissions: GraphQLConnection<{
-          id: string;
-          registry: { id: string };
+          id: PermissionsUserId;
+          registry: { id: RegistryId };
           resource: string;
           user: { address: NormalizedAddress };
           roles: string;
@@ -306,7 +316,10 @@ describe("Resolver.permissions", () => {
     const result = await request<{
       domain: {
         resolver: {
-          permissions: { id: string; contract: { chainId: number; address: NormalizedAddress } };
+          permissions: {
+            id: PermissionsId;
+            contract: { chainId: ChainId; address: NormalizedAddress };
+          };
         };
       };
     }>(ResolverPermissions, { name: NAME_WITH_RESOLVER });