@ensnode/ensdb-sdk 1.15.1 → 1.16.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 NameHash
+Copyright (c) 2026 NameHash Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/ensindexer-abstract/index.d.ts

@@ -1,4 +1,4 @@
-export { b as account, c as account_relations, d as domain, e as domainEvent, f as domainResolverRelation, g as domainResolverRelation_relations, h as domainType, i as event, j as internal_registrarActionMetadata, k as internal_registrarActionMetadataType, l as label, m as label_relations, n as latestRegistrationIndex, o as latestRegistrationIndex_relations, p as latestRenewalIndex, q as latestRenewalIndex_relations, r as migratedNodeByNode, s as migratedNodeByParent, t as nameSales, u as nameTokens, v as permissions, w as permissionsEvent, x as permissionsResource, y as permissionsUser, z as permissionsUserEvent, A as registrarActionRelations, B as registrarActionType, C as registrarActions, D as registration, E as registrationLifecycleRelations, F as registrationLifecycles, G as registrationType, H as registration_relations, I as registry, J as registryType, K as relations_domain, L as relations_permissions, M as relations_permissionsResource, N as relations_permissionsUser, O as relations_registry, P as renewal, Q as renewal_relations, R as resolver, S as resolverAddressRecord, T as resolverAddressRecordRelations, U as resolverEvent, V as resolverRecords, W as resolverRecords_relations, X as resolverTextRecord, Y as resolverTextRecordRelations, Z as resolver_relations, _ as reverseNameRecord, $ as subgraph_abiChanged, a0 as subgraph_abiChangedRelations, a1 as subgraph_account, a2 as subgraph_accountRelations, a3 as subgraph_addrChanged, a4 as subgraph_addrChangedRelations, a5 as subgraph_authorisationChanged, a6 as subgraph_authorisationChangedRelations, a7 as subgraph_contenthashChanged, a8 as subgraph_contenthashChangedRelations, a9 as subgraph_domain, aa as subgraph_domainRelations, ab as subgraph_expiryExtended, ac as subgraph_expiryExtendedRelations, ad as subgraph_fusesSet, ae as subgraph_fusesSetRelations, af as subgraph_interfaceChanged, ag as subgraph_interfaceChangedRelations, ah as subgraph_multicoinAddrChanged, ai as subgraph_multicoinAddrChangedRelations, aj as subgraph_nameChanged, ak as subgraph_nameChangedRelations, al as subgraph_nameRegistered, am as subgraph_nameRegisteredRelations, an as subgraph_nameRenewed, ao as subgraph_nameRenewedRelations, ap as subgraph_nameTransferred, aq as subgraph_nameTransferredRelations, ar as subgraph_nameUnwrapped, as as subgraph_nameUnwrappedRelations, at as subgraph_nameWrapped, au as subgraph_nameWrappedRelations, av as subgraph_newOwner, aw as subgraph_newOwnerRelations, ax as subgraph_newResolver, ay as subgraph_newResolverRelations, az as subgraph_newTTL, aA as subgraph_newTTLRelations, aB as subgraph_pubkeyChanged, aC as subgraph_pubkeyChangedRelations, aD as subgraph_registration, aE as subgraph_registrationRelations, aF as subgraph_resolver, aG as subgraph_resolverRelations, aH as subgraph_textChanged, aI as subgraph_textChangedRelations, aJ as subgraph_transfer, aK as subgraph_transferRelations, aL as subgraph_versionChanged, aM as subgraph_versionChangedRelations, aN as subgraph_wrappedDomain, aO as subgraph_wrappedDomainRelations, aP as subgraph_wrappedTransfer, aQ as subgraph_wrappedTransferRelations, aR as subregistries, aS as subregistryRelations } from '../index-1D8_3_7g.js';
+export { C as CANONICAL_NAME_PREFIX_LENGTH, R as REGISTRATION_SORT_SENTINEL, b as account, c as account_relations, d as domain, e as domainEvent, f as domainResolverRelation, g as domainResolverRelation_relations, h as domainType, i as event, j as internal_registrarActionMetadata, k as internal_registrarActionMetadataType, l as label, m as label_relations, n as latestRegistrationIndex, o as latestRegistrationIndex_relations, p as latestRenewalIndex, q as latestRenewalIndex_relations, r as migratedNodeByNode, s as migratedNodeByParent, t as nameSales, u as nameTokens, v as permissions, w as permissionsEvent, x as permissionsResource, y as permissionsUser, z as permissionsUserEvent, A as registrarActionRelations, B as registrarActionType, D as registrarActions, E as registration, F as registrationLifecycleRelations, G as registrationLifecycles, H as registrationType, I as registration_relations, J as registry, K as registryType, L as relations_domain, M as relations_permissions, N as relations_permissionsResource, O as relations_permissionsUser, P as relations_registry, Q as renewal, S as renewal_relations, T as resolver, U as resolverAddressRecord, V as resolverAddressRecordRelations, W as resolverEvent, X as resolverRecords, Y as resolverRecords_relations, Z as resolverTextRecord, _ as resolverTextRecordRelations, $ as resolver_relations, a0 as reverseNameRecord, a1 as subgraph_abiChanged, a2 as subgraph_abiChangedRelations, a3 as subgraph_account, a4 as subgraph_accountRelations, a5 as subgraph_addrChanged, a6 as subgraph_addrChangedRelations, a7 as subgraph_authorisationChanged, a8 as subgraph_authorisationChangedRelations, a9 as subgraph_contenthashChanged, aa as subgraph_contenthashChangedRelations, ab as subgraph_domain, ac as subgraph_domainRelations, ad as subgraph_expiryExtended, ae as subgraph_expiryExtendedRelations, af as subgraph_fusesSet, ag as subgraph_fusesSetRelations, ah as subgraph_interfaceChanged, ai as subgraph_interfaceChangedRelations, aj as subgraph_multicoinAddrChanged, ak as subgraph_multicoinAddrChangedRelations, al as subgraph_nameChanged, am as subgraph_nameChangedRelations, an as subgraph_nameRegistered, ao as subgraph_nameRegisteredRelations, ap as subgraph_nameRenewed, aq as subgraph_nameRenewedRelations, ar as subgraph_nameTransferred, as as subgraph_nameTransferredRelations, at as subgraph_nameUnwrapped, au as subgraph_nameUnwrappedRelations, av as subgraph_nameWrapped, aw as subgraph_nameWrappedRelations, ax as subgraph_newOwner, ay as subgraph_newOwnerRelations, az as subgraph_newResolver, aA as subgraph_newResolverRelations, aB as subgraph_newTTL, aC as subgraph_newTTLRelations, aD as subgraph_pubkeyChanged, aE as subgraph_pubkeyChangedRelations, aF as subgraph_registration, aG as subgraph_registrationRelations, aH as subgraph_resolver, aI as subgraph_resolverRelations, aJ as subgraph_textChanged, aK as subgraph_textChangedRelations, aL as subgraph_transfer, aM as subgraph_transferRelations, aN as subgraph_versionChanged, aO as subgraph_versionChangedRelations, aP as subgraph_wrappedDomain, aQ as subgraph_wrappedDomainRelations, aR as subgraph_wrappedTransfer, aS as subgraph_wrappedTransferRelations, aT as subregistries, aU as subregistryRelations, aV as truncateCanonicalNamePrefix } from '../index-D36RM4zS.js';
 import 'ponder';
 import 'drizzle-orm';
 import 'drizzle-orm/pg-core';

package/dist/ensindexer-abstract/index.js

@@ -22,6 +22,8 @@ var reverseNameRecord = onchainTable2(
   (t) => ({
     // keyed by (address, coinType)
     address: t.hex().notNull().$type(),
+    // @TODO(cointype-bigint): store as `t.int8({ mode: "number" }).$type<CoinType>()` (like chainId
+    // elsewhere) so reads/writes use CoinType directly without bigint round-trips. See #2293.
     coinType: t.bigint().notNull(),
     /**
      * Represents the ENSIP-19 Reverse Name Record for a given (address, coinType).
@@ -62,7 +64,13 @@ var resolver = onchainTable2(
     // keyed by (chainId, address)
     id: t.text().primaryKey().$type(),
     chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type()
+    address: t.hex().notNull().$type(),
+    /**
+     * Whether this Resolver implements ENSIP-10 wildcard resolution (`IExtendedResolver`,
+     * interfaceId `0x9061b923`), determined via a single `supportsInterface` RPC the first
+     * time the Resolver is observed (see `upsertResolver`).
+     */
+    isExtended: t.boolean().notNull().default(false)
   }),
   (t) => ({
     byId: uniqueIndex().on(t.chainId, t.address)
@@ -131,17 +139,22 @@ var resolverAddressRecord = onchainTable2(
     node: t.hex().notNull().$type(),
     // NOTE: all well-known CoinTypes fit into javascript number but NOT postgres .integer, must be
     // stored as BigInt
+    // @TODO(cointype-bigint): use `t.int8({ mode: "number" }).$type<CoinType>()` like `chainId` above
+    // to drop bigint round-trips at every read/write boundary. See #2293.
     coinType: t.bigint().notNull(),
     /**
-     * Represents the value of the Addresss Record specified by ((chainId, resolver, node), coinType).
+     * Represents the value of the Address Record specified by ((chainId, resolver, node), coinType).
      *
      * The value of this field is interpreted by `interpretAddressRecordValue` — see its implementation
      * for additional context and specific guarantees.
      */
-    value: t.text().notNull()
+    value: t.hex().notNull()
   }),
   (t) => ({
-    pk: primaryKey2({ columns: [t.chainId, t.address, t.node, t.coinType] })
+    pk: primaryKey2({ columns: [t.chainId, t.address, t.node, t.coinType] }),
+    // supports the reverse lookup powering `Account.nameReferences`:
+    // `WHERE value = <address> [AND coin_type = <coinType>]`
+    byValueAndCoinType: index().on(t.value, t.coinType)
   })
 );
 var resolverAddressRecordRelations = relations(resolverAddressRecord, ({ one }) => ({
@@ -1569,7 +1582,19 @@ var relations_registry = relations4(registry, ({ one, many }) => ({
     references: [permissions.chainId, permissions.address]
   })
 }));
+var REGISTRATION_SORT_SENTINEL = 2n ** 256n - 1n;
 var domainType = onchainEnum2("DomainType", ["ENSv1Domain", "ENSv2Domain"]);
+var CANONICAL_NAME_PREFIX_LENGTH = 64;
+function truncateCanonicalNamePrefix(name) {
+  if (name === null) return null;
+  let prefix = "";
+  let count = 0;
+  for (const codePoint of name) {
+    prefix += codePoint;
+    if (++count >= CANONICAL_NAME_PREFIX_LENGTH) break;
+  }
+  return prefix;
+}
 var domain = onchainTable6(
   "domains",
   (t) => ({
@@ -1601,6 +1626,18 @@ var domain = onchainTable6(
      * @example "vitalik.eth"
      */
     canonicalName: t.text().$type(),
+    /**
+     * Materialized prefix of `canonicalName` (first {@link CANONICAL_NAME_PREFIX_LENGTH} code
+     * points), NULL iff `canonical = false`. Maintained by `canonicality-db-helpers.ts`.
+     *
+     * Powers left-anchored / substring search (`__canonical_name_prefix LIKE 'vit%'`) and NAME
+     * ordering without `canonical_name`'s full-length btree size hazard. The `__` prefix marks it
+     * an internal implementation detail (mirrors `Registry.__hasChildren`); query `canonical_name`
+     * for exact matches and display.
+     *
+     * @example "vitalik.eth"
+     */
+    __canonicalNamePrefix: t.text("__canonical_name_prefix").$type(),
     /**
      * Materialized Canonical LabelHashPath, NULL iff `canonical = false`.
      * Maintained by `canonicality-db-helpers.ts`.
@@ -1629,7 +1666,29 @@ var domain = onchainTable6(
      *
      * @dev the computed Node (via `namehash`) of this Domain's Canonical Name.
      */
-    canonicalNode: t.hex().$type()
+    canonicalNode: t.hex().$type(),
+    /**
+     * Materialized `start` of this Domain's latest Registration, or {@link REGISTRATION_SORT_SENTINEL}
+     * when the Domain has no Registration. Mirror of the latest `registration.start` (see
+     * `latestRegistrationIndex`), maintained inline by `registration-db-helpers.ts`.
+     *
+     * @dev Exists purely so REGISTRATION_TIMESTAMP-ordered find-domains queries can use the
+     * `(registry_id, __latest_registration_start, id)` composite index instead of joining through
+     * `latest_registration_indexes` → `registrations` and sorting. Held NOT NULL (absent → sentinel)
+     * so the keyset stays a plain tuple compare with no NULL-placement special casing; see
+     * find-domains-resolver-helpers.ts. Double-underscore prefix marks it as an internal
+     * materialized mirror, not part of the on-chain protocol surface; the canonical (possibly null)
+     * value lives on the Registration entity.
+     */
+    __latestRegistrationStart: t.bigint("__latest_registration_start").notNull().default(REGISTRATION_SORT_SENTINEL),
+    /**
+     * Materialized `expiry` of this Domain's latest Registration, or {@link REGISTRATION_SORT_SENTINEL}
+     * when the Domain has no Registration or its latest Registration never expires (effectively +∞).
+     * Mirror of the latest `registration.expiry`, maintained inline by `registration-db-helpers.ts`.
+     *
+     * @dev See `__latestRegistrationStart`. Backs REGISTRATION_EXPIRY-ordered queries.
+     */
+    __latestRegistrationExpiry: t.bigint("__latest_registration_expiry").notNull().default(REGISTRATION_SORT_SENTINEL)
     // NOTE: Domain-Resolver Relations tracked via Protocol Acceleration plugin
   }),
   (t) => ({
@@ -1641,29 +1700,40 @@ var domain = onchainTable6(
     // get-domain-by-interpreted-name.ts). The leading `registry_id` column also serves
     // `WHERE registry_id = X` lookups via prefix scan.
     byRegistryAndLabelHash: index5().on(t.registryId, t.labelHash),
-    // composite for `WHERE registry_id = X ORDER BY canonical_name LIMIT N` (Domain.subdomains
-    // and other find-domains queries when ordering by NAME). Uses `left(canonical_name, 256)`
-    // to bound the index tuple under btree's per-tuple max (~2712 bytes): 256 chars × max 4-byte
-    // UTF-8 = 1024 bytes, leaving ample room for the registry_id and id columns. Names beyond
-    // 256 chars (currently <0.0001% of mainnet) collide on the truncated prefix and tie-break by
-    // id; this is acceptable since such names are invariably spam. Callers MUST sort by the same
-    // expression for the planner to use this index for ordered scan.
-    byRegistryAndCanonicalNameLeft: index5().on(
-      t.registryId,
-      sql2`left(${t.canonicalName}, 256)`,
-      t.id
-    ),
+    // composite for `WHERE registry_id = X ORDER BY __canonical_name_prefix LIMIT N` (Domain.subdomains
+    // and other find-domains queries when ordering by NAME). The length-capped prefix keeps the
+    // index tuple under btree's per-tuple max (~2712 bytes); 64 code points × max 4-byte UTF-8 =
+    // 256 bytes, leaving ample room for the registry_id and id columns.
+    byRegistryAndCanonicalNamePrefix: index5().on(t.registryId, t.__canonicalNamePrefix, t.id),
     // hash index avoids the btree 8191-byte row-size hazard for spam names
     byCanonicalNameExact: index5().using("hash", t.canonicalName),
-    // GIN trigram index for substring / similarity queries (inline `gin_trgm_ops` via `sql`
-    // because passing it through `.op()` gets dropped by Ponder)
-    byCanonicalNameFuzzy: index5().using("gin", sql2`${t.canonicalName} gin_trgm_ops`),
+    // GIN trigram on the length-capped prefix for left-anchored (`LIKE 'vit%'`) and substring
+    // search (inline `gin_trgm_ops` via `sql` because passing it through `.op()` gets dropped by
+    // Ponder)
+    byCanonicalNamePrefixFuzzy: index5().using("gin", sql2`${t.__canonicalNamePrefix} gin_trgm_ops`),
     // GIN containment for `cascadeLabelHeal`'s `canonical_label_hash_path @> ARRAY[lh]` lookup
     byCanonicalLabelHashPath: index5().using("gin", t.canonicalLabelHashPath),
     // hash index for resolver-record → canonical-domain joins
     byCanonicalNode: index5().using("hash", t.canonicalNode),
     // btree for ORDER BY canonical_depth (typeahead and DEPTH-ordered browse)
-    byCanonicalDepth: index5().on(t.canonicalDepth)
+    byCanonicalDepth: index5().on(t.canonicalDepth),
+    // Composites for `WHERE registry_id = X ORDER BY <latest registration value> LIMIT N`
+    // (REGISTRATION_TIMESTAMP / REGISTRATION_EXPIRY ordering in find-domains queries). The latest
+    // registration's start/expiry is mirrored onto the Domain row (see `__latestRegistration*`) so
+    // the order is an index-ordered scan, not a join through `latest_registration_indexes` →
+    // `registrations` followed by a sort. The columns are NOT NULL (absent → `REGISTRATION_SORT_SENTINEL`),
+    // so a single plain composite per column serves both ASC and DESC (forward / backward scan) with
+    // a plain keyset tuple — see find-domains-resolver-helpers.ts.
+    byRegistryAndLatestRegistrationStart: index5().on(
+      t.registryId,
+      t.__latestRegistrationStart,
+      t.id
+    ),
+    byRegistryAndLatestRegistrationExpiry: index5().on(
+      t.registryId,
+      t.__latestRegistrationExpiry,
+      t.id
+    )
   })
 );
 var relations_domain = relations4(domain, ({ one, many }) => ({
@@ -1715,7 +1785,7 @@ var registration = onchainTable6(
     start: t.bigint().notNull(),
     // may have an expiry
     expiry: t.bigint(),
-    // maybe have a grace period (BaseRegistrar)
+    // may have a grace period (BaseRegistrar)
     gracePeriod: t.bigint(),
     // registrar AccountId
     registrarChainId: t.int8({ mode: "number" }).notNull().$type(),
@@ -1923,6 +1993,8 @@ var label_relations = relations4(label, ({ many }) => ({
   domains: many(domain)
 }));
 export {
+  CANONICAL_NAME_PREFIX_LENGTH,
+  REGISTRATION_SORT_SENTINEL,
   account,
   account_relations,
   domain,
@@ -2030,6 +2102,7 @@ export {
   subgraph_wrappedTransfer,
   subgraph_wrappedTransferRelations,
   subregistries,
-  subregistryRelations
+  subregistryRelations,
+  truncateCanonicalNamePrefix
 };
 //# sourceMappingURL=index.js.map