@ensnode/ensdb-sdk 1.9.0 → 1.10.0

package/dist/index.js

@@ -4,18 +4,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/client/ensdb-reader.ts
-import { and, eq } from "drizzle-orm/sql";
-import {
-  deserializeCrossChainIndexingStatusSnapshot,
-  deserializeEnsIndexerPublicConfig
-} from "@ensnode/ensnode-sdk";
-
-// src/lib/drizzle.ts
-import { drizzle } from "drizzle-orm/node-postgres";
-import { isPgEnum } from "drizzle-orm/pg-core";
-import { isTable, Table } from "drizzle-orm/table";
-
 // src/ensindexer-abstract/index.ts
 var ensindexer_abstract_exports = {};
 __export(ensindexer_abstract_exports, {
@@ -316,15 +304,16 @@ var registrationType = onchainEnum("RegistrationType", [
   "NameWrapper",
   "BaseRegistrar",
   "ThreeDNS",
-  "ENSv2Registry"
+  "ENSv2RegistryRegistration",
+  "ENSv2RegistryReservation"
 ]);
 var registration = onchainTable(
   "registrations",
   (t) => ({
-    // keyed by (domainId, index)
+    // keyed by (domainId, registrationIndex)
     id: t.text().primaryKey().$type(),
     domainId: t.text().notNull().$type(),
-    index: t.integer().notNull(),
+    registrationIndex: t.integer().notNull(),
     // has a type
     type: registrationType().notNull(),
     // has a start
@@ -336,9 +325,11 @@ var registration = onchainTable(
     // registrar AccountId
     registrarChainId: t.integer().notNull().$type(),
     registrarAddress: t.hex().notNull().$type(),
-    // references registrant
+    // may reference a registrant
     registrantId: t.hex().$type(),
-    // may have a referrer
+    // may reference an unregistrant
+    unregistrantId: t.hex().$type(),
+    // may have referrer data
     referrer: t.hex().$type(),
     // may have fuses (NameWrapper, Wrapped BaseRegistrar)
     fuses: t.integer(),
@@ -353,12 +344,12 @@ var registration = onchainTable(
     eventId: t.text().notNull()
   }),
   (t) => ({
-    byId: uniqueIndex().on(t.domainId, t.index)
+    byId: uniqueIndex().on(t.domainId, t.registrationIndex)
   })
 );
 var latestRegistrationIndex = onchainTable("latest_registration_indexes", (t) => ({
   domainId: t.text().primaryKey().$type(),
-  index: t.integer().notNull()
+  registrationIndex: t.integer().notNull()
 }));
 var registration_relations = relations(registration, ({ one, many }) => ({
   // belongs to either v1Domain or v2Domain
@@ -376,6 +367,12 @@ var registration_relations = relations(registration, ({ one, many }) => ({
     references: [account.id],
     relationName: "registrant"
   }),
+  // has one unregistrant
+  unregistrant: one(account, {
+    fields: [registration.unregistrantId],
+    references: [account.id],
+    relationName: "unregistrant"
+  }),
   // has many renewals
   renewals: many(renewal),
   // has an event
@@ -391,7 +388,7 @@ var renewal = onchainTable(
     id: t.text().primaryKey().$type(),
     domainId: t.text().notNull().$type(),
     registrationIndex: t.integer().notNull(),
-    index: t.integer().notNull(),
+    renewalIndex: t.integer().notNull(),
     // all renewals have a duration
     duration: t.bigint().notNull(),
     // may have a referrer
@@ -405,14 +402,14 @@ var renewal = onchainTable(
     eventId: t.text().notNull()
   }),
   (t) => ({
-    byId: uniqueIndex().on(t.domainId, t.registrationIndex, t.index)
+    byId: uniqueIndex().on(t.domainId, t.registrationIndex, t.renewalIndex)
   })
 );
 var renewal_relations = relations(renewal, ({ one }) => ({
   // belongs to registration
   registration: one(registration, {
     fields: [renewal.domainId, renewal.registrationIndex],
-    references: [registration.domainId, registration.index]
+    references: [registration.domainId, registration.registrationIndex]
   }),
   // has an event
   event: one(event, {
@@ -425,7 +422,7 @@ var latestRenewalIndex = onchainTable(
   (t) => ({
     domainId: t.text().notNull().$type(),
     registrationIndex: t.integer().notNull(),
-    index: t.integer().notNull()
+    renewalIndex: t.integer().notNull()
   }),
   (t) => ({ pk: primaryKey({ columns: [t.domainId, t.registrationIndex] }) })
 );
@@ -524,13 +521,9 @@ var reverseNameRecord = onchainTable2(
     /**
      * Represents the ENSIP-19 Reverse Name Record for a given (address, coinType).
      *
-     * The value of this field is guaranteed to be a non-empty-string normalized ENS name (see
-     * `interpretNameRecordValue` for additional context and specific guarantees). Unnormalized
-     * names and empty string values are interpreted as a deletion of the associated Reverse Name
-     * Record entity (represented in the schema as the _absence_ of a relevant Reverse Name Record
-     * entity).
+     * The value of this field is guaranteed to be a non-empty {@link InterpretedName}.
      */
-    value: t.text().notNull()
+    value: t.text().notNull().$type()
   }),
   (t) => ({
     pk: primaryKey2({ columns: [t.address, t.coinType] })
@@ -583,14 +576,30 @@ var resolverRecords = onchainTable2(
     /**
      * Represents the value of the reverse-resolution (ENSIP-3) name() record, used for Reverse Resolution.
      *
-     * The emitted record values are interpreted according to `interpretNameRecordValue` — unnormalized
-     * names and empty string values are interpreted as a deletion of the associated record (represented
-     * here as `null`).
+     * If present, the value of this field is guaranteed to be a non-empty {@link InterpretedName}.
+     */
+    name: t.text().$type(),
+    /**
+     * ENSIP-7 contenthash raw bytes or null if not set.
+     */
+    contenthash: t.hex(),
+    /**
+     * PubkeyResolver (x, y) pair, or null if not set.
      *
-     * If set, the value of this field is guaranteed to be a non-empty-string normalized ENS name
-     * (see `interpretNameRecordValue` for additional context and specific guarantees).
+     * Invariant: both null together, or both set together.
      */
-    name: t.text()
+    pubkeyX: t.hex(),
+    pubkeyY: t.hex(),
+    /**
+     * IDNSZoneResolver zonehash or null if not set.
+     */
+    dnszonehash: t.hex(),
+    /**
+     * IVersionableResolver version. Null when no `VersionChanged` event has been seen for this
+     * (chainId, address, node) — the resolver may not implement `IVersionableResolver`, or simply
+     * may never have been version-bumped. Consumers should treat null as "unknown" rather than 0.
+     */
+    version: t.bigint().$type()
   }),
   (t) => ({
     byId: uniqueIndex2().on(t.chainId, t.address, t.node)
@@ -668,7 +677,7 @@ var resolverTextRecordRelations = relations2(resolverTextRecord, ({ one }) => ({
   })
 }));
 var migratedNode = onchainTable2("migrated_nodes", (t) => ({
-  node: t.hex().primaryKey()
+  node: t.hex().primaryKey().$type()
 }));
 
 // src/ensindexer-abstract/registrars.schema.ts
@@ -935,7 +944,7 @@ var registrarActions = onchainTable3(
      * 3) May be the "zero address" to represent that an `encodedReferrer` is
      *    defined but that it is interpreted as no referrer.
      */
-    decodedReferrer: t.hex(),
+    decodedReferrer: t.hex().$type(),
     /**
      * Number of the block that includes the "logical registrar action".
      *
@@ -1049,7 +1058,7 @@ var registrarActionRelations = relations3(registrarActions, ({ one }) => ({
 }));
 
 // src/ensindexer-abstract/subgraph.schema.ts
-import { index as index3, onchainTable as onchainTable4, relations as relations4 } from "ponder";
+import { index as index3, onchainTable as onchainTable4, relations as relations4, sql as sql2 } from "ponder";
 
 // src/lib/collate.ts
 function monkeypatchCollate(col, collation) {
@@ -1129,9 +1138,12 @@ var subgraph_domain = onchainTable4(
     expiryDate: t.bigint()
   }),
   (t) => ({
-    // Temporarily disable the `byName` index to avoid index creation issues.
-    // For more details, see: https://github.com/namehash/ensnode/issues/1819
-    // byName: index().on(t.name),
+    // uses a hash index because some name values exceed the btree max row size (8191 bytes)
+    byExactName: index3().using("hash", t.name),
+    // GIN trigram index for partial-match filters (_contains, _starts_with, _ends_with).
+    // (inline `gin_trgm_ops` via `sql` because passing it through `.op()` gets dropped by Ponder,
+    // producing `USING gin (name)` with no opclass)
+    byFuzzyName: index3().using("gin", sql2`${t.name} gin_trgm_ops`),
     byLabelhash: index3().on(t.labelhash),
     byParentId: index3().on(t.parentId),
     byOwnerId: index3().on(t.ownerId),
@@ -1983,6 +1995,17 @@ var metadata = ENSNODE_SCHEMA.table(
   ]
 );
 
+// src/lib/drizzle.ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { isPgEnum } from "drizzle-orm/pg-core";
+import { isTable, Table } from "drizzle-orm/table";
+
+// src/lib/checksum.ts
+import { createHash } from "crypto";
+function createChecksum(data) {
+  return createHash("sha256").update(data).digest("hex").slice(0, 10);
+}
+
 // src/lib/drizzle.ts
 var appliedNameForConcreteEnsIndexerSchema;
 function buildConcreteEnsIndexerSchema(ensIndexerSchemaName) {
@@ -2023,6 +2046,50 @@ function buildEnsDbDrizzleClient(connectionString, concreteEnsIndexerSchema, log
     logger
   });
 }
+function safeStringifyDrizzleSchema(schema) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(schema, (_key, value) => {
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "[circular]";
+      seen.add(value);
+    }
+    return value;
+  });
+}
+function getDrizzleSchemaChecksum(schema) {
+  const stringifiedSchema = safeStringifyDrizzleSchema(schema);
+  return createChecksum(stringifiedSchema);
+}
+
+// src/client/ensdb-config.ts
+var ENSDB_SCHEMA_CHECKSUM = getDrizzleSchemaChecksum({
+  ...ensindexer_abstract_exports,
+  ...ensnode_exports
+});
+
+// src/client/ensdb-reader.ts
+import { and, eq } from "drizzle-orm/sql";
+import {
+  deserializeCrossChainIndexingStatusSnapshot,
+  deserializeEnsIndexerPublicConfig
+} from "@ensnode/ensnode-sdk";
+
+// src/lib/parse-pg-version-info.ts
+function parsePgVersionInfo(versionString) {
+  if (typeof versionString !== "string") {
+    throw new Error("PostgreSQL version string must be a string");
+  }
+  const match = versionString.match(/PostgreSQL (\d+\.\d+)/);
+  if (!match) {
+    throw new Error(`Failed to parse PostgreSQL version from version string: '${versionString}'`);
+  }
+  const parsedVersion = match[1];
+  if (typeof parsedVersion !== "string") {
+    throw new Error(`Parsed PostgreSQL version is not a string: '${parsedVersion}'`);
+  }
+  return parsedVersion;
+}
 
 // src/client/ensnode-metadata.ts
 var EnsNodeMetadataKeys = {
@@ -2131,6 +2198,15 @@ var EnsDbReader = class {
     }
     return deserializeEnsIndexerPublicConfig(record);
   }
+  /**
+   * Build ENSDb Public Config
+   */
+  async buildEnsDbPublicConfig() {
+    const versionInfo = await this.buildEnsDbVersionInfo();
+    return {
+      versionInfo
+    };
+  }
   /**
    * Get Indexing Status Snapshot
    *
@@ -2172,6 +2248,33 @@ var EnsDbReader = class {
       `There must be exactly one ENSNodeMetadata record for ('${this.ensIndexerSchemaName}', '${metadata2.key}') composite key`
     );
   }
+  /**
+   * Get PostgreSQL version for the server hosting the ENSDb instance.
+   *
+   * @throws when the version cannot be retrieved or parsed from the query result.
+   */
+  async getPostgresVersion() {
+    const result = await this.ensDb.execute("SELECT version();");
+    const versionString = result.rows[0]?.version;
+    try {
+      return parsePgVersionInfo(versionString);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to get PostgreSQL version for the ENSDb instance: ${errorMessage}`);
+    }
+  }
+  /**
+   * Build ENSDb version info.
+   *
+   * @throws when version info cannot be retrieved or parsed from
+   *         the ENSDb instance.
+   */
+  async buildEnsDbVersionInfo() {
+    const postgresVersion = await this.getPostgresVersion();
+    return {
+      postgresql: postgresVersion
+    };
+  }
 };
 
 // src/client/ensdb-writer.ts
@@ -2243,9 +2346,54 @@ var EnsDbWriter = class extends EnsDbReader {
     });
   }
 };
+
+// src/client/validate/ensdb-config.ts
+import { prettifyError } from "zod/v4";
+
+// src/client/zod-schemas/ensdb-config.ts
+import { parse as parseConnectionString } from "pg-connection-string";
+import { z } from "zod/v4";
+var EnsDbUrlSchema = z.string().refine(
+  (url) => {
+    try {
+      if (!url.startsWith("postgresql://") && !url.startsWith("postgres://")) {
+        return false;
+      }
+      const config = parseConnectionString(url);
+      return !!(config.host && config.port && config.database);
+    } catch {
+      return false;
+    }
+  },
+  {
+    error: "Invalid PostgreSQL connection string for ENSDb. Expected format: postgresql://username:password@host:port/database"
+  }
+);
+var EnsIndexerSchemaNameSchema = z.string({
+  error: "ENSIndexer Schema Name is required."
+}).trim().nonempty({
+  error: "ENSIndexer Schema Name cannot be an empty string."
+});
+var EnsDbConfigSchema = z.object({
+  ensDbUrl: EnsDbUrlSchema,
+  ensIndexerSchemaName: EnsIndexerSchemaNameSchema
+});
+
+// src/client/validate/ensdb-config.ts
+function validateEnsDbConfig(unvalidatedConfig) {
+  const ensDbConfig = EnsDbConfigSchema.safeParse(unvalidatedConfig);
+  if (!ensDbConfig.success) {
+    throw new Error(`Failed to parse ENSDb configuration: 
+${prettifyError(ensDbConfig.error)}
+`);
+  }
+  return ensDbConfig.data;
+}
 export {
+  ENSDB_SCHEMA_CHECKSUM,
   EnsDbReader,
   EnsDbWriter,
-  EnsNodeMetadataKeys
+  EnsNodeMetadataKeys,
+  validateEnsDbConfig
 };
 //# sourceMappingURL=index.js.map