@ensnode/ensdb-sdk 1.13.1 → 1.15.0

package/dist/index.js

@@ -10,7 +10,7 @@ __export(ensindexer_abstract_exports, {
   account: () => account,
   account_relations: () => account_relations,
   domain: () => domain,
-  domainEvent: () => domainEvent,
+  domainEvent: () => domainEvent2,
   domainResolverRelation: () => domainResolverRelation,
   domainResolverRelation_relations: () => domainResolverRelation_relations,
   domainType: () => domainType,
@@ -52,7 +52,7 @@ __export(ensindexer_abstract_exports, {
   resolver: () => resolver,
   resolverAddressRecord: () => resolverAddressRecord,
   resolverAddressRecordRelations: () => resolverAddressRecordRelations,
-  resolverEvent: () => resolverEvent,
+  resolverEvent: () => resolverEvent2,
   resolverRecords: () => resolverRecords,
   resolverRecords_relations: () => resolverRecords_relations,
   resolverTextRecord: () => resolverTextRecord,
@@ -117,633 +117,224 @@ __export(ensindexer_abstract_exports, {
   subregistryRelations: () => subregistryRelations
 });
 
-// src/ensindexer-abstract/ensv2.schema.ts
-import { index, onchainEnum, onchainTable, primaryKey, relations, sql, uniqueIndex } from "ponder";
-var event = onchainTable(
-  "events",
+// src/ensindexer-abstract/migrated-nodes.schema.ts
+import { onchainTable, primaryKey } from "ponder";
+var migratedNodeByParent = onchainTable(
+  "migrated_nodes_by_parent",
   (t) => ({
-    // Ponder's event.id
-    id: t.text().primaryKey(),
-    // The HCA account address if used, otherwise Transaction.from.
-    sender: t.hex().notNull().$type(),
-    // Event Log Metadata
-    // chain
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    // block
-    blockNumber: t.bigint().notNull().$type(),
-    blockHash: t.hex().notNull().$type(),
-    timestamp: t.bigint().notNull(),
-    // transaction
-    transactionHash: t.hex().notNull().$type(),
-    transactionIndex: t.integer().notNull(),
-    // `tx.from` — never HCA-aware. Always the EOA/relayer that submitted the transaction.
-    // Use `event.sender` for the HCA-aware actor.
-    from: t.hex().notNull().$type(),
-    to: t.hex().$type(),
-    // NOTE: a null `to` means this was a tx that deployed a contract
-    // log
+    // keyed by (parentNode, labelHash)
+    parentNode: t.hex().notNull().$type(),
+    labelHash: t.hex().notNull().$type()
+  }),
+  (t) => ({
+    pk: primaryKey({ columns: [t.parentNode, t.labelHash] })
+  })
+);
+var migratedNodeByNode = onchainTable("migrated_nodes_by_node", (t) => ({
+  node: t.hex().primaryKey().$type()
+}));
+
+// src/ensindexer-abstract/protocol-acceleration.schema.ts
+import { index, onchainTable as onchainTable2, primaryKey as primaryKey2, relations, uniqueIndex } from "ponder";
+var reverseNameRecord = onchainTable2(
+  "reverse_name_records",
+  (t) => ({
+    // keyed by (address, coinType)
     address: t.hex().notNull().$type(),
-    logIndex: t.integer().notNull().$type(),
-    selector: t.hex().notNull().$type(),
-    topics: t.hex().array().notNull().$type(),
-    data: t.hex().notNull()
+    coinType: t.bigint().notNull(),
+    /**
+     * Represents the ENSIP-19 Reverse Name Record for a given (address, coinType).
+     *
+     * The value of this field is guaranteed to be a non-empty {@link InterpretedName}.
+     */
+    value: t.text().notNull().$type()
   }),
   (t) => ({
-    bySelector: index().on(t.selector),
-    byFrom: index().on(t.from),
-    bySender: index().on(t.sender),
-    byTimestamp: index().on(t.timestamp)
+    pk: primaryKey2({ columns: [t.address, t.coinType] })
   })
 );
-var domainEvent = onchainTable(
-  "domain_events",
+var domainResolverRelation = onchainTable2(
+  "domain_resolver_relations",
   (t) => ({
+    // keyed by (chainId, address, node)
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    // The Registry (ENSv1Registry or ENSv2Registry)'s AccountId.
+    address: t.hex().notNull().$type(),
     domainId: t.text().notNull().$type(),
-    eventId: t.text().notNull()
+    // The Domain's assigned Resolver's address (NOTE: always scoped to chainId)
+    resolver: t.hex().notNull().$type()
   }),
-  (t) => ({ pk: primaryKey({ columns: [t.domainId, t.eventId] }) })
+  (t) => ({
+    pk: primaryKey2({ columns: [t.chainId, t.address, t.domainId] }),
+    byDomain: index().on(t.domainId)
+  })
 );
-var resolverEvent = onchainTable(
-  "resolver_events",
+var domainResolverRelation_relations = relations(domainResolverRelation, ({ one }) => ({
+  resolver: one(resolver, {
+    fields: [domainResolverRelation.chainId, domainResolverRelation.resolver],
+    references: [resolver.chainId, resolver.address]
+  })
+}));
+var resolver = onchainTable2(
+  "resolvers",
   (t) => ({
-    resolverId: t.text().notNull().$type(),
-    eventId: t.text().notNull()
+    // keyed by (chainId, address)
+    id: t.text().primaryKey().$type(),
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type()
   }),
-  (t) => ({ pk: primaryKey({ columns: [t.resolverId, t.eventId] }) })
+  (t) => ({
+    byId: uniqueIndex().on(t.chainId, t.address)
+  })
 );
-var permissionsEvent = onchainTable(
-  "permissions_events",
+var resolver_relations = relations(resolver, ({ many }) => ({
+  records: many(resolverRecords)
+}));
+var resolverRecords = onchainTable2(
+  "resolver_records",
   (t) => ({
-    permissionsId: t.text().notNull().$type(),
-    eventId: t.text().notNull()
+    // keyed by (chainId, resolver, node)
+    id: t.text().primaryKey().$type(),
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type(),
+    node: t.hex().notNull().$type(),
+    /**
+     * Represents the value of the reverse-resolution (ENSIP-3) name() record, used for Reverse Resolution.
+     *
+     * 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.
+     *
+     * Invariant: both null together, or both set together.
+     */
+    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) => ({ pk: primaryKey({ columns: [t.permissionsId, t.eventId] }) })
+  (t) => ({
+    byId: uniqueIndex().on(t.chainId, t.address, t.node)
+  })
 );
-var permissionsUserEvent = onchainTable(
-  "permissions_user_events",
+var resolverRecords_relations = relations(resolverRecords, ({ one, many }) => ({
+  // belongs to resolver
+  resolver: one(resolver, {
+    fields: [resolverRecords.chainId, resolverRecords.address],
+    references: [resolver.chainId, resolver.address]
+  }),
+  // resolverRecord has many address records
+  addressRecords: many(resolverAddressRecord),
+  // resolverRecord has many text records
+  textRecords: many(resolverTextRecord)
+}));
+var resolverAddressRecord = onchainTable2(
+  "resolver_address_records",
   (t) => ({
-    permissionsUserId: t.text().notNull().$type(),
-    eventId: t.text().notNull()
+    // keyed by ((chainId, resolver, node), coinType)
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type(),
+    node: t.hex().notNull().$type(),
+    // NOTE: all well-known CoinTypes fit into javascript number but NOT postgres .integer, must be
+    // stored as BigInt
+    coinType: t.bigint().notNull(),
+    /**
+     * Represents the value of the Addresss 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()
   }),
-  (t) => ({ pk: primaryKey({ columns: [t.permissionsUserId, t.eventId] }) })
+  (t) => ({
+    pk: primaryKey2({ columns: [t.chainId, t.address, t.node, t.coinType] })
+  })
 );
-var account = onchainTable("accounts", (t) => ({
-  id: t.hex().primaryKey().$type()
-}));
-var account_relations = relations(account, ({ many }) => ({
-  registrations: many(registration, { relationName: "registrant" }),
-  domains: many(domain),
-  permissions: many(permissionsUser)
+var resolverAddressRecordRelations = relations(resolverAddressRecord, ({ one }) => ({
+  // belongs to resolverRecord
+  resolver: one(resolverRecords, {
+    fields: [
+      resolverAddressRecord.chainId,
+      resolverAddressRecord.address,
+      resolverAddressRecord.node
+    ],
+    references: [resolverRecords.chainId, resolverRecords.address, resolverRecords.node]
+  })
 }));
-var registryType = onchainEnum("RegistryType", [
-  "ENSv1Registry",
-  "ENSv1VirtualRegistry",
-  "ENSv2Registry"
-]);
-var registry = onchainTable(
-  "registries",
+var resolverTextRecord = onchainTable2(
+  "resolver_text_records",
   (t) => ({
-    // see RegistryId for guarantees
-    id: t.text().primaryKey().$type(),
-    // has a type
-    type: registryType().notNull(),
+    // keyed by ((chainId, resolver, node), key)
     chainId: t.int8({ mode: "number" }).notNull().$type(),
     address: t.hex().notNull().$type(),
-    // If this is an ENSv1VirtualRegistry, `node` is the namehash of the parent ENSv1 domain that
-    // owns it, otherwise null.
-    node: t.hex().$type(),
-    // the Registry's declared Canonical Domain (uni-directional)
-    canonicalDomainId: t.text().$type(),
-    // Whether this Registry is part of the canonical nametree. See canonicality-db-helpers.ts.
-    canonical: t.boolean().notNull().default(false),
-    // Synthetic monotonic sentinel: flipped to true the first time a child Domain is registered
-    // under this Registry (see `ensureDomainInRegistry`). Read by `cascadeCanonicality` to skip
-    // the raw-SQL recursive-CTE walk (and its associated Ponder cache flush) when the start
-    // registry provably has no descendants — the dominant case for fresh ENSv1 virtual
-    // registries on first wire-up. Double-underscore prefix marks it as an internal-only
-    // bookkeeping field, not part of the on-chain protocol surface.
-    __hasChildren: t.boolean().notNull().default(false)
+    node: t.hex().notNull().$type(),
+    key: t.text().notNull(),
+    /**
+     * Represents the value of the Text Record specified by ((chainId, resolver, node), key).
+     *
+     * The value of this field is interpreted by `interpretTextRecordValue` — see its implementation
+     * for additional context and specific guarantees.
+     */
+    value: t.text().notNull()
   }),
   (t) => ({
-    // NOTE: non-unique index because multiple rows can share (chainId, address) across virtual registries
-    byChainAddress: index().on(t.chainId, t.address)
+    pk: primaryKey2({ columns: [t.chainId, t.address, t.node, t.key] })
   })
 );
-var relations_registry = relations(registry, ({ one, many }) => ({
-  // domains that declare this registry as their parent registry
-  domains: many(domain, { relationName: "registry" }),
-  // domains that declare this registry as their subregistry
-  domainsAsSubregistry: many(domain, { relationName: "subregistry" }),
-  permissions: one(permissions, {
-    relationName: "permissions",
-    fields: [registry.chainId, registry.address],
-    references: [permissions.chainId, permissions.address]
+var resolverTextRecordRelations = relations(resolverTextRecord, ({ one }) => ({
+  // belongs to resolverRecord
+  resolver: one(resolverRecords, {
+    fields: [resolverTextRecord.chainId, resolverTextRecord.address, resolverTextRecord.node],
+    references: [resolverRecords.chainId, resolverRecords.address, resolverRecords.node]
   })
 }));
-var domainType = onchainEnum("DomainType", ["ENSv1Domain", "ENSv2Domain"]);
-var domain = onchainTable(
-  "domains",
+
+// src/ensindexer-abstract/registrars.schema.ts
+import { index as index2, onchainEnum, onchainTable as onchainTable3, relations as relations2, uniqueIndex as uniqueIndex2 } from "ponder";
+var subregistries = onchainTable3(
+  "subregistries",
   (t) => ({
-    // see DomainId for guarantees (ENSv1DomainId: `${ENSv1RegistryId}/${node}`, ENSv2DomainId: CAIP-19)
-    id: t.text().primaryKey().$type(),
-    // has a type
-    type: domainType().notNull(),
-    // belongs to a registry
-    registryId: t.text().notNull().$type(),
-    // the Domain's declared Subregistry (uni-directional)
-    subregistryId: t.text().$type(),
-    // If this is an ENSv2Domain, the TokenId within the ENSv2Registry, otherwise null.
-    tokenId: t.bigint().$type(),
-    // If this is an ENSv1Domain, The Domain's namehash, otherwise null.
-    node: t.hex().$type(),
-    // represents a labelHash
-    labelHash: t.hex().notNull().$type(),
-    // If this is an ENSv1Domain, this is the effective owner of the Domain.
-    // If this is an ENSv2Domain, this is the on-chain owner address (the HCA account address if used).
-    ownerId: t.hex().$type(),
-    // If this is an ENSv1Domain, may have a `rootRegistryOwner`, otherwise null.
-    rootRegistryOwnerId: t.hex().$type(),
-    // Whether this Domain is part of the canonical nametree. Mirrors the parent Registry's flag.
-    canonical: t.boolean().notNull().default(false)
-    // NOTE: Domain-Resolver Relations tracked via Protocol Acceleration plugin
+    /**
+     * Subregistry ID
+     *
+     * Identifies the chainId and address of the smart contract associated
+     * with the subregistry.
+     *
+     * Guaranteed to be a fully lowercase string formatted according to
+     * the CAIP-10 standard.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-10
+     */
+    subregistryId: t.text().primaryKey(),
+    /**
+     * The node (namehash) of the name the subregistry manages subnames of.
+     * Example subregistry managed names:
+     * - `eth`
+     * - `base.eth`
+     * - `linea.eth`
+     *
+     * Guaranteed to be a fully lowercase hex string representation of 32-bytes.
+     */
+    node: t.hex().notNull()
   }),
   (t) => ({
-    byType: index().on(t.type),
-    byRegistry: index().on(t.registryId),
-    bySubregistry: index().on(t.subregistryId).where(sql`${t.subregistryId} IS NOT NULL`),
-    byOwner: index().on(t.ownerId),
-    byLabelHash: index().on(t.labelHash)
+    uniqueNode: uniqueIndex2().on(t.node)
   })
 );
-var relations_domain = relations(domain, ({ one, many }) => ({
-  registry: one(registry, {
-    relationName: "registry",
-    fields: [domain.registryId],
-    references: [registry.id]
-  }),
-  subregistry: one(registry, {
-    relationName: "subregistry",
-    fields: [domain.subregistryId],
-    references: [registry.id]
-  }),
-  owner: one(account, {
-    relationName: "owner",
-    fields: [domain.ownerId],
-    references: [account.id]
-  }),
-  rootRegistryOwner: one(account, {
-    relationName: "rootRegistryOwner",
-    fields: [domain.rootRegistryOwnerId],
-    references: [account.id]
-  }),
-  label: one(label, {
-    relationName: "label",
-    fields: [domain.labelHash],
-    references: [label.labelHash]
-  }),
-  registrations: many(registration)
-}));
-var registrationType = onchainEnum("RegistrationType", [
-  // TODO: prefix these with ENSv1, maybe excluding ThreeDNS
-  "NameWrapper",
-  "BaseRegistrar",
-  "ThreeDNS",
-  "ENSv2RegistryRegistration",
-  "ENSv2RegistryReservation"
-]);
-var registration = onchainTable(
-  "registrations",
-  (t) => ({
-    // keyed by (domainId, registrationIndex)
-    id: t.text().primaryKey().$type(),
-    domainId: t.text().notNull().$type(),
-    registrationIndex: t.integer().notNull(),
-    // has a type
-    type: registrationType().notNull(),
-    // has a start
-    start: t.bigint().notNull(),
-    // may have an expiry
-    expiry: t.bigint(),
-    // maybe have a grace period (BaseRegistrar)
-    gracePeriod: t.bigint(),
-    // registrar AccountId
-    registrarChainId: t.int8({ mode: "number" }).notNull().$type(),
-    registrarAddress: t.hex().notNull().$type(),
-    // may reference a registrant. If this is an ENSv2 Registration, the protocol-emitted
-    // registrant address (the HCA account address if used).
-    registrantId: t.hex().$type(),
-    // may reference an unregistrant. If this is an ENSv2 Registration, the protocol-emitted
-    // unregistrant address (the HCA account address if used).
-    unregistrantId: t.hex().$type(),
-    // may have referrer data
-    referrer: t.hex().$type(),
-    // may have fuses (NameWrapper, Wrapped BaseRegistrar)
-    fuses: t.integer(),
-    // TODO(paymentToken): add payment token tracking here
-    // may have base cost (BaseRegistrar, ENSv2Registrar)
-    base: t.bigint(),
-    // may have a premium (BaseRegistrar)
-    premium: t.bigint(),
-    // may be Wrapped (BaseRegistrar)
-    wrapped: t.boolean().default(false),
-    // has an event
-    eventId: t.text().notNull()
-  }),
-  (t) => ({
-    byId: uniqueIndex().on(t.domainId, t.registrationIndex)
-  })
-);
-var registration_relations = relations(registration, ({ one, many }) => ({
-  // belongs to a domain
-  domain: one(domain, {
-    fields: [registration.domainId],
-    references: [domain.id]
-  }),
-  // has one registrant
-  registrant: one(account, {
-    fields: [registration.registrantId],
-    references: [account.id],
-    relationName: "registrant"
-  }),
-  // has a latest registration index
-  latestRegistrationIndex: one(latestRegistrationIndex),
-  // has a latest renewal index
-  latestRenewalIndex: one(latestRenewalIndex),
-  // has one unregistrant
-  unregistrant: one(account, {
-    fields: [registration.unregistrantId],
-    references: [account.id],
-    relationName: "unregistrant"
-  }),
-  // has many renewals
-  renewals: many(renewal),
-  // has an event
-  event: one(event, {
-    fields: [registration.eventId],
-    references: [event.id]
-  })
-}));
-var latestRegistrationIndex = onchainTable("latest_registration_indexes", (t) => ({
-  domainId: t.text().primaryKey().$type(),
-  registrationIndex: t.integer().notNull()
-}));
-var latestRegistrationIndex_relations = relations(latestRegistrationIndex, ({ one }) => ({
-  // references domain
-  domain: one(domain, {
-    fields: [latestRegistrationIndex.domainId],
-    references: [domain.id]
-  })
-}));
-var renewal = onchainTable(
-  "renewals",
-  (t) => ({
-    // keyed by (registrationId, index)
-    id: t.text().primaryKey().$type(),
-    domainId: t.text().notNull().$type(),
-    registrationIndex: t.integer().notNull(),
-    renewalIndex: t.integer().notNull(),
-    // all renewals have a duration
-    duration: t.bigint().notNull(),
-    // may have a referrer
-    referrer: t.hex().$type(),
-    // TODO(paymentToken): add payment token tracking here
-    // may have base cost
-    base: t.bigint(),
-    // may have a premium (ENSv1 RegistrarControllers)
-    premium: t.bigint(),
-    // has an event
-    eventId: t.text().notNull()
-  }),
-  (t) => ({
-    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.registrationIndex]
-  }),
-  // has an event
-  event: one(event, {
-    fields: [renewal.eventId],
-    references: [event.id]
-  })
-}));
-var latestRenewalIndex = onchainTable(
-  "latest_renewal_indexes",
-  (t) => ({
-    domainId: t.text().notNull().$type(),
-    registrationIndex: t.integer().notNull(),
-    renewalIndex: t.integer().notNull()
-  }),
-  (t) => ({ pk: primaryKey({ columns: [t.domainId, t.registrationIndex] }) })
-);
-var latestRenewalIndex_relations = relations(latestRenewalIndex, ({ one }) => ({
-  // references domain
-  domain: one(domain, {
-    fields: [latestRenewalIndex.domainId],
-    references: [domain.id]
-  })
-}));
-var permissions = onchainTable(
-  "permissions",
-  (t) => ({
-    id: t.text().primaryKey().$type(),
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type()
-  }),
-  (t) => ({
-    byId: uniqueIndex().on(t.chainId, t.address)
-  })
-);
-var relations_permissions = relations(permissions, ({ many }) => ({
-  resources: many(permissionsResource),
-  users: many(permissionsUser)
-}));
-var permissionsResource = onchainTable(
-  "permissions_resources",
-  (t) => ({
-    id: t.text().primaryKey().$type(),
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type(),
-    resource: t.bigint().notNull()
-  }),
-  (t) => ({
-    byId: uniqueIndex().on(t.chainId, t.address, t.resource)
-  })
-);
-var relations_permissionsResource = relations(permissionsResource, ({ one }) => ({
-  permissions: one(permissions, {
-    fields: [permissionsResource.chainId, permissionsResource.address],
-    references: [permissions.chainId, permissions.address]
-  })
-}));
-var permissionsUser = onchainTable(
-  "permissions_users",
-  (t) => ({
-    id: t.text().primaryKey().$type(),
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type(),
-    resource: t.bigint().notNull(),
-    // The user/grantee address this Permission is granted to (the HCA account address if used).
-    user: t.hex().notNull().$type(),
-    // has one roles bitmap
-    roles: t.bigint().notNull()
-  }),
-  (t) => ({
-    byId: uniqueIndex().on(t.chainId, t.address, t.resource, t.user)
-  })
-);
-var relations_permissionsUser = relations(permissionsUser, ({ one }) => ({
-  account: one(account, {
-    fields: [permissionsUser.user],
-    references: [account.id]
-  }),
-  permissions: one(permissions, {
-    fields: [permissionsUser.chainId, permissionsUser.address],
-    references: [permissions.chainId, permissions.address]
-  }),
-  resource: one(permissionsResource, {
-    fields: [permissionsUser.chainId, permissionsUser.address, permissionsUser.resource],
-    references: [
-      permissionsResource.chainId,
-      permissionsResource.address,
-      permissionsResource.resource
-    ]
-  })
-}));
-var label = onchainTable(
-  "labels",
-  (t) => ({
-    labelHash: t.hex().primaryKey().$type(),
-    interpreted: t.text().notNull().$type()
-  }),
-  (t) => ({
-    byInterpreted: index().on(t.interpreted)
-  })
-);
-var label_relations = relations(label, ({ many }) => ({
-  domains: many(domain)
-}));
-
-// src/ensindexer-abstract/migrated-nodes.schema.ts
-import { onchainTable as onchainTable2, primaryKey as primaryKey2 } from "ponder";
-var migratedNodeByParent = onchainTable2(
-  "migrated_nodes_by_parent",
-  (t) => ({
-    // keyed by (parentNode, labelHash)
-    parentNode: t.hex().notNull().$type(),
-    labelHash: t.hex().notNull().$type()
-  }),
-  (t) => ({
-    pk: primaryKey2({ columns: [t.parentNode, t.labelHash] })
-  })
-);
-var migratedNodeByNode = onchainTable2("migrated_nodes_by_node", (t) => ({
-  node: t.hex().primaryKey().$type()
-}));
-
-// src/ensindexer-abstract/protocol-acceleration.schema.ts
-import { onchainTable as onchainTable3, primaryKey as primaryKey3, relations as relations2, uniqueIndex as uniqueIndex2 } from "ponder";
-var reverseNameRecord = onchainTable3(
-  "reverse_name_records",
-  (t) => ({
-    // keyed by (address, coinType)
-    address: t.hex().notNull().$type(),
-    coinType: t.bigint().notNull(),
-    /**
-     * Represents the ENSIP-19 Reverse Name Record for a given (address, coinType).
-     *
-     * The value of this field is guaranteed to be a non-empty {@link InterpretedName}.
-     */
-    value: t.text().notNull().$type()
-  }),
-  (t) => ({
-    pk: primaryKey3({ columns: [t.address, t.coinType] })
-  })
-);
-var domainResolverRelation = onchainTable3(
-  "domain_resolver_relations",
-  (t) => ({
-    // keyed by (chainId, address, node)
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    // The Registry (ENSv1Registry or ENSv2Registry)'s AccountId.
-    address: t.hex().notNull().$type(),
-    domainId: t.text().notNull().$type(),
-    // The Domain's assigned Resolver's address (NOTE: always scoped to chainId)
-    resolver: t.hex().notNull().$type()
-  }),
-  (t) => ({
-    pk: primaryKey3({ columns: [t.chainId, t.address, t.domainId] })
-  })
-);
-var domainResolverRelation_relations = relations2(domainResolverRelation, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [domainResolverRelation.chainId, domainResolverRelation.resolver],
-    references: [resolver.chainId, resolver.address]
-  })
-}));
-var resolver = onchainTable3(
-  "resolvers",
-  (t) => ({
-    // keyed by (chainId, address)
-    id: t.text().primaryKey().$type(),
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type()
-  }),
-  (t) => ({
-    byId: uniqueIndex2().on(t.chainId, t.address)
-  })
-);
-var resolver_relations = relations2(resolver, ({ many }) => ({
-  records: many(resolverRecords)
-}));
-var resolverRecords = onchainTable3(
-  "resolver_records",
-  (t) => ({
-    // keyed by (chainId, resolver, node)
-    id: t.text().primaryKey().$type(),
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type(),
-    node: t.hex().notNull().$type(),
-    /**
-     * Represents the value of the reverse-resolution (ENSIP-3) name() record, used for Reverse Resolution.
-     *
-     * 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.
-     *
-     * Invariant: both null together, or both set together.
-     */
-    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)
-  })
-);
-var resolverRecords_relations = relations2(resolverRecords, ({ one, many }) => ({
-  // belongs to resolver
-  resolver: one(resolver, {
-    fields: [resolverRecords.chainId, resolverRecords.address],
-    references: [resolver.chainId, resolver.address]
-  }),
-  // resolverRecord has many address records
-  addressRecords: many(resolverAddressRecord),
-  // resolverRecord has many text records
-  textRecords: many(resolverTextRecord)
-}));
-var resolverAddressRecord = onchainTable3(
-  "resolver_address_records",
-  (t) => ({
-    // keyed by ((chainId, resolver, node), coinType)
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type(),
-    node: t.hex().notNull().$type(),
-    // NOTE: all well-known CoinTypes fit into javascript number but NOT postgres .integer, must be
-    // stored as BigInt
-    coinType: t.bigint().notNull(),
-    /**
-     * Represents the value of the Addresss 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()
-  }),
-  (t) => ({
-    pk: primaryKey3({ columns: [t.chainId, t.address, t.node, t.coinType] })
-  })
-);
-var resolverAddressRecordRelations = relations2(resolverAddressRecord, ({ one }) => ({
-  // belongs to resolverRecord
-  resolver: one(resolverRecords, {
-    fields: [
-      resolverAddressRecord.chainId,
-      resolverAddressRecord.address,
-      resolverAddressRecord.node
-    ],
-    references: [resolverRecords.chainId, resolverRecords.address, resolverRecords.node]
-  })
-}));
-var resolverTextRecord = onchainTable3(
-  "resolver_text_records",
-  (t) => ({
-    // keyed by ((chainId, resolver, node), key)
-    chainId: t.int8({ mode: "number" }).notNull().$type(),
-    address: t.hex().notNull().$type(),
-    node: t.hex().notNull().$type(),
-    key: t.text().notNull(),
-    /**
-     * Represents the value of the Text Record specified by ((chainId, resolver, node), key).
-     *
-     * The value of this field is interpreted by `interpretTextRecordValue` — see its implementation
-     * for additional context and specific guarantees.
-     */
-    value: t.text().notNull()
-  }),
-  (t) => ({
-    pk: primaryKey3({ columns: [t.chainId, t.address, t.node, t.key] })
-  })
-);
-var resolverTextRecordRelations = relations2(resolverTextRecord, ({ one }) => ({
-  // belongs to resolverRecord
-  resolver: one(resolverRecords, {
-    fields: [resolverTextRecord.chainId, resolverTextRecord.address, resolverTextRecord.node],
-    references: [resolverRecords.chainId, resolverRecords.address, resolverRecords.node]
-  })
-}));
-
-// src/ensindexer-abstract/registrars.schema.ts
-import { index as index2, onchainEnum as onchainEnum2, onchainTable as onchainTable4, relations as relations3, uniqueIndex as uniqueIndex3 } from "ponder";
-var subregistries = onchainTable4(
-  "subregistries",
-  (t) => ({
-    /**
-     * Subregistry ID
-     *
-     * Identifies the chainId and address of the smart contract associated
-     * with the subregistry.
-     *
-     * Guaranteed to be a fully lowercase string formatted according to
-     * the CAIP-10 standard.
-     *
-     * @see https://chainagnostic.org/CAIPs/caip-10
-     */
-    subregistryId: t.text().primaryKey(),
-    /**
-     * The node (namehash) of the name the subregistry manages subnames of.
-     * Example subregistry managed names:
-     * - `eth`
-     * - `base.eth`
-     * - `linea.eth`
-     *
-     * Guaranteed to be a fully lowercase hex string representation of 32-bytes.
-     */
-    node: t.hex().notNull()
-  }),
-  (t) => ({
-    uniqueNode: uniqueIndex3().on(t.node)
-  })
-);
-var registrationLifecycles = onchainTable4(
+var registrationLifecycles = onchainTable3(
   "registration_lifecycles",
   (t) => ({
     /**
@@ -779,11 +370,11 @@ var registrationLifecycles = onchainTable4(
     bySubregistry: index2().on(t.subregistryId)
   })
 );
-var registrarActionType = onchainEnum2("registrar_action_type", [
+var registrarActionType = onchainEnum("registrar_action_type", [
   "registration",
   "renewal"
 ]);
-var registrarActions = onchainTable4(
+var registrarActions = onchainTable3(
   "registrar_actions",
   (t) => ({
     /**
@@ -1036,11 +627,11 @@ var registrarActions = onchainTable4(
     byTimestamp: index2().on(t.timestamp)
   })
 );
-var internal_registrarActionMetadataType = onchainEnum2(
+var internal_registrarActionMetadataType = onchainEnum(
   "_ensindexer_registrar_action_metadata_type",
   ["CURRENT_LOGICAL_REGISTRAR_ACTION"]
 );
-var internal_registrarActionMetadata = onchainTable4(
+var internal_registrarActionMetadata = onchainTable3(
   "_ensindexer_registrar_action_metadata",
   (t) => ({
     /**
@@ -1068,10 +659,10 @@ var internal_registrarActionMetadata = onchainTable4(
     logicalEventId: t.text().notNull()
   })
 );
-var subregistryRelations = relations3(subregistries, ({ many }) => ({
+var subregistryRelations = relations2(subregistries, ({ many }) => ({
   registrationLifecycle: many(registrationLifecycles)
 }));
-var registrationLifecycleRelations = relations3(
+var registrationLifecycleRelations = relations2(
   registrationLifecycles,
   ({ one, many }) => ({
     subregistry: one(subregistries, {
@@ -1081,7 +672,7 @@ var registrationLifecycleRelations = relations3(
     registrarAction: many(registrarActions)
   })
 );
-var registrarActionRelations = relations3(registrarActions, ({ one }) => ({
+var registrarActionRelations = relations2(registrarActions, ({ one }) => ({
   registrationLifecycle: one(registrationLifecycles, {
     fields: [registrarActions.node],
     references: [registrationLifecycles.node]
@@ -1089,7 +680,7 @@ var registrarActionRelations = relations3(registrarActions, ({ one }) => ({
 }));
 
 // src/ensindexer-abstract/subgraph.schema.ts
-import { index as index3, onchainTable as onchainTable5, relations as relations4, sql as sql2 } from "ponder";
+import { index as index3, onchainTable as onchainTable4, relations as relations3, sql } from "ponder";
 
 // src/lib/collate.ts
 function monkeypatchCollate(col, collation) {
@@ -1100,7 +691,7 @@ function monkeypatchCollate(col, collation) {
 }
 
 // src/ensindexer-abstract/subgraph.schema.ts
-var subgraph_domain = onchainTable5(
+var subgraph_domain = onchainTable4(
   "subgraph_domains",
   (t) => ({
     // The namehash of the name
@@ -1174,7 +765,7 @@ var subgraph_domain = onchainTable5(
     // 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`),
+    byFuzzyName: index3().using("gin", sql`${t.name} gin_trgm_ops`),
     byLabelhash: index3().on(t.labelhash),
     byParentId: index3().on(t.parentId),
     byOwnerId: index3().on(t.ownerId),
@@ -1185,7 +776,7 @@ var subgraph_domain = onchainTable5(
 );
 monkeypatchCollate(subgraph_domain.name, '"C"');
 monkeypatchCollate(subgraph_domain.labelName, '"C"');
-var subgraph_domainRelations = relations4(subgraph_domain, ({ one, many }) => ({
+var subgraph_domainRelations = relations3(subgraph_domain, ({ one, many }) => ({
   resolvedAddress: one(subgraph_account, {
     fields: [subgraph_domain.resolvedAddressId],
     references: [subgraph_account.id]
@@ -1230,15 +821,15 @@ var subgraph_domainRelations = relations4(subgraph_domain, ({ one, many }) => ({
   fusesSets: many(subgraph_fusesSet),
   expiryExtendeds: many(subgraph_expiryExtended)
 }));
-var subgraph_account = onchainTable5("subgraph_accounts", (t) => ({
+var subgraph_account = onchainTable4("subgraph_accounts", (t) => ({
   id: t.hex().primaryKey()
 }));
-var subgraph_accountRelations = relations4(subgraph_account, ({ many }) => ({
+var subgraph_accountRelations = relations3(subgraph_account, ({ many }) => ({
   domains: many(subgraph_domain),
   wrappedDomains: many(subgraph_wrappedDomain),
   registrations: many(subgraph_registration)
 }));
-var subgraph_resolver = onchainTable5(
+var subgraph_resolver = onchainTable4(
   "subgraph_resolvers",
   (t) => ({
     // The unique identifier for this resolver, which is a concatenation of the domain namehash and the resolver address
@@ -1262,7 +853,7 @@ var subgraph_resolver = onchainTable5(
     byDomainId: index3().on(t.domainId)
   })
 );
-var subgraph_resolverRelations = relations4(subgraph_resolver, ({ one, many }) => ({
+var subgraph_resolverRelations = relations3(subgraph_resolver, ({ one, many }) => ({
   addr: one(subgraph_account, {
     fields: [subgraph_resolver.addrId],
     references: [subgraph_account.id]
@@ -1283,7 +874,7 @@ var subgraph_resolverRelations = relations4(subgraph_resolver, ({ one, many }) =
   authorisationChangeds: many(subgraph_authorisationChanged),
   versionChangeds: many(subgraph_versionChanged)
 }));
-var subgraph_registration = onchainTable5(
+var subgraph_registration = onchainTable4(
   "subgraph_registrations",
   (t) => ({
     // The unique identifier of the registration
@@ -1325,7 +916,7 @@ var subgraph_registration = onchainTable5(
     byExpiryDate: index3().on(t.expiryDate)
   })
 );
-var subgraph_registrationRelations = relations4(subgraph_registration, ({ one, many }) => ({
+var subgraph_registrationRelations = relations3(subgraph_registration, ({ one, many }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_registration.domainId],
     references: [subgraph_domain.id]
@@ -1339,7 +930,7 @@ var subgraph_registrationRelations = relations4(subgraph_registration, ({ one, m
   nameReneweds: many(subgraph_nameRenewed),
   nameTransferreds: many(subgraph_nameTransferred)
 }));
-var subgraph_wrappedDomain = onchainTable5(
+var subgraph_wrappedDomain = onchainTable4(
   "subgraph_wrapped_domains",
   (t) => ({
     // The unique identifier for each instance of the WrappedDomain entity
@@ -1374,605 +965,1082 @@ var subgraph_wrappedDomain = onchainTable5(
     byDomainId: index3().on(t.domainId)
   })
 );
-var subgraph_wrappedDomainRelations = relations4(subgraph_wrappedDomain, ({ one }) => ({
+var subgraph_wrappedDomainRelations = relations3(subgraph_wrappedDomain, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_wrappedDomain.domainId],
+    references: [subgraph_domain.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_wrappedDomain.ownerId],
+    references: [subgraph_account.id]
+  })
+}));
+var sharedEventColumns = (t) => ({
+  id: t.text().primaryKey(),
+  blockNumber: t.integer().notNull(),
+  transactionID: t.hex().notNull()
+});
+var domainEvent = (t) => ({
+  ...sharedEventColumns(t),
+  domainId: t.hex().notNull()
+});
+var domainEventIndex = (t) => ({
+  // primary reverse lookup
+  idx: index3().on(t.domainId),
+  // sorting index
+  idx_compound: index3().on(t.domainId, t.id)
+});
+var subgraph_transfer = onchainTable4(
+  "subgraph_transfers",
+  (t) => ({
+    ...domainEvent(t),
+    ownerId: t.hex().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_newOwner = onchainTable4(
+  "subgraph_new_owners",
+  (t) => ({
+    ...domainEvent(t),
+    ownerId: t.hex().notNull(),
+    parentDomainId: t.hex().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_newResolver = onchainTable4(
+  "subgraph_new_resolvers",
+  (t) => ({
+    ...domainEvent(t),
+    resolverId: t.text().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_newTTL = onchainTable4(
+  "subgraph_new_ttls",
+  (t) => ({
+    ...domainEvent(t),
+    ttl: t.bigint().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_wrappedTransfer = onchainTable4(
+  "subgraph_wrapped_transfers",
+  (t) => ({
+    ...domainEvent(t),
+    ownerId: t.hex().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_nameWrapped = onchainTable4(
+  "subgraph_name_wrapped",
+  (t) => ({
+    ...domainEvent(t),
+    name: t.text(),
+    fuses: t.integer().notNull(),
+    ownerId: t.hex().notNull(),
+    expiryDate: t.bigint().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_nameUnwrapped = onchainTable4(
+  "subgraph_name_unwrapped",
+  (t) => ({
+    ...domainEvent(t),
+    ownerId: t.hex().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_fusesSet = onchainTable4(
+  "subgraph_fuses_set",
+  (t) => ({
+    ...domainEvent(t),
+    fuses: t.integer().notNull()
+  }),
+  domainEventIndex
+);
+var subgraph_expiryExtended = onchainTable4(
+  "subgraph_expiry_extended",
+  (t) => ({
+    ...domainEvent(t),
+    expiryDate: t.bigint().notNull()
+  }),
+  domainEventIndex
+);
+var registrationEvent = (t) => ({
+  ...sharedEventColumns(t),
+  registrationId: t.hex().notNull()
+});
+var registrationEventIndex = (t) => ({
+  // primary reverse lookup
+  idx: index3().on(t.registrationId),
+  // sorting index
+  idx_compound: index3().on(t.registrationId, t.id)
+});
+var subgraph_nameRegistered = onchainTable4(
+  "subgraph_name_registered",
+  (t) => ({
+    ...registrationEvent(t),
+    registrantId: t.hex().notNull(),
+    expiryDate: t.bigint().notNull()
+  }),
+  registrationEventIndex
+);
+var subgraph_nameRenewed = onchainTable4(
+  "subgraph_name_renewed",
+  (t) => ({
+    ...registrationEvent(t),
+    expiryDate: t.bigint().notNull()
+  }),
+  registrationEventIndex
+);
+var subgraph_nameTransferred = onchainTable4(
+  "subgraph_name_transferred",
+  (t) => ({
+    ...registrationEvent(t),
+    newOwnerId: t.hex().notNull()
+  }),
+  registrationEventIndex
+);
+var resolverEvent = (t) => ({
+  ...sharedEventColumns(t),
+  resolverId: t.text().notNull()
+});
+var resolverEventIndex = (t) => ({
+  // primary reverse lookup
+  idx: index3().on(t.resolverId),
+  // sorting index
+  idx_compound: index3().on(t.resolverId, t.id)
+});
+var subgraph_addrChanged = onchainTable4(
+  "subgraph_addr_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    addrId: t.hex().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_multicoinAddrChanged = onchainTable4(
+  "subgraph_multicoin_addr_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    coinType: t.bigint().notNull(),
+    addr: t.hex().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_nameChanged = onchainTable4(
+  "subgraph_name_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    name: t.text().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_abiChanged = onchainTable4(
+  "subgraph_abi_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    contentType: t.bigint().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_pubkeyChanged = onchainTable4(
+  "subgraph_pubkey_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    x: t.hex().notNull(),
+    y: t.hex().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_textChanged = onchainTable4(
+  "subgraph_text_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    key: t.text().notNull(),
+    value: t.text()
+  }),
+  resolverEventIndex
+);
+var subgraph_contenthashChanged = onchainTable4(
+  "subgraph_contenthash_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    hash: t.hex().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_interfaceChanged = onchainTable4(
+  "subgraph_interface_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    interfaceID: t.hex().notNull(),
+    implementer: t.hex().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_authorisationChanged = onchainTable4(
+  "subgraph_authorisation_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    owner: t.hex().notNull(),
+    target: t.hex().notNull(),
+    isAuthorized: t.boolean().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_versionChanged = onchainTable4(
+  "subgraph_version_changed",
+  (t) => ({
+    ...resolverEvent(t),
+    version: t.bigint().notNull()
+  }),
+  resolverEventIndex
+);
+var subgraph_transferRelations = relations3(subgraph_transfer, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_transfer.domainId],
+    references: [subgraph_domain.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_transfer.ownerId],
+    references: [subgraph_account.id]
+  })
+}));
+var subgraph_newOwnerRelations = relations3(subgraph_newOwner, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newOwner.domainId],
+    references: [subgraph_domain.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_newOwner.ownerId],
+    references: [subgraph_account.id]
+  }),
+  parentDomain: one(subgraph_domain, {
+    fields: [subgraph_newOwner.parentDomainId],
+    references: [subgraph_domain.id]
+  })
+}));
+var subgraph_newResolverRelations = relations3(subgraph_newResolver, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newResolver.domainId],
+    references: [subgraph_domain.id]
+  }),
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_newResolver.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
+var subgraph_newTTLRelations = relations3(subgraph_newTTL, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newTTL.domainId],
+    references: [subgraph_domain.id]
+  })
+}));
+var subgraph_wrappedTransferRelations = relations3(subgraph_wrappedTransfer, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_wrappedTransfer.domainId],
+    references: [subgraph_domain.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_wrappedTransfer.ownerId],
+    references: [subgraph_account.id]
+  })
+}));
+var subgraph_nameWrappedRelations = relations3(subgraph_nameWrapped, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_nameWrapped.domainId],
+    references: [subgraph_domain.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_nameWrapped.ownerId],
+    references: [subgraph_account.id]
+  })
+}));
+var subgraph_nameUnwrappedRelations = relations3(subgraph_nameUnwrapped, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_nameUnwrapped.domainId],
+    references: [subgraph_domain.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_nameUnwrapped.ownerId],
+    references: [subgraph_account.id]
+  })
+}));
+var subgraph_fusesSetRelations = relations3(subgraph_fusesSet, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_fusesSet.domainId],
+    references: [subgraph_domain.id]
+  })
+}));
+var subgraph_expiryExtendedRelations = relations3(subgraph_expiryExtended, ({ one }) => ({
   domain: one(subgraph_domain, {
-    fields: [subgraph_wrappedDomain.domainId],
+    fields: [subgraph_expiryExtended.domainId],
     references: [subgraph_domain.id]
+  })
+}));
+var subgraph_nameRegisteredRelations = relations3(subgraph_nameRegistered, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameRegistered.registrationId],
+    references: [subgraph_registration.id]
   }),
-  owner: one(subgraph_account, {
-    fields: [subgraph_wrappedDomain.ownerId],
+  registrant: one(subgraph_account, {
+    fields: [subgraph_nameRegistered.registrantId],
     references: [subgraph_account.id]
   })
 }));
-var sharedEventColumns = (t) => ({
-  id: t.text().primaryKey(),
-  blockNumber: t.integer().notNull(),
-  transactionID: t.hex().notNull()
-});
-var domainEvent2 = (t) => ({
-  ...sharedEventColumns(t),
-  domainId: t.hex().notNull()
-});
-var domainEventIndex = (t) => ({
-  // primary reverse lookup
-  idx: index3().on(t.domainId),
-  // sorting index
-  idx_compound: index3().on(t.domainId, t.id)
-});
-var subgraph_transfer = onchainTable5(
-  "subgraph_transfers",
-  (t) => ({
-    ...domainEvent2(t),
-    ownerId: t.hex().notNull()
-  }),
-  domainEventIndex
-);
-var subgraph_newOwner = onchainTable5(
-  "subgraph_new_owners",
-  (t) => ({
-    ...domainEvent2(t),
-    ownerId: t.hex().notNull(),
-    parentDomainId: t.hex().notNull()
-  }),
-  domainEventIndex
-);
-var subgraph_newResolver = onchainTable5(
-  "subgraph_new_resolvers",
-  (t) => ({
-    ...domainEvent2(t),
-    resolverId: t.text().notNull()
-  }),
-  domainEventIndex
-);
-var subgraph_newTTL = onchainTable5(
-  "subgraph_new_ttls",
-  (t) => ({
-    ...domainEvent2(t),
-    ttl: t.bigint().notNull()
-  }),
-  domainEventIndex
-);
-var subgraph_wrappedTransfer = onchainTable5(
-  "subgraph_wrapped_transfers",
-  (t) => ({
-    ...domainEvent2(t),
-    ownerId: t.hex().notNull()
-  }),
-  domainEventIndex
-);
-var subgraph_nameWrapped = onchainTable5(
-  "subgraph_name_wrapped",
-  (t) => ({
-    ...domainEvent2(t),
-    name: t.text(),
-    fuses: t.integer().notNull(),
-    ownerId: t.hex().notNull(),
-    expiryDate: t.bigint().notNull()
+var subgraph_nameRenewedRelations = relations3(subgraph_nameRenewed, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameRenewed.registrationId],
+    references: [subgraph_registration.id]
+  })
+}));
+var subgraph_nameTransferredRelations = relations3(subgraph_nameTransferred, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameTransferred.registrationId],
+    references: [subgraph_registration.id]
   }),
-  domainEventIndex
-);
-var subgraph_nameUnwrapped = onchainTable5(
-  "subgraph_name_unwrapped",
-  (t) => ({
-    ...domainEvent2(t),
-    ownerId: t.hex().notNull()
+  newOwner: one(subgraph_account, {
+    fields: [subgraph_nameTransferred.newOwnerId],
+    references: [subgraph_account.id]
+  })
+}));
+var subgraph_addrChangedRelations = relations3(subgraph_addrChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_addrChanged.resolverId],
+    references: [subgraph_resolver.id]
   }),
-  domainEventIndex
+  addr: one(subgraph_account, {
+    fields: [subgraph_addrChanged.addrId],
+    references: [subgraph_account.id]
+  })
+}));
+var subgraph_multicoinAddrChangedRelations = relations3(
+  subgraph_multicoinAddrChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_multicoinAddrChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
+  })
 );
-var subgraph_fusesSet = onchainTable5(
-  "subgraph_fuses_set",
-  (t) => ({
-    ...domainEvent2(t),
-    fuses: t.integer().notNull()
-  }),
-  domainEventIndex
+var subgraph_nameChangedRelations = relations3(subgraph_nameChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_nameChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
+var subgraph_abiChangedRelations = relations3(subgraph_abiChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_abiChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
+var subgraph_pubkeyChangedRelations = relations3(subgraph_pubkeyChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_pubkeyChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
+var subgraph_textChangedRelations = relations3(subgraph_textChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_textChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
+var subgraph_contenthashChangedRelations = relations3(
+  subgraph_contenthashChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_contenthashChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
+  })
 );
-var subgraph_expiryExtended = onchainTable5(
-  "subgraph_expiry_extended",
-  (t) => ({
-    ...domainEvent2(t),
-    expiryDate: t.bigint().notNull()
-  }),
-  domainEventIndex
+var subgraph_interfaceChangedRelations = relations3(
+  subgraph_interfaceChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_interfaceChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
+  })
 );
-var registrationEvent = (t) => ({
-  ...sharedEventColumns(t),
-  registrationId: t.hex().notNull()
-});
-var registrationEventIndex = (t) => ({
-  // primary reverse lookup
-  idx: index3().on(t.registrationId),
-  // sorting index
-  idx_compound: index3().on(t.registrationId, t.id)
-});
-var subgraph_nameRegistered = onchainTable5(
-  "subgraph_name_registered",
-  (t) => ({
-    ...registrationEvent(t),
-    registrantId: t.hex().notNull(),
-    expiryDate: t.bigint().notNull()
-  }),
-  registrationEventIndex
+var subgraph_authorisationChangedRelations = relations3(
+  subgraph_authorisationChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_authorisationChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
+  })
 );
-var subgraph_nameRenewed = onchainTable5(
-  "subgraph_name_renewed",
+var subgraph_versionChangedRelations = relations3(subgraph_versionChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_versionChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
+
+// src/ensindexer-abstract/tokenscope.schema.ts
+import { index as index4, onchainTable as onchainTable5 } from "ponder";
+var nameSales = onchainTable5(
+  "name_sales",
   (t) => ({
-    ...registrationEvent(t),
-    expiryDate: t.bigint().notNull()
+    /**
+     * Unique and deterministic identifier of the onchain event associated with the sale.
+     *
+     * Composite key format: "{chainId}-{blockNumber}-{logIndex}" (e.g., "1-1234567-5")
+     */
+    id: t.text().primaryKey(),
+    /**
+     * The chain where the sale occurred.
+     */
+    chainId: t.int8({ mode: "number" }).notNull(),
+    /**
+     * The block number on chainId where the sale occurred.
+     */
+    blockNumber: t.bigint().notNull(),
+    /**
+     * The log index position of the sale event within blockNumber.
+     */
+    logIndex: t.integer().notNull(),
+    /**
+     * The EVM transaction hash on chainId associated with the sale.
+     */
+    transactionHash: t.hex().notNull(),
+    /**
+     * The Seaport order hash.
+     */
+    orderHash: t.hex().notNull(),
+    /**
+     * The address of the contract on chainId that manages tokenId.
+     */
+    contractAddress: t.hex().notNull(),
+    /**
+     * The tokenId managed by contractAddress that was sold.
+     *
+     * In a general context (outside of TokenScope) ERC1155 NFTs may have
+     * multiple copies, however TokenScope guarantees that all indexed NFTs
+     * never have an amount / balance > 1.
+     */
+    tokenId: t.bigint().notNull(),
+    /**
+     * The CAIP-19 Asset Namespace of the token that was sold. Either `erc721` or `erc1155`.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-19
+     */
+    assetNamespace: t.text().notNull(),
+    /**
+     * The CAIP-19 Asset ID of token that was sold. This is a globally unique reference to the
+     * specific asset in question.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-19
+     */
+    assetId: t.text().notNull(),
+    /**
+     * The namehash (Node) of the ENS domain that was sold.
+     */
+    domainId: t.hex().notNull(),
+    /**
+     * The account that bought the token controlling ownership of domainId from
+     * the seller for the amount of currency associated with the sale.
+     */
+    buyer: t.hex().notNull(),
+    /**
+     * The account that sold the token controlling ownership of domainId to
+     * buyer for the amount of currency associated with the sale.
+     */
+    seller: t.hex().notNull(),
+    /**
+     * Currency of the payment (ETH, USDC or DAI) from buyer to seller in exchange for tokenId.
+     */
+    currency: t.text().notNull(),
+    /**
+     * The amount of currency paid from buyer to seller in exchange for tokenId.
+     *
+     * Denominated in the smallest unit of currency.
+     *
+     * Amount interpretation depends on currency:
+     * - ETH/WETH: Amount in wei (1 ETH = 10^18 wei)
+     * - USDC: Amount in micro-units (1 USDC = 10^6 units)
+     * - DAI: Amount in wei-equivalent (1 DAI = 10^18 units)
+     */
+    amount: t.bigint().notNull(),
+    /**
+     * Unix timestamp of the block timestamp when the sale occurred.
+     */
+    timestamp: t.bigint().notNull()
   }),
-  registrationEventIndex
-);
-var subgraph_nameTransferred = onchainTable5(
-  "subgraph_name_transferred",
   (t) => ({
-    ...registrationEvent(t),
-    newOwnerId: t.hex().notNull()
-  }),
-  registrationEventIndex
+    idx_domainId: index4().on(t.domainId),
+    idx_assetId: index4().on(t.assetId),
+    idx_buyer: index4().on(t.buyer),
+    idx_seller: index4().on(t.seller),
+    idx_timestamp: index4().on(t.timestamp)
+  })
 );
-var resolverEvent2 = (t) => ({
-  ...sharedEventColumns(t),
-  resolverId: t.text().notNull()
-});
-var resolverEventIndex = (t) => ({
-  // primary reverse lookup
-  idx: index3().on(t.resolverId),
-  // sorting index
-  idx_compound: index3().on(t.resolverId, t.id)
-});
-var subgraph_addrChanged = onchainTable5(
-  "subgraph_addr_changed",
+var nameTokens = onchainTable5(
+  "name_tokens",
   (t) => ({
-    ...resolverEvent2(t),
-    addrId: t.hex().notNull()
+    /**
+     * The CAIP-19 Asset ID of the token.
+     *
+     * This is a globally unique reference to the token.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-19
+     */
+    id: t.text().primaryKey(),
+    /**
+     * The namehash (Node) of the ENS name associated with the token.
+     *
+     * Note: An ENS name may have more than one distinct token across time. It is
+     * also possible for multiple distinct tokens for an ENS name to have
+     * a mintStatus of `minted` at the same time. For example:
+     * - When a direct subname of .eth is wrapped by the NameWrapper. This state
+     *   has one minted token for the name managed by the BaseRegistrar (this
+     *   token will be owned by the NameWrapper) and another minted token for
+     *   the name managed by the NameWrapper (owned by the effective owner of
+     *   the name).
+     * - When a direct subname of .eth is wrapped by the NameWrapper and then
+     *   unwrapped. This state has one minted token (managed by the BaseRegistrar)
+     *   and another burned token (managed by the NameWrapper).
+     */
+    domainId: t.hex().notNull(),
+    /**
+     * The chain that manages the token.
+     */
+    chainId: t.int8({ mode: "number" }).notNull(),
+    /**
+     * The address of the contract on chainId that manages the token.
+     */
+    contractAddress: t.hex().notNull(),
+    /**
+     * The tokenId of the token managed by contractAddress.
+     *
+     * In a general context (outside of TokenScope) ERC1155 NFTs may have
+     * multiple copies, however TokenScope guarantees that all indexed NFTs
+     * never have an amount / balance > 1.
+     */
+    tokenId: t.bigint().notNull(),
+    /**
+     * The CAIP-19 Asset Namespace of the token. Either `erc721` or `erc1155`.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-19
+     */
+    assetNamespace: t.text().notNull(),
+    /**
+     * The account that owns the token.
+     *
+     * Value is zeroAddress if and only if mintStatus is `burned`.
+     *
+     * Note: The owner of the token for a given domainId may differ from the
+     * owner of the associated node in the registry. For example:
+     * - Consider the case where address X owns the ENS name `foo.eth` in
+     *   both the BaseRegistrar and the Registry. If X sends a request directly
+     *   to the Registry to transfer ownership to Y, ownership of `foo.eth` will
+     *   be transferred to Y in the Registry but not in the BaseRegistrar.
+     * - ... for the case above, the BaseRegistrar implements a `reclaim`
+     *   allowing the owner of the name in the BaseRegistrar to reclaim ownership
+     *   of the name in the Registry.
+     *
+     * Note: When a name is wrapped by the NameWrapper, the owner of the token
+     * in the BaseRegistrar is the NameWrapper, while a new token for the name is
+     * minted by the NameWrapper and owned by the effective owner of the name.
+     */
+    owner: t.hex().notNull(),
+    /**
+     * The mint status of the token. Either `minted` or `burned`.
+     *
+     * After we index a NFT we never delete it from our index. Instead, when an
+     * indexed NFT is burned onchain we retain its record and update its mint
+     * status as `burned`. If a NFT is minted again after it is burned its mint
+     * status is updated to `minted`.
+     */
+    mintStatus: t.text().notNull()
   }),
-  resolverEventIndex
+  (t) => ({
+    idx_domainId: index4().on(t.domainId),
+    idx_owner: index4().on(t.owner)
+  })
 );
-var subgraph_multicoinAddrChanged = onchainTable5(
-  "subgraph_multicoin_addr_changed",
+
+// src/ensindexer-abstract/unigraph.schema.ts
+import { index as index5, onchainEnum as onchainEnum2, onchainTable as onchainTable6, primaryKey as primaryKey3, relations as relations4, sql as sql2, uniqueIndex as uniqueIndex3 } from "ponder";
+var event = onchainTable6(
+  "events",
   (t) => ({
-    ...resolverEvent2(t),
-    coinType: t.bigint().notNull(),
-    addr: t.hex().notNull()
+    // Ponder's event.id
+    id: t.text().primaryKey(),
+    // The HCA account address if used, otherwise Transaction.from.
+    sender: t.hex().notNull().$type(),
+    // Event Log Metadata
+    // chain
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    // block
+    blockNumber: t.bigint().notNull().$type(),
+    blockHash: t.hex().notNull().$type(),
+    timestamp: t.bigint().notNull(),
+    // transaction
+    transactionHash: t.hex().notNull().$type(),
+    transactionIndex: t.integer().notNull(),
+    // `tx.from` — never HCA-aware. Always the EOA/relayer that submitted the transaction.
+    // Use `event.sender` for the HCA-aware actor.
+    from: t.hex().notNull().$type(),
+    to: t.hex().$type(),
+    // NOTE: a null `to` means this was a tx that deployed a contract
+    // log
+    address: t.hex().notNull().$type(),
+    logIndex: t.integer().notNull().$type(),
+    selector: t.hex().notNull().$type(),
+    topics: t.hex().array().notNull().$type(),
+    data: t.hex().notNull()
   }),
-  resolverEventIndex
+  (t) => ({
+    bySelector: index5().on(t.selector),
+    byFrom: index5().on(t.from),
+    bySender: index5().on(t.sender),
+    byTimestamp: index5().on(t.timestamp)
+  })
 );
-var subgraph_nameChanged = onchainTable5(
-  "subgraph_name_changed",
+var domainEvent2 = onchainTable6(
+  "domain_events",
   (t) => ({
-    ...resolverEvent2(t),
-    name: t.text().notNull()
+    domainId: t.text().notNull().$type(),
+    eventId: t.text().notNull()
   }),
-  resolverEventIndex
+  (t) => ({ pk: primaryKey3({ columns: [t.domainId, t.eventId] }) })
 );
-var subgraph_abiChanged = onchainTable5(
-  "subgraph_abi_changed",
+var resolverEvent2 = onchainTable6(
+  "resolver_events",
   (t) => ({
-    ...resolverEvent2(t),
-    contentType: t.bigint().notNull()
+    resolverId: t.text().notNull().$type(),
+    eventId: t.text().notNull()
   }),
-  resolverEventIndex
+  (t) => ({ pk: primaryKey3({ columns: [t.resolverId, t.eventId] }) })
 );
-var subgraph_pubkeyChanged = onchainTable5(
-  "subgraph_pubkey_changed",
+var permissionsEvent = onchainTable6(
+  "permissions_events",
   (t) => ({
-    ...resolverEvent2(t),
-    x: t.hex().notNull(),
-    y: t.hex().notNull()
+    permissionsId: t.text().notNull().$type(),
+    eventId: t.text().notNull()
   }),
-  resolverEventIndex
+  (t) => ({ pk: primaryKey3({ columns: [t.permissionsId, t.eventId] }) })
 );
-var subgraph_textChanged = onchainTable5(
-  "subgraph_text_changed",
+var permissionsUserEvent = onchainTable6(
+  "permissions_user_events",
   (t) => ({
-    ...resolverEvent2(t),
-    key: t.text().notNull(),
-    value: t.text()
+    permissionsUserId: t.text().notNull().$type(),
+    eventId: t.text().notNull()
   }),
-  resolverEventIndex
+  (t) => ({ pk: primaryKey3({ columns: [t.permissionsUserId, t.eventId] }) })
 );
-var subgraph_contenthashChanged = onchainTable5(
-  "subgraph_contenthash_changed",
+var account = onchainTable6("accounts", (t) => ({
+  id: t.hex().primaryKey().$type()
+}));
+var account_relations = relations4(account, ({ many }) => ({
+  registrations: many(registration, { relationName: "registrant" }),
+  domains: many(domain),
+  permissions: many(permissionsUser)
+}));
+var registryType = onchainEnum2("RegistryType", [
+  "ENSv1Registry",
+  "ENSv1VirtualRegistry",
+  "ENSv2Registry"
+]);
+var registry = onchainTable6(
+  "registries",
   (t) => ({
-    ...resolverEvent2(t),
-    hash: t.hex().notNull()
+    // see RegistryId for guarantees
+    id: t.text().primaryKey().$type(),
+    // has a type
+    type: registryType().notNull(),
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type(),
+    // If this is an ENSv1VirtualRegistry, `node` is the namehash of the parent ENSv1 domain that
+    // owns it, otherwise null.
+    node: t.hex().$type(),
+    // the Registry's declared Canonical Domain (uni-directional)
+    canonicalDomainId: t.text().$type(),
+    // Whether this Registry is part of the canonical nametree. See canonicality-db-helpers.ts.
+    canonical: t.boolean().notNull().default(false),
+    // Synthetic monotonic sentinel: flipped to true the first time a child Domain is registered
+    // under this Registry (see `ensureDomainInRegistry`). Read by `cascadeCanonicality` to skip
+    // the raw-SQL recursive-CTE walk (and its associated Ponder cache flush) when the start
+    // registry provably has no descendants — the dominant case for fresh ENSv1 virtual
+    // registries on first wire-up. Double-underscore prefix marks it as an internal-only
+    // bookkeeping field, not part of the on-chain protocol surface.
+    __hasChildren: t.boolean().notNull().default(false)
   }),
-  resolverEventIndex
+  (t) => ({
+    // NOTE: non-unique index because multiple rows can share (chainId, address) across virtual registries
+    byChainAddress: index5().on(t.chainId, t.address)
+  })
 );
-var subgraph_interfaceChanged = onchainTable5(
-  "subgraph_interface_changed",
+var relations_registry = relations4(registry, ({ one, many }) => ({
+  // domains that declare this registry as their parent registry
+  domains: many(domain, { relationName: "registry" }),
+  // domains that declare this registry as their subregistry
+  domainsAsSubregistry: many(domain, { relationName: "subregistry" }),
+  permissions: one(permissions, {
+    relationName: "permissions",
+    fields: [registry.chainId, registry.address],
+    references: [permissions.chainId, permissions.address]
+  })
+}));
+var domainType = onchainEnum2("DomainType", ["ENSv1Domain", "ENSv2Domain"]);
+var domain = onchainTable6(
+  "domains",
   (t) => ({
-    ...resolverEvent2(t),
-    interfaceID: t.hex().notNull(),
-    implementer: t.hex().notNull()
+    // see DomainId for guarantees (ENSv1DomainId: `${ENSv1RegistryId}/${node}`, ENSv2DomainId: CAIP-19)
+    id: t.text().primaryKey().$type(),
+    // has a type
+    type: domainType().notNull(),
+    // belongs to a registry
+    registryId: t.text().notNull().$type(),
+    // the Domain's declared Subregistry (uni-directional)
+    subregistryId: t.text().$type(),
+    // If this is an ENSv2Domain, the TokenId within the ENSv2Registry, otherwise null.
+    tokenId: t.bigint().$type(),
+    // If this is an ENSv1Domain, The Domain's namehash, otherwise null.
+    node: t.hex().$type(),
+    // represents a labelHash
+    labelHash: t.hex().notNull().$type(),
+    // If this is an ENSv1Domain, this is the effective owner of the Domain.
+    // If this is an ENSv2Domain, this is the on-chain owner address (the HCA account address if used).
+    ownerId: t.hex().$type(),
+    // If this is an ENSv1Domain, may have a `rootRegistryOwner`, otherwise null.
+    rootRegistryOwnerId: t.hex().$type(),
+    // Whether this Domain is part of the canonical nametree. Mirrors the parent Registry's flag.
+    canonical: t.boolean().notNull().default(false),
+    /**
+     * Materialized Canonical Name, NULL iff `canonical = false`.
+     * Maintained by `canonicality-db-helpers.ts`.
+     *
+     * @example "vitalik.eth"
+     */
+    canonicalName: t.text().$type(),
+    /**
+     * Materialized Canonical LabelHashPath, NULL iff `canonical = false`.
+     * Maintained by `canonicality-db-helpers.ts`.
+     *
+     * @dev Note that LabelHashPaths are in traversal-order (i.e. [labelhash("eth"), labelhash("vitalik")]).
+     */
+    canonicalLabelHashPath: t.hex().array().$type(),
+    /**
+     * Materialized Canonical Domain Path, NULL iff `canonical = false`.
+     * Maintained by `canonicality-db-helpers.ts`.
+     *
+     * @dev Note that canonicalPath is in traversal-order (i.e. ["eth"'s DomainId, "vitalik"'s DomainId]).
+     */
+    canonicalPath: t.text().array().$type(),
+    /**
+     * Materialized Canonical Depth, NULL iff `canonical = false`.
+     * Maintained by `canonicality-db-helpers.ts`.
+     *
+     * @dev The depth of this Domain in the Canonical Nametree i.e. the number of Labels in its Canonical Name.
+     * @example "eth" depth 1, "vitalik.eth" depth 2, etc
+     */
+    canonicalDepth: t.integer(),
+    /**
+     * Materialized Canonical Node, NULL iff `canonical = false`.
+     * Maintained by `canonicality-db-helpers.ts`.
+     *
+     * @dev the computed Node (via `namehash`) of this Domain's Canonical Name.
+     */
+    canonicalNode: t.hex().$type()
+    // NOTE: Domain-Resolver Relations tracked via Protocol Acceleration plugin
   }),
-  resolverEventIndex
-);
-var subgraph_authorisationChanged = onchainTable5(
-  "subgraph_authorisation_changed",
   (t) => ({
-    ...resolverEvent2(t),
-    owner: t.hex().notNull(),
-    target: t.hex().notNull(),
-    isAuthorized: t.boolean().notNull()
-  }),
-  resolverEventIndex
+    byType: index5().on(t.type),
+    bySubregistry: index5().on(t.subregistryId).where(sql2`${t.subregistryId} IS NOT NULL`),
+    byOwner: index5().on(t.ownerId),
+    byLabelHash: index5().on(t.labelHash),
+    // Composite for `(registry_id, label_hash)` lookups (namegraph walk in
+    // 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
+    ),
+    // 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 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)
+  })
 );
-var subgraph_versionChanged = onchainTable5(
-  "subgraph_version_changed",
-  (t) => ({
-    ...resolverEvent2(t),
-    version: t.bigint().notNull()
+var relations_domain = relations4(domain, ({ one, many }) => ({
+  registry: one(registry, {
+    relationName: "registry",
+    fields: [domain.registryId],
+    references: [registry.id]
   }),
-  resolverEventIndex
-);
-var subgraph_transferRelations = relations4(subgraph_transfer, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_transfer.domainId],
-    references: [subgraph_domain.id]
+  subregistry: one(registry, {
+    relationName: "subregistry",
+    fields: [domain.subregistryId],
+    references: [registry.id]
   }),
-  owner: one(subgraph_account, {
-    fields: [subgraph_transfer.ownerId],
-    references: [subgraph_account.id]
-  })
-}));
-var subgraph_newOwnerRelations = relations4(subgraph_newOwner, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_newOwner.domainId],
-    references: [subgraph_domain.id]
+  owner: one(account, {
+    relationName: "owner",
+    fields: [domain.ownerId],
+    references: [account.id]
   }),
-  owner: one(subgraph_account, {
-    fields: [subgraph_newOwner.ownerId],
-    references: [subgraph_account.id]
+  rootRegistryOwner: one(account, {
+    relationName: "rootRegistryOwner",
+    fields: [domain.rootRegistryOwnerId],
+    references: [account.id]
   }),
-  parentDomain: one(subgraph_domain, {
-    fields: [subgraph_newOwner.parentDomainId],
-    references: [subgraph_domain.id]
-  })
-}));
-var subgraph_newResolverRelations = relations4(subgraph_newResolver, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_newResolver.domainId],
-    references: [subgraph_domain.id]
+  label: one(label, {
+    relationName: "label",
+    fields: [domain.labelHash],
+    references: [label.labelHash]
   }),
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_newResolver.resolverId],
-    references: [subgraph_resolver.id]
-  })
-}));
-var subgraph_newTTLRelations = relations4(subgraph_newTTL, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_newTTL.domainId],
-    references: [subgraph_domain.id]
-  })
+  registrations: many(registration)
 }));
-var subgraph_wrappedTransferRelations = relations4(subgraph_wrappedTransfer, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_wrappedTransfer.domainId],
-    references: [subgraph_domain.id]
+var registrationType = onchainEnum2("RegistrationType", [
+  // TODO: prefix these with ENSv1, maybe excluding ThreeDNS
+  "NameWrapper",
+  "BaseRegistrar",
+  "ThreeDNS",
+  "ENSv2RegistryRegistration",
+  "ENSv2RegistryReservation"
+]);
+var registration = onchainTable6(
+  "registrations",
+  (t) => ({
+    // keyed by (domainId, registrationIndex)
+    id: t.text().primaryKey().$type(),
+    domainId: t.text().notNull().$type(),
+    registrationIndex: t.integer().notNull(),
+    // has a type
+    type: registrationType().notNull(),
+    // has a start
+    start: t.bigint().notNull(),
+    // may have an expiry
+    expiry: t.bigint(),
+    // maybe have a grace period (BaseRegistrar)
+    gracePeriod: t.bigint(),
+    // registrar AccountId
+    registrarChainId: t.int8({ mode: "number" }).notNull().$type(),
+    registrarAddress: t.hex().notNull().$type(),
+    // may reference a registrant. If this is an ENSv2 Registration, the protocol-emitted
+    // registrant address (the HCA account address if used).
+    registrantId: t.hex().$type(),
+    // may reference an unregistrant. If this is an ENSv2 Registration, the protocol-emitted
+    // unregistrant address (the HCA account address if used).
+    unregistrantId: t.hex().$type(),
+    // may have referrer data
+    referrer: t.hex().$type(),
+    // may have fuses (NameWrapper, Wrapped BaseRegistrar)
+    fuses: t.integer(),
+    // TODO(paymentToken): add payment token tracking here
+    // may have base cost (BaseRegistrar, ENSv2Registrar)
+    base: t.bigint(),
+    // may have a premium (BaseRegistrar)
+    premium: t.bigint(),
+    // may be Wrapped (BaseRegistrar)
+    wrapped: t.boolean().default(false),
+    // has an event
+    eventId: t.text().notNull()
   }),
-  owner: one(subgraph_account, {
-    fields: [subgraph_wrappedTransfer.ownerId],
-    references: [subgraph_account.id]
+  (t) => ({
+    byId: uniqueIndex3().on(t.domainId, t.registrationIndex)
   })
-}));
-var subgraph_nameWrappedRelations = relations4(subgraph_nameWrapped, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_nameWrapped.domainId],
-    references: [subgraph_domain.id]
+);
+var registration_relations = relations4(registration, ({ one, many }) => ({
+  // belongs to a domain
+  domain: one(domain, {
+    fields: [registration.domainId],
+    references: [domain.id]
   }),
-  owner: one(subgraph_account, {
-    fields: [subgraph_nameWrapped.ownerId],
-    references: [subgraph_account.id]
-  })
-}));
-var subgraph_nameUnwrappedRelations = relations4(subgraph_nameUnwrapped, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_nameUnwrapped.domainId],
-    references: [subgraph_domain.id]
+  // has one registrant
+  registrant: one(account, {
+    fields: [registration.registrantId],
+    references: [account.id],
+    relationName: "registrant"
   }),
-  owner: one(subgraph_account, {
-    fields: [subgraph_nameUnwrapped.ownerId],
-    references: [subgraph_account.id]
-  })
-}));
-var subgraph_fusesSetRelations = relations4(subgraph_fusesSet, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_fusesSet.domainId],
-    references: [subgraph_domain.id]
-  })
-}));
-var subgraph_expiryExtendedRelations = relations4(subgraph_expiryExtended, ({ one }) => ({
-  domain: one(subgraph_domain, {
-    fields: [subgraph_expiryExtended.domainId],
-    references: [subgraph_domain.id]
-  })
-}));
-var subgraph_nameRegisteredRelations = relations4(subgraph_nameRegistered, ({ one }) => ({
-  registration: one(subgraph_registration, {
-    fields: [subgraph_nameRegistered.registrationId],
-    references: [subgraph_registration.id]
+  // has a latest registration index
+  latestRegistrationIndex: one(latestRegistrationIndex),
+  // has a latest renewal index
+  latestRenewalIndex: one(latestRenewalIndex),
+  // has one unregistrant
+  unregistrant: one(account, {
+    fields: [registration.unregistrantId],
+    references: [account.id],
+    relationName: "unregistrant"
   }),
-  registrant: one(subgraph_account, {
-    fields: [subgraph_nameRegistered.registrantId],
-    references: [subgraph_account.id]
+  // has many renewals
+  renewals: many(renewal),
+  // has an event
+  event: one(event, {
+    fields: [registration.eventId],
+    references: [event.id]
   })
 }));
-var subgraph_nameRenewedRelations = relations4(subgraph_nameRenewed, ({ one }) => ({
-  registration: one(subgraph_registration, {
-    fields: [subgraph_nameRenewed.registrationId],
-    references: [subgraph_registration.id]
-  })
+var latestRegistrationIndex = onchainTable6("latest_registration_indexes", (t) => ({
+  domainId: t.text().primaryKey().$type(),
+  registrationIndex: t.integer().notNull()
 }));
-var subgraph_nameTransferredRelations = relations4(subgraph_nameTransferred, ({ one }) => ({
-  registration: one(subgraph_registration, {
-    fields: [subgraph_nameTransferred.registrationId],
-    references: [subgraph_registration.id]
-  }),
-  newOwner: one(subgraph_account, {
-    fields: [subgraph_nameTransferred.newOwnerId],
-    references: [subgraph_account.id]
+var latestRegistrationIndex_relations = relations4(latestRegistrationIndex, ({ one }) => ({
+  // references domain
+  domain: one(domain, {
+    fields: [latestRegistrationIndex.domainId],
+    references: [domain.id]
   })
 }));
-var subgraph_addrChangedRelations = relations4(subgraph_addrChanged, ({ one }) => ({
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_addrChanged.resolverId],
-    references: [subgraph_resolver.id]
+var renewal = onchainTable6(
+  "renewals",
+  (t) => ({
+    // keyed by (registrationId, index)
+    id: t.text().primaryKey().$type(),
+    domainId: t.text().notNull().$type(),
+    registrationIndex: t.integer().notNull(),
+    renewalIndex: t.integer().notNull(),
+    // all renewals have a duration
+    duration: t.bigint().notNull(),
+    // may have a referrer
+    referrer: t.hex().$type(),
+    // TODO(paymentToken): add payment token tracking here
+    // may have base cost
+    base: t.bigint(),
+    // may have a premium (ENSv1 RegistrarControllers)
+    premium: t.bigint(),
+    // has an event
+    eventId: t.text().notNull()
   }),
-  addr: one(subgraph_account, {
-    fields: [subgraph_addrChanged.addrId],
-    references: [subgraph_account.id]
-  })
-}));
-var subgraph_multicoinAddrChangedRelations = relations4(
-  subgraph_multicoinAddrChanged,
-  ({ one }) => ({
-    resolver: one(subgraph_resolver, {
-      fields: [subgraph_multicoinAddrChanged.resolverId],
-      references: [subgraph_resolver.id]
-    })
+  (t) => ({
+    byId: uniqueIndex3().on(t.domainId, t.registrationIndex, t.renewalIndex)
   })
 );
-var subgraph_nameChangedRelations = relations4(subgraph_nameChanged, ({ one }) => ({
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_nameChanged.resolverId],
-    references: [subgraph_resolver.id]
-  })
-}));
-var subgraph_abiChangedRelations = relations4(subgraph_abiChanged, ({ one }) => ({
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_abiChanged.resolverId],
-    references: [subgraph_resolver.id]
-  })
-}));
-var subgraph_pubkeyChangedRelations = relations4(subgraph_pubkeyChanged, ({ one }) => ({
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_pubkeyChanged.resolverId],
-    references: [subgraph_resolver.id]
-  })
-}));
-var subgraph_textChangedRelations = relations4(subgraph_textChanged, ({ one }) => ({
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_textChanged.resolverId],
-    references: [subgraph_resolver.id]
-  })
-}));
-var subgraph_contenthashChangedRelations = relations4(
-  subgraph_contenthashChanged,
-  ({ one }) => ({
-    resolver: one(subgraph_resolver, {
-      fields: [subgraph_contenthashChanged.resolverId],
-      references: [subgraph_resolver.id]
-    })
+var renewal_relations = relations4(renewal, ({ one }) => ({
+  // belongs to registration
+  registration: one(registration, {
+    fields: [renewal.domainId, renewal.registrationIndex],
+    references: [registration.domainId, registration.registrationIndex]
+  }),
+  // has an event
+  event: one(event, {
+    fields: [renewal.eventId],
+    references: [event.id]
   })
+}));
+var latestRenewalIndex = onchainTable6(
+  "latest_renewal_indexes",
+  (t) => ({
+    domainId: t.text().notNull().$type(),
+    registrationIndex: t.integer().notNull(),
+    renewalIndex: t.integer().notNull()
+  }),
+  (t) => ({ pk: primaryKey3({ columns: [t.domainId, t.registrationIndex] }) })
 );
-var subgraph_interfaceChangedRelations = relations4(
-  subgraph_interfaceChanged,
-  ({ one }) => ({
-    resolver: one(subgraph_resolver, {
-      fields: [subgraph_interfaceChanged.resolverId],
-      references: [subgraph_resolver.id]
-    })
+var latestRenewalIndex_relations = relations4(latestRenewalIndex, ({ one }) => ({
+  // references domain
+  domain: one(domain, {
+    fields: [latestRenewalIndex.domainId],
+    references: [domain.id]
+  })
+}));
+var permissions = onchainTable6(
+  "permissions",
+  (t) => ({
+    id: t.text().primaryKey().$type(),
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type()
+  }),
+  (t) => ({
+    byId: uniqueIndex3().on(t.chainId, t.address)
   })
 );
-var subgraph_authorisationChangedRelations = relations4(
-  subgraph_authorisationChanged,
-  ({ one }) => ({
-    resolver: one(subgraph_resolver, {
-      fields: [subgraph_authorisationChanged.resolverId],
-      references: [subgraph_resolver.id]
-    })
+var relations_permissions = relations4(permissions, ({ many }) => ({
+  resources: many(permissionsResource),
+  users: many(permissionsUser)
+}));
+var permissionsResource = onchainTable6(
+  "permissions_resources",
+  (t) => ({
+    id: t.text().primaryKey().$type(),
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type(),
+    resource: t.bigint().notNull()
+  }),
+  (t) => ({
+    byId: uniqueIndex3().on(t.chainId, t.address, t.resource)
   })
 );
-var subgraph_versionChangedRelations = relations4(subgraph_versionChanged, ({ one }) => ({
-  resolver: one(subgraph_resolver, {
-    fields: [subgraph_versionChanged.resolverId],
-    references: [subgraph_resolver.id]
+var relations_permissionsResource = relations4(permissionsResource, ({ one }) => ({
+  permissions: one(permissions, {
+    fields: [permissionsResource.chainId, permissionsResource.address],
+    references: [permissions.chainId, permissions.address]
   })
 }));
-
-// src/ensindexer-abstract/tokenscope.schema.ts
-import { index as index4, onchainTable as onchainTable6 } from "ponder";
-var nameSales = onchainTable6(
-  "name_sales",
+var permissionsUser = onchainTable6(
+  "permissions_users",
   (t) => ({
-    /**
-     * Unique and deterministic identifier of the onchain event associated with the sale.
-     *
-     * Composite key format: "{chainId}-{blockNumber}-{logIndex}" (e.g., "1-1234567-5")
-     */
-    id: t.text().primaryKey(),
-    /**
-     * The chain where the sale occurred.
-     */
-    chainId: t.int8({ mode: "number" }).notNull(),
-    /**
-     * The block number on chainId where the sale occurred.
-     */
-    blockNumber: t.bigint().notNull(),
-    /**
-     * The log index position of the sale event within blockNumber.
-     */
-    logIndex: t.integer().notNull(),
-    /**
-     * The EVM transaction hash on chainId associated with the sale.
-     */
-    transactionHash: t.hex().notNull(),
-    /**
-     * The Seaport order hash.
-     */
-    orderHash: t.hex().notNull(),
-    /**
-     * The address of the contract on chainId that manages tokenId.
-     */
-    contractAddress: t.hex().notNull(),
-    /**
-     * The tokenId managed by contractAddress that was sold.
-     *
-     * In a general context (outside of TokenScope) ERC1155 NFTs may have
-     * multiple copies, however TokenScope guarantees that all indexed NFTs
-     * never have an amount / balance > 1.
-     */
-    tokenId: t.bigint().notNull(),
-    /**
-     * The CAIP-19 Asset Namespace of the token that was sold. Either `erc721` or `erc1155`.
-     *
-     * @see https://chainagnostic.org/CAIPs/caip-19
-     */
-    assetNamespace: t.text().notNull(),
-    /**
-     * The CAIP-19 Asset ID of token that was sold. This is a globally unique reference to the
-     * specific asset in question.
-     *
-     * @see https://chainagnostic.org/CAIPs/caip-19
-     */
-    assetId: t.text().notNull(),
-    /**
-     * The namehash (Node) of the ENS domain that was sold.
-     */
-    domainId: t.hex().notNull(),
-    /**
-     * The account that bought the token controlling ownership of domainId from
-     * the seller for the amount of currency associated with the sale.
-     */
-    buyer: t.hex().notNull(),
-    /**
-     * The account that sold the token controlling ownership of domainId to
-     * buyer for the amount of currency associated with the sale.
-     */
-    seller: t.hex().notNull(),
-    /**
-     * Currency of the payment (ETH, USDC or DAI) from buyer to seller in exchange for tokenId.
-     */
-    currency: t.text().notNull(),
-    /**
-     * The amount of currency paid from buyer to seller in exchange for tokenId.
-     *
-     * Denominated in the smallest unit of currency.
-     *
-     * Amount interpretation depends on currency:
-     * - ETH/WETH: Amount in wei (1 ETH = 10^18 wei)
-     * - USDC: Amount in micro-units (1 USDC = 10^6 units)
-     * - DAI: Amount in wei-equivalent (1 DAI = 10^18 units)
-     */
-    amount: t.bigint().notNull(),
-    /**
-     * Unix timestamp of the block timestamp when the sale occurred.
-     */
-    timestamp: t.bigint().notNull()
+    id: t.text().primaryKey().$type(),
+    chainId: t.int8({ mode: "number" }).notNull().$type(),
+    address: t.hex().notNull().$type(),
+    resource: t.bigint().notNull(),
+    // The user/grantee address this Permission is granted to (the HCA account address if used).
+    user: t.hex().notNull().$type(),
+    // has one roles bitmap
+    roles: t.bigint().notNull()
   }),
   (t) => ({
-    idx_domainId: index4().on(t.domainId),
-    idx_assetId: index4().on(t.assetId),
-    idx_buyer: index4().on(t.buyer),
-    idx_seller: index4().on(t.seller),
-    idx_timestamp: index4().on(t.timestamp)
+    byId: uniqueIndex3().on(t.chainId, t.address, t.resource, t.user)
   })
 );
-var nameTokens = onchainTable6(
-  "name_tokens",
+var relations_permissionsUser = relations4(permissionsUser, ({ one }) => ({
+  account: one(account, {
+    fields: [permissionsUser.user],
+    references: [account.id]
+  }),
+  permissions: one(permissions, {
+    fields: [permissionsUser.chainId, permissionsUser.address],
+    references: [permissions.chainId, permissions.address]
+  }),
+  resource: one(permissionsResource, {
+    fields: [permissionsUser.chainId, permissionsUser.address, permissionsUser.resource],
+    references: [
+      permissionsResource.chainId,
+      permissionsResource.address,
+      permissionsResource.resource
+    ]
+  })
+}));
+var label = onchainTable6(
+  "labels",
   (t) => ({
-    /**
-     * The CAIP-19 Asset ID of the token.
-     *
-     * This is a globally unique reference to the token.
-     *
-     * @see https://chainagnostic.org/CAIPs/caip-19
-     */
-    id: t.text().primaryKey(),
-    /**
-     * The namehash (Node) of the ENS name associated with the token.
-     *
-     * Note: An ENS name may have more than one distinct token across time. It is
-     * also possible for multiple distinct tokens for an ENS name to have
-     * a mintStatus of `minted` at the same time. For example:
-     * - When a direct subname of .eth is wrapped by the NameWrapper. This state
-     *   has one minted token for the name managed by the BaseRegistrar (this
-     *   token will be owned by the NameWrapper) and another minted token for
-     *   the name managed by the NameWrapper (owned by the effective owner of
-     *   the name).
-     * - When a direct subname of .eth is wrapped by the NameWrapper and then
-     *   unwrapped. This state has one minted token (managed by the BaseRegistrar)
-     *   and another burned token (managed by the NameWrapper).
-     */
-    domainId: t.hex().notNull(),
-    /**
-     * The chain that manages the token.
-     */
-    chainId: t.int8({ mode: "number" }).notNull(),
-    /**
-     * The address of the contract on chainId that manages the token.
-     */
-    contractAddress: t.hex().notNull(),
-    /**
-     * The tokenId of the token managed by contractAddress.
-     *
-     * In a general context (outside of TokenScope) ERC1155 NFTs may have
-     * multiple copies, however TokenScope guarantees that all indexed NFTs
-     * never have an amount / balance > 1.
-     */
-    tokenId: t.bigint().notNull(),
-    /**
-     * The CAIP-19 Asset Namespace of the token. Either `erc721` or `erc1155`.
-     *
-     * @see https://chainagnostic.org/CAIPs/caip-19
-     */
-    assetNamespace: t.text().notNull(),
-    /**
-     * The account that owns the token.
-     *
-     * Value is zeroAddress if and only if mintStatus is `burned`.
-     *
-     * Note: The owner of the token for a given domainId may differ from the
-     * owner of the associated node in the registry. For example:
-     * - Consider the case where address X owns the ENS name `foo.eth` in
-     *   both the BaseRegistrar and the Registry. If X sends a request directly
-     *   to the Registry to transfer ownership to Y, ownership of `foo.eth` will
-     *   be transferred to Y in the Registry but not in the BaseRegistrar.
-     * - ... for the case above, the BaseRegistrar implements a `reclaim`
-     *   allowing the owner of the name in the BaseRegistrar to reclaim ownership
-     *   of the name in the Registry.
-     *
-     * Note: When a name is wrapped by the NameWrapper, the owner of the token
-     * in the BaseRegistrar is the NameWrapper, while a new token for the name is
-     * minted by the NameWrapper and owned by the effective owner of the name.
-     */
-    owner: t.hex().notNull(),
-    /**
-     * The mint status of the token. Either `minted` or `burned`.
-     *
-     * After we index a NFT we never delete it from our index. Instead, when an
-     * indexed NFT is burned onchain we retain its record and update its mint
-     * status as `burned`. If a NFT is minted again after it is burned its mint
-     * status is updated to `minted`.
-     */
-    mintStatus: t.text().notNull()
+    labelHash: t.hex().primaryKey().$type(),
+    interpreted: t.text().notNull().$type()
   }),
   (t) => ({
-    idx_domainId: index4().on(t.domainId),
-    idx_owner: index4().on(t.owner)
+    // hash index avoids the btree 8191-byte row-size hazard for spam labels (a single label can
+    // exceed btree's leaf-size limit)
+    byInterpretedExact: index5().using("hash", t.interpreted),
+    // GIN trigram index for substring / similarity queries (inline `gin_trgm_ops` via `sql`
+    // because passing it through `.op()` gets dropped by Ponder)
+    byInterpretedFuzzy: index5().using("gin", sql2`${t.interpreted} gin_trgm_ops`)
   })
 );
+var label_relations = relations4(label, ({ many }) => ({
+  domains: many(domain)
+}));
 
 // src/ensnode/index.ts
 var ensnode_exports = {};
@@ -2255,6 +2323,12 @@ var EnsDbReader = class {
     }
     return deserializeIndexingMetadataContext(record);
   }
+  /**
+   * Destroy the ENSDbReader instance by closing the ENSDb connection pool.
+   */
+  async destroy() {
+    await this.ensDb.$client.end();
+  }
   /**
    * Get ENSNode Metadata record
    *