@ensnode/ensnode-schema 0.35.0 → 1.0.0

package/dist/ponder.schema.js

@@ -1,130 +1,627 @@
-// src/subgraph.schema.ts
-import { index, onchainTable, relations } from "ponder";
+// src/schemas/protocol-acceleration.schema.ts
+import { onchainTable, primaryKey, relations } from "ponder";
+var reverseNameRecord = onchainTable(
+  "reverse_name_records",
+  (t) => ({
+    // keyed by (address, coinType)
+    address: 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-string normalized ENS name (see
+     * `interpretNameRecordValue` for additional context and specific guarantees). Unnormalized
+     * names and empty string values are interpreted as a deletion of the associated Reverse Name
+     * Record entity (represented in the schema as the _absence_ of a relevant Reverse Name Record
+     * entity).
+     */
+    value: t.text().notNull()
+  }),
+  (t) => ({
+    pk: primaryKey({ columns: [t.address, t.coinType] })
+  })
+);
+var nodeResolverRelation = onchainTable(
+  "node_resolver_relations",
+  (t) => ({
+    // keyed by (chainId, registry, node)
+    chainId: t.integer().notNull(),
+    registry: t.hex().notNull(),
+    node: t.hex().notNull(),
+    /**
+     * The Address of the Resolver contract this `node` has set (via Registry#NewResolver) within
+     * the Registry on `chainId`.
+     */
+    resolver: t.hex().notNull()
+  }),
+  (t) => ({
+    pk: primaryKey({ columns: [t.chainId, t.registry, t.node] })
+  })
+);
+var resolverRecords = onchainTable(
+  "resolver_records",
+  (t) => ({
+    // keyed by (chainId, resolver, node)
+    chainId: t.integer().notNull(),
+    resolver: t.hex().notNull(),
+    node: t.hex().notNull(),
+    /**
+     * Represents the value of the reverse-resolution (ENSIP-3) name() record, used for Reverse Resolution.
+     *
+     * The emitted record values are interpreted according to `interpretNameRecordValue` — unnormalized
+     * names and empty string values are interpreted as a deletion of the associated record (represented
+     * here as `null`).
+     *
+     * If set, the value of this field is guaranteed to be a non-empty-string normalized ENS name
+     * (see `interpretNameRecordValue` for additional context and specific guarantees).
+     */
+    name: t.text()
+  }),
+  (t) => ({
+    pk: primaryKey({ columns: [t.chainId, t.resolver, t.node] })
+  })
+);
+var resolverRecords_relations = relations(resolverRecords, ({ many }) => ({
+  // resolverRecord has many address records
+  addressRecords: many(resolverAddressRecord),
+  // resolverRecord has many text records
+  textRecords: many(resolverTextRecord)
+}));
+var resolverAddressRecord = onchainTable(
+  "resolver_address_records",
+  (t) => ({
+    // keyed by ((chainId, resolver, node), coinType)
+    chainId: t.integer().notNull(),
+    resolver: t.hex().notNull(),
+    node: t.hex().notNull(),
+    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.
+     */
+    address: t.text().notNull()
+  }),
+  (t) => ({
+    pk: primaryKey({ columns: [t.chainId, t.resolver, t.node, t.coinType] })
+  })
+);
+var resolverAddressRecordRelations = relations(resolverAddressRecord, ({ one }) => ({
+  // belongs to resolverRecord
+  resolver: one(resolverRecords, {
+    fields: [
+      resolverAddressRecord.chainId,
+      resolverAddressRecord.resolver,
+      resolverAddressRecord.node
+    ],
+    references: [resolverRecords.chainId, resolverRecords.resolver, resolverRecords.node]
+  })
+}));
+var resolverTextRecord = onchainTable(
+  "resolver_trecords",
+  (t) => ({
+    // keyed by ((chainId, resolver, node), key)
+    chainId: t.integer().notNull(),
+    resolver: t.hex().notNull(),
+    node: t.hex().notNull(),
+    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: primaryKey({ columns: [t.chainId, t.resolver, t.node, t.key] })
+  })
+);
+var resolverTextRecordRelations = relations(resolverTextRecord, ({ one }) => ({
+  // belongs to resolverRecord
+  resolver: one(resolverRecords, {
+    fields: [resolverTextRecord.chainId, resolverTextRecord.resolver, resolverTextRecord.node],
+    references: [resolverRecords.chainId, resolverRecords.resolver, resolverRecords.node]
+  })
+}));
+var migratedNode = onchainTable("migrated_nodes", (t) => ({
+  node: t.hex().primaryKey()
+}));
 
-// src/collate.ts
+// src/schemas/registrars.schema.ts
+import { index, onchainEnum, onchainTable as onchainTable2, relations as relations2, uniqueIndex } from "ponder";
+var subregistries = onchainTable2(
+  "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: uniqueIndex().on(t.node)
+  })
+);
+var registrationLifecycles = onchainTable2(
+  "registration_lifecycles",
+  (t) => ({
+    /**
+     * The node (namehash) of the FQDN of the domain the registration lifecycle
+     * is associated with.
+     *
+     * Guaranteed to be a subname of the node (namehash) of the subregistry
+     * identified by `subregistryId`.
+     *
+     * Guaranteed to be a fully lowercase hex string representation of 32-bytes.
+     */
+    node: t.hex().primaryKey(),
+    /**
+     * Subregistry ID
+     *
+     * Identifies the chainId and address of the subregistry smart contract
+     * that manages the registration lifecycle.
+     *
+     * Guaranteed to be a fully lowercase string formatted according to
+     * the CAIP-10 standard.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-10
+     */
+    subregistryId: t.text().notNull(),
+    /**
+     * Expires at
+     *
+     * Unix timestamp when the Registration Lifecycle is scheduled to expire.
+     */
+    expiresAt: t.bigint().notNull()
+  }),
+  (t) => ({
+    bySubregistry: index().on(t.subregistryId)
+  })
+);
+var registrarActionType = onchainEnum("registrar_action_type", [
+  "registration",
+  "renewal"
+]);
+var registrarActions = onchainTable2(
+  "registrar_actions",
+  (t) => ({
+    /**
+     * "Logical registrar action" ID
+     *
+     * The `id` value is a deterministic and globally unique identifier for
+     * the "logical registrar action".
+     *
+     * The `id` value represents the *initial* onchain event associated with
+     * the "logical registrar action", but the full state of
+     * the "logical registrar action" is an aggregate across each of
+     * the onchain events referenced in the `eventIds` field.
+     *
+     * Guaranteed to be the very first element in `eventIds` array.
+     */
+    id: t.text().primaryKey(),
+    /**
+     * The type of the "logical registrar action".
+     */
+    type: registrarActionType().notNull(),
+    /**
+     * Subregistry ID
+     *
+     * The ID of the subregistry the "logical registrar action" was taken on.
+     *
+     * Identifies the chainId and address of the associated subregistry smart
+     * contract.
+     *
+     * Guaranteed to be a fully lowercase string formatted according to
+     * the CAIP-10 standard.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-10
+     */
+    subregistryId: t.text().notNull(),
+    /**
+     * The node (namehash) of the FQDN of the domain associated with
+     * the "logical registrar action".
+     *
+     * Guaranteed to be a fully lowercase hex string representation of 32-bytes.
+     */
+    node: t.hex().notNull(),
+    /**
+     * Incremental Duration
+     *
+     * If `type` is "registration":
+     *   - Represents the duration between `blockTimestamp` and
+     *     the initial `expiresAt` value that the associated
+     *     "registration lifecycle" will be initialized with.
+     * If `type` is "renewal":
+     *   - Represents the incremental increase in duration made to
+     *     the `expiresAt` value in the associated "registration lifecycle".
+     *
+     * A "registration lifecycle" may be extended via renewal even after it
+     * expires if it is still within its grace period.
+     *
+     * Consider the following scenario:
+     *
+     * The "registration lifecycle" of a direct subname of .eth is scheduled to
+     * expire on Jan 1, midnight UTC. It is currently 30 days after this
+     * expiration time. Therefore, there are currently another 60 days of grace
+     * period remaining for this name. Anyone can still make a renewal to
+     * extend the "registration lifecycle" of this name.
+     *
+     * Given this scenario, consider the following examples:
+     *
+     * 1. If a renewal is made with 10 days incremental duration,
+     *    the "registration lifecycle" for this name will remain in
+     *    an "expired" state, but it will now have another 70 days of
+     *    grace period remaining.
+     *
+     * 2. If a renewal is made with 50 days incremental duration,
+     *    the "registration lifecycle" for this name will no longer be
+     *    "expired" and will become "active", but the "registration lifecycle"
+     *    will now be scheduled to expire again in 20 days.
+     *
+     * After the "registration lifecycle" for a name becomes expired by more
+     * than its grace period, it can no longer be renewed by anyone and is
+     * considered "released". The name must first be registered again, starting
+     * a new "registration lifecycle" of
+     * active / expired / grace period / released.
+     *
+     * May be 0.
+     *
+     * Guaranteed to be a non-negative bigint value.
+     */
+    incrementalDuration: t.bigint().notNull(),
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     *
+     * Guaranteed to be:
+     * 1) null if and only if `total` is null.
+     * 2) Otherwise, a non-negative bigint value.
+     */
+    baseCost: t.bigint(),
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     *
+     * Guaranteed to be:
+     * 1) null if and only if `total` is null.
+     * 2) Otherwise, zero when `type` is `renewal`.
+     * 3) Otherwise, a non-negative bigint value.
+     */
+    premium: t.bigint(),
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     *
+     * May be 0.
+     *
+     * Guaranteed to be:
+     * 1) null if and only if both `baseCost` and `premium` are null.
+     * 2) Otherwise, a non-negative bigint value, equal to the sum of
+     *    `baseCost` and `premium`.
+     */
+    total: t.bigint(),
+    /**
+     * Registrant
+     *
+     * Identifies the address that initiated the "logical registrar action" and
+     * is paying the `total` cost (if applicable).
+     *
+     * It may not be the owner of the name:
+     * 1. When a name is registered, the initial owner of the name may be
+     *    distinct from the registrant.
+     * 2. There are no restrictions on who may renew a name.
+     *    Therefore the owner of the name may be distinct from the registrant.
+     *
+     *
+     * The "chainId" of this address is the same as is referenced in `subregistryId`.
+     *
+     * Guaranteed to be a fully lowercase address
+     */
+    registrant: t.hex().notNull(),
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     *
+     * Guaranteed to be:
+     * 1) null if the emitted `eventIds` contain no information about a referrer.
+     * 2) Otherwise, a fully lowercase hex string representation of 32-bytes.
+     */
+    encodedReferrer: t.hex(),
+    /**
+     * Decoded referrer
+     *
+     * Decoded referrer according to the subjective interpretation of
+     * `encodedReferrer` defined for ENS Holiday Awards.
+     *
+     * Identifies the interpreted address of the referrer.
+     * The "chainId" of this address is the same as is referenced in
+     * `subregistryId`.
+     *
+     * Guaranteed to be:
+     * 1) null if `encodedReferrer` is null.
+     * 2) Otherwise, a fully lowercase address.
+     * 3) May be the "zero address" to represent that an `encodedReferrer` is
+     *    defined but that it is interpreted as no referrer.
+     */
+    decodedReferrer: t.hex(),
+    /**
+     * Number of the block that includes the "logical registrar action".
+     *
+     * The "chainId" of this block is the same as is referenced in
+     * `subregistryId`.
+     *
+     * Guaranteed to be a non-negative bigint value.
+     */
+    blockNumber: t.bigint().notNull(),
+    /**
+     * Unix timestamp of the block referenced by `blockNumber` that includes
+     * the "logical registrar action".
+     */
+    timestamp: t.bigint().notNull(),
+    /**
+     * Transaction hash of the transaction associated with
+     * the "logical registrar action".
+     *
+     * The "chainId" of this transaction is the same as is referenced in
+     * `subregistryId`.
+     *
+     * Note that a single transaction may be associated with any number of
+     * "logical registrar actions".
+     *
+     * Guaranteed to be a fully lowercase hex string representation of 32-bytes.
+     */
+    transactionHash: t.hex().notNull(),
+    /**
+     * Event IDs
+     *
+     * Array of the eventIds that have contributed to the state of
+     * the "logical registrar action" record.
+     *
+     * Each eventId is a deterministic and globally unique onchain event
+     * identifier.
+     *
+     * Guarantees:
+     * - Each eventId is of events that occurred within the block
+     *   referenced by `blockNumber`.
+     * - At least 1 eventId.
+     * - Ordered chronologically (ascending) by logIndex within `blockNumber`.
+     * - The first element in the array is equal to the `id` of
+     *   the overall "logical registrar action" record.
+     *
+     * The following ideas are not generalized for ENS overall but happen to
+     * be a characteristic of the scope of our current indexing logic:
+     * 1. These id's always reference events emitted by
+     *    a related "BaseRegistrar" contract.
+     * 2. These id's optionally reference events emitted by
+     *    a related "Registrar Controller" contract. This is because our
+     *    current indexing logic doesn't guarantee to index
+     *    all "Registrar Controller" contracts.
+     */
+    eventIds: t.text().array().notNull()
+  }),
+  (t) => ({
+    byDecodedReferrer: index().on(t.decodedReferrer),
+    byTimestamp: index().on(t.timestamp)
+  })
+);
+var internal_registrarActionMetadata = onchainTable2(
+  "_ensindexer_registrar_action_metadata",
+  (t) => ({
+    /**
+     * Logical Event Key
+     *
+     * A fully lowercase string formatted as:
+     * `{chainId}:{subregistryAddress}:{node}:{transactionHash}`
+     */
+    logicalEventKey: t.text().primaryKey(),
+    /**
+     * Logical Event ID
+     *
+     * A string holding the `id` value of the existing "logical registrar action"
+     * record that is currently being built as an aggregation of onchain events.
+     *
+     * May be used by subsequent event handlers to identify which
+     * "logical registrar action" to aggregate additional indexed state into.
+     */
+    logicalEventId: t.text().notNull()
+  })
+);
+var subregistryRelations = relations2(subregistries, ({ many }) => ({
+  registrationLifecycle: many(registrationLifecycles)
+}));
+var registrationLifecycleRelations = relations2(
+  registrationLifecycles,
+  ({ one, many }) => ({
+    subregistry: one(subregistries, {
+      fields: [registrationLifecycles.subregistryId],
+      references: [subregistries.subregistryId]
+    }),
+    registrarAction: many(registrarActions)
+  })
+);
+var registrarActionRelations = relations2(registrarActions, ({ one }) => ({
+  registrationLifecycle: one(registrationLifecycles, {
+    fields: [registrarActions.node],
+    references: [registrationLifecycles.node]
+  })
+}));
+
+// src/schemas/subgraph.schema.ts
+import { index as index2, onchainTable as onchainTable3, relations as relations3 } from "ponder";
+
+// src/lib/collate.ts
 function monkeypatchCollate(col, collation) {
   col.getSQLType = function() {
-    return Object.getPrototypeOf(this).getSQLType.call(this) + " COLLATE " + collation;
+    return `${Object.getPrototypeOf(this).getSQLType.call(this)} COLLATE ${collation}`;
   };
   return col;
 }
 
-// src/subgraph.schema.ts
-var domain = onchainTable("domains", (t) => ({
-  // The namehash of the name
-  id: t.hex().primaryKey(),
-  /**
-   * The human readable name that this Domain represents.
-   *
-   * If REPLACE_UNNORMALIZED is true, this value is guaranteed to be an Interpreted Name, which is either:
-   * a) a normalized Name, or
-   * b) a Name entirely consisting of Interpreted Labels.
-   *
-   * Note that the type of the column will remain string | null, for legacy subgraph compatibility,
-   * but in practice will never be null. The Root node's name will be '' (empty string).
-   *
-   * @see https://ensnode.io/docs/reference/terminology#interpreted-name
-   *
-   * If REPLACE_UNNORMALIZED is false, this value may contain:
-   * a) null (in the case of the root node), or
-   * b) a Literal Name that may or may not be normalized and may or may not contain Encoded LabelHashes.
-   *
-   * @see https://ensnode.io/docs/reference/terminology#literal-name
-   */
-  name: t.text(),
-  /**
-   * The Label associated with the Domain.
-   *
-   * If REPLACE_UNNORMALIZED is true, this value is guaranteed to be an Interpreted Label which is either:
-   * a) null, exclusively in the case of the root Node,
-   * b) a normalized Label, or
-   * c) an Encoded LabelHash of the Literal Label value found onchain.
-   *
-   * @see https://ensnode.io/docs/reference/terminology#interpreted-label
-   *
-   * If REPLACE_UNNORMALIZED is false, this value my contain:
-   * a) null, exclusively in the case of the root Node, or
-   * b) a Literal Label that may or may not be normalized and may or may not be an Encoded LabelHash.
-   *
-   * @see https://ensnode.io/docs/reference/terminology#literal-label
-   */
-  labelName: t.text(),
-  // keccak256(labelName)
-  labelhash: t.hex(),
-  // The namehash (id) of the parent name
-  parentId: t.hex(),
-  // The number of subdomains
-  subdomainCount: t.integer().notNull().default(0),
-  // Address logged from current resolver, if any
-  resolvedAddressId: t.hex(),
-  // The resolver that controls the domain's settings
-  resolverId: t.text(),
-  // The time-to-live (TTL) value of the domain's records
-  ttl: t.bigint(),
-  // Indicates whether the domain has been migrated to a new registrar
-  isMigrated: t.boolean().notNull().default(false),
-  // The time when the domain was created
-  createdAt: t.bigint().notNull(),
-  // The account that owns the domain
-  ownerId: t.hex().notNull(),
-  // The account that owns the ERC721 NFT for the domain
-  registrantId: t.hex(),
-  // The account that owns the wrapped domain
-  wrappedOwnerId: t.hex(),
-  // The expiry date for the domain, from either the registration, or the wrapped domain if PCC is burned
-  expiryDate: t.bigint()
-}));
-monkeypatchCollate(domain.name, '"C"');
-monkeypatchCollate(domain.labelName, '"C"');
-var domainRelations = relations(domain, ({ one, many }) => ({
-  resolvedAddress: one(account, {
-    fields: [domain.resolvedAddressId],
-    references: [account.id]
+// src/schemas/subgraph.schema.ts
+var subgraph_domain = onchainTable3(
+  "subgraph_domains",
+  (t) => ({
+    // The namehash of the name
+    id: t.hex().primaryKey(),
+    /**
+     * The ENS Name that this Domain represents.
+     *
+     * If {@link ENSIndexerConfig#isSubgraphCompatible}, this value is guaranteed to be either:
+     * a) null (in the case of the root node), or
+     * b) a Subgraph Interpreted Name.
+     *
+     * @see https://ensnode.io/docs/reference/terminology#subgraph-indexability--labelname-interpretation
+     *
+     * Otherwise, this value is guaranteed to be an Interpreted Name, which is either:
+     * a) a normalized Name, or
+     * b) a Name entirely consisting of Interpreted Labels.
+     *
+     * Note that the type of the column will remain string | null, for legacy subgraph compatibility,
+     * but in practice will never be null. The Root node's name will be '' (empty string).
+     *
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+     */
+    name: t.text(),
+    /**
+     * The Label associated with the Domain.
+     *
+     * If {@link ENSIndexerConfig#isSubgraphCompatible}, this value is guaranteed to be either:
+     * a) null, in the case of the root Node or a name whose childmost label is subgraph-unindexable, or
+     * b) a subgraph-indexable Subgraph Interpreted Label (i.e. a Literal Label of undefined normalization).
+     *
+     * @see https://ensnode.io/docs/reference/terminology#subgraph-indexability--labelname-interpretation
+     *
+     * Otherwise, this value is guaranteed to be an Interpreted Label which is either:
+     * a) null, exclusively in the case of the root Node,
+     * b) a normalized Label, or
+     * c) an Encoded LabelHash, which encodes either
+     *   i. in the case of an Unknown Label, the LabelHash emitted onchain, or
+     *   ii. in the case of an Unnormalized Label, the LabelHash of the Literal Label value found onchain.
+     *
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+     */
+    labelName: t.text(),
+    // keccak256(labelName)
+    labelhash: t.hex(),
+    // The namehash (id) of the parent name
+    parentId: t.hex(),
+    // The number of subdomains
+    subdomainCount: t.integer().notNull().default(0),
+    // Address logged from current resolver, if any
+    resolvedAddressId: t.hex(),
+    // The resolver that controls the domain's settings
+    resolverId: t.text(),
+    // The time-to-live (TTL) value of the domain's records
+    ttl: t.bigint(),
+    // Indicates whether the domain has been migrated to a new registrar
+    isMigrated: t.boolean().notNull().default(false),
+    // The time when the domain was created
+    createdAt: t.bigint().notNull(),
+    // The account that owns the domain
+    ownerId: t.hex().notNull(),
+    // The account that owns the ERC721 NFT for the domain
+    registrantId: t.hex(),
+    // The account that owns the wrapped domain
+    wrappedOwnerId: t.hex(),
+    // The expiry date for the domain, from either the registration, or the wrapped domain if PCC is burned
+    expiryDate: t.bigint()
+  }),
+  (t) => ({
+    byLabelhash: index2().on(t.labelhash),
+    byParentId: index2().on(t.parentId),
+    byOwnerId: index2().on(t.ownerId),
+    byRegistrantId: index2().on(t.registrantId),
+    byWrappedOwnerId: index2().on(t.wrappedOwnerId)
+  })
+);
+monkeypatchCollate(subgraph_domain.name, '"C"');
+monkeypatchCollate(subgraph_domain.labelName, '"C"');
+var subgraph_domainRelations = relations3(subgraph_domain, ({ one, many }) => ({
+  resolvedAddress: one(subgraph_account, {
+    fields: [subgraph_domain.resolvedAddressId],
+    references: [subgraph_account.id]
   }),
-  owner: one(account, { fields: [domain.ownerId], references: [account.id] }),
-  parent: one(domain, { fields: [domain.parentId], references: [domain.id] }),
-  resolver: one(resolver, {
-    fields: [domain.resolverId],
-    references: [resolver.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_domain.ownerId],
+    references: [subgraph_account.id]
   }),
-  subdomains: many(domain, { relationName: "parent" }),
-  registrant: one(account, {
-    fields: [domain.registrantId],
-    references: [account.id]
+  parent: one(subgraph_domain, {
+    fields: [subgraph_domain.parentId],
+    references: [subgraph_domain.id]
   }),
-  wrappedOwner: one(account, {
-    fields: [domain.wrappedOwnerId],
-    references: [account.id]
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_domain.resolverId],
+    references: [subgraph_resolver.id]
   }),
-  wrappedDomain: one(wrappedDomain, {
-    fields: [domain.id],
-    references: [wrappedDomain.domainId]
+  subdomains: many(subgraph_domain, { relationName: "parent" }),
+  registrant: one(subgraph_account, {
+    fields: [subgraph_domain.registrantId],
+    references: [subgraph_account.id]
   }),
-  registration: one(registration, {
-    fields: [domain.id],
-    references: [registration.domainId]
+  wrappedOwner: one(subgraph_account, {
+    fields: [subgraph_domain.wrappedOwnerId],
+    references: [subgraph_account.id]
+  }),
+  wrappedDomain: one(subgraph_wrappedDomain, {
+    fields: [subgraph_domain.id],
+    references: [subgraph_wrappedDomain.domainId]
+  }),
+  registration: one(subgraph_registration, {
+    fields: [subgraph_domain.id],
+    references: [subgraph_registration.domainId]
   }),
   // event relations
-  transfers: many(transfer),
-  newOwners: many(newOwner),
-  newResolvers: many(newResolver),
-  newTTLs: many(newTTL),
-  wrappedTransfers: many(wrappedTransfer),
-  nameWrappeds: many(nameWrapped),
-  nameUnwrappeds: many(nameUnwrapped),
-  fusesSets: many(fusesSet),
-  expiryExtendeds: many(expiryExtended)
+  transfers: many(subgraph_transfer),
+  newOwners: many(subgraph_newOwner),
+  newResolvers: many(subgraph_newResolver),
+  newTTLs: many(subgraph_newTTL),
+  wrappedTransfers: many(subgraph_wrappedTransfer),
+  nameWrappeds: many(subgraph_nameWrapped),
+  nameUnwrappeds: many(subgraph_nameUnwrapped),
+  fusesSets: many(subgraph_fusesSet),
+  expiryExtendeds: many(subgraph_expiryExtended)
 }));
-var account = onchainTable("accounts", (t) => ({
+var subgraph_account = onchainTable3("subgraph_accounts", (t) => ({
   id: t.hex().primaryKey()
 }));
-var accountRelations = relations(account, ({ many }) => ({
-  domains: many(domain),
-  wrappedDomains: many(wrappedDomain),
-  registrations: many(registration)
+var subgraph_accountRelations = relations3(subgraph_account, ({ many }) => ({
+  domains: many(subgraph_domain),
+  wrappedDomains: many(subgraph_wrappedDomain),
+  registrations: many(subgraph_registration)
 }));
-var resolver = onchainTable(
-  "resolvers",
+var subgraph_resolver = onchainTable3(
+  "subgraph_resolvers",
   (t) => ({
     // The unique identifier for this resolver, which is a concatenation of the domain namehash and the resolver address
     id: t.text().primaryKey(),
@@ -141,43 +638,35 @@ var resolver = onchainTable(
     texts: t.text().array(),
     // The set of observed SLIP-44 coin types for this resolver
     // NOTE: we avoid .notNull.default([]) to match subgraph behavior
-    coinTypes: t.bigint().array(),
-    /**
-     * Represents the value of the reverse-resolution (ENSIP-3) name() record.
-     *
-     * The emitted record values are interpreted according to `interpretNameRecordValue` — unnormalized
-     * names and empty string values are interpreted as a deletion of the associated record (represented
-     * here as `null`).
-     *
-     * If set, the value of this field is guaranteed to be a non-empty-string normalized ENS name
-     * (see `interpretNameRecordValue` for guarantees).
-     *
-     * Note that this is an extension to the original subgraph schema and legacy subgraph compatibility
-     * is not relevant.
-     */
-    name: t.text()
+    coinTypes: t.bigint().array()
   }),
   (t) => ({
-    idx: index().on(t.domainId)
+    byDomainId: index2().on(t.domainId)
   })
 );
-var resolverRelations = relations(resolver, ({ one, many }) => ({
-  addr: one(account, { fields: [resolver.addrId], references: [account.id] }),
-  domain: one(domain, { fields: [resolver.domainId], references: [domain.id] }),
+var subgraph_resolverRelations = relations3(subgraph_resolver, ({ one, many }) => ({
+  addr: one(subgraph_account, {
+    fields: [subgraph_resolver.addrId],
+    references: [subgraph_account.id]
+  }),
+  domain: one(subgraph_domain, {
+    fields: [subgraph_resolver.domainId],
+    references: [subgraph_domain.id]
+  }),
   // event relations
-  addrChangeds: many(addrChanged),
-  multicoinAddrChangeds: many(multicoinAddrChanged),
-  nameChangeds: many(nameChanged),
-  abiChangeds: many(abiChanged),
-  pubkeyChangeds: many(pubkeyChanged),
-  textChangeds: many(textChanged),
-  contenthashChangeds: many(contenthashChanged),
-  interfaceChangeds: many(interfaceChanged),
-  authorisationChangeds: many(authorisationChanged),
-  versionChangeds: many(versionChanged)
+  addrChangeds: many(subgraph_addrChanged),
+  multicoinAddrChangeds: many(subgraph_multicoinAddrChanged),
+  nameChangeds: many(subgraph_nameChanged),
+  abiChangeds: many(subgraph_abiChanged),
+  pubkeyChangeds: many(subgraph_pubkeyChanged),
+  textChangeds: many(subgraph_textChanged),
+  contenthashChangeds: many(subgraph_contenthashChanged),
+  interfaceChangeds: many(subgraph_interfaceChanged),
+  authorisationChangeds: many(subgraph_authorisationChanged),
+  versionChangeds: many(subgraph_versionChanged)
 }));
-var registration = onchainTable(
-  "registrations",
+var subgraph_registration = onchainTable3(
+  "subgraph_registrations",
   (t) => ({
     // The unique identifier of the registration
     id: t.hex().primaryKey(),
@@ -194,44 +683,45 @@ var registration = onchainTable(
     /**
      * The Label associated with the domain registration.
      *
-     * If REPLACE_UNNORMALIZED is true, this value is guaranteed to be an Interpreted Label which is either:
+     * If {@link ENSIndexerConfig#isSubgraphCompatible}, this value is guaranteed to be either:
+     * a) null, in the case of the root Node or a Domain whose label is subgraph-unindexable, or
+     * b) a subgraph-indexable Subgraph Interpreted Label (i.e. a Literal Label of undefined normalization).
+     *
+     * @see https://ensnode.io/docs/reference/terminology#subgraph-indexability--labelname-interpretation
+     *
+     * Otherwise, this value is guaranteed to be an Interpreted Label which is either:
      * a) a normalized Label, or
-     * b) an Encoded LabelHash of the Literal Label value found onchain.
+     * b) in the case of an Unnormalized Label, an Encoded LabelHash of the Literal Label value found onchain.
      *
      * Note that the type of the column will remain string | null, for legacy subgraph compatibility.
-     * In practice however, when REPLACE_UNNORMALIZED is true, because there is no Registration entity
-     * for the root Node—the only Node with a null labelName—this field will never be null.
+     * In practice however, because there is no Registration entity for the root Node (the only Node
+     * with a null labelName) this field will never be null.
      *
      * @see https://ensnode.io/docs/reference/terminology#interpreted-label
-     *
-     * If REPLACE_UNNORMALIZED is false, this value may contain:
-     * a) null, or
-     * b) a Literal Label that may or may not be normalized and may or may not be an Encoded LabelHash.
-     *
-     * @see https://ensnode.io/docs/reference/terminology#literal-label
      */
     labelName: t.text()
   }),
   (t) => ({
-    idx: index().on(t.domainId)
+    byDomainId: index2().on(t.domainId),
+    byRegistrationDate: index2().on(t.registrationDate)
   })
 );
-var registrationRelations = relations(registration, ({ one, many }) => ({
-  domain: one(domain, {
-    fields: [registration.domainId],
-    references: [domain.id]
+var subgraph_registrationRelations = relations3(subgraph_registration, ({ one, many }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_registration.domainId],
+    references: [subgraph_domain.id]
   }),
-  registrant: one(account, {
-    fields: [registration.registrantId],
-    references: [account.id]
+  registrant: one(subgraph_account, {
+    fields: [subgraph_registration.registrantId],
+    references: [subgraph_account.id]
   }),
   // event relations
-  nameRegistereds: many(nameRegistered),
-  nameReneweds: many(nameRenewed),
-  nameTransferreds: many(nameTransferred)
+  nameRegistereds: many(subgraph_nameRegistered),
+  nameReneweds: many(subgraph_nameRenewed),
+  nameTransferreds: many(subgraph_nameTransferred)
 }));
-var wrappedDomain = onchainTable(
-  "wrapped_domains",
+var subgraph_wrappedDomain = onchainTable3(
+  "subgraph_wrapped_domains",
   (t) => ({
     // The unique identifier for each instance of the WrappedDomain entity
     id: t.hex().primaryKey(),
@@ -244,37 +734,35 @@ var wrappedDomain = onchainTable(
     // The account that owns this WrappedDomain
     ownerId: t.hex().notNull(),
     /**
-     * The Name that this WrappedDomain represents.
-     *
-     * If REPLACE_UNNORMALIZED is true, this value is guaranteed to be an Interpreted Name, which is either:
-     * a) a normalized Name, or
-     * b) a Name entirely consisting of Interpreted Labels.
+     * The Name that this WrappedDomain represents. Names are emitted by the NameWrapper contract as
+     * DNS-Encoded Names which may be malformed, which will result in this field being `null`.
      *
-     * Note that the type of the column will remain string | null, for legacy subgraph compatibility,
-     * but in practice will never be null.
+     * If {@link ENSIndexerConfig#isSubgraphCompatible}, this value is guaranteed to be either:
+     * a) null (in the case of a DNS-Encoded Name that is malformed or contains subgraph-unindexable labels), or
+     * b) a subgraph-indexable Subgraph Interpreted Label (i.e. a Literal Label of undefined normalization).
      *
-     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+     * @see https://ensnode.io/docs/reference/terminology#subgraph-indexability--labelname-interpretation
      *
-     * If REPLACE_UNNORMALIZED is false, this value may contain:
-     * a) null (in the case of the root node or invalid Name), or
-     * b) a Literal Name that may or may not be normalized and may or may not contain Encoded LabelHashes.
+     * Otherwise, this value is guaranteed to be either:
+     * a) null (in the case of a malformed DNS-Encoded Name),
+     * b) an Interpreted Name.
      *
-     * @see https://ensnode.io/docs/reference/terminology#literal-name
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
      */
     name: t.text()
   }),
   (t) => ({
-    idx: index().on(t.domainId)
+    byDomainId: index2().on(t.domainId)
   })
 );
-var wrappedDomainRelations = relations(wrappedDomain, ({ one }) => ({
-  domain: one(domain, {
-    fields: [wrappedDomain.domainId],
-    references: [domain.id]
+var subgraph_wrappedDomainRelations = relations3(subgraph_wrappedDomain, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_wrappedDomain.domainId],
+    references: [subgraph_domain.id]
   }),
-  owner: one(account, {
-    fields: [wrappedDomain.ownerId],
-    references: [account.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_wrappedDomain.ownerId],
+    references: [subgraph_account.id]
   })
 }));
 var sharedEventColumns = (t) => ({
@@ -288,20 +776,20 @@ var domainEvent = (t) => ({
 });
 var domainEventIndex = (t) => ({
   // primary reverse lookup
-  idx: index().on(t.domainId),
+  idx: index2().on(t.domainId),
   // sorting index
-  idx_compound: index().on(t.domainId, t.id)
+  idx_compound: index2().on(t.domainId, t.id)
 });
-var transfer = onchainTable(
-  "transfers",
+var subgraph_transfer = onchainTable3(
+  "subgraph_transfers",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull()
   }),
   domainEventIndex
 );
-var newOwner = onchainTable(
-  "new_owners",
+var subgraph_newOwner = onchainTable3(
+  "subgraph_new_owners",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull(),
@@ -309,32 +797,32 @@ var newOwner = onchainTable(
   }),
   domainEventIndex
 );
-var newResolver = onchainTable(
-  "new_resolvers",
+var subgraph_newResolver = onchainTable3(
+  "subgraph_new_resolvers",
   (t) => ({
     ...domainEvent(t),
     resolverId: t.text().notNull()
   }),
   domainEventIndex
 );
-var newTTL = onchainTable(
-  "new_ttls",
+var subgraph_newTTL = onchainTable3(
+  "subgraph_new_ttls",
   (t) => ({
     ...domainEvent(t),
     ttl: t.bigint().notNull()
   }),
   domainEventIndex
 );
-var wrappedTransfer = onchainTable(
-  "wrapped_transfers",
+var subgraph_wrappedTransfer = onchainTable3(
+  "subgraph_wrapped_transfers",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull()
   }),
   domainEventIndex
 );
-var nameWrapped = onchainTable(
-  "name_wrapped",
+var subgraph_nameWrapped = onchainTable3(
+  "subgraph_name_wrapped",
   (t) => ({
     ...domainEvent(t),
     name: t.text(),
@@ -344,24 +832,24 @@ var nameWrapped = onchainTable(
   }),
   domainEventIndex
 );
-var nameUnwrapped = onchainTable(
-  "name_unwrapped",
+var subgraph_nameUnwrapped = onchainTable3(
+  "subgraph_name_unwrapped",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull()
   }),
   domainEventIndex
 );
-var fusesSet = onchainTable(
-  "fuses_set",
+var subgraph_fusesSet = onchainTable3(
+  "subgraph_fuses_set",
   (t) => ({
     ...domainEvent(t),
     fuses: t.integer().notNull()
   }),
   domainEventIndex
 );
-var expiryExtended = onchainTable(
-  "expiry_extended",
+var subgraph_expiryExtended = onchainTable3(
+  "subgraph_expiry_extended",
   (t) => ({
     ...domainEvent(t),
     expiryDate: t.bigint().notNull()
@@ -374,12 +862,12 @@ var registrationEvent = (t) => ({
 });
 var registrationEventIndex = (t) => ({
   // primary reverse lookup
-  idx: index().on(t.registrationId),
+  idx: index2().on(t.registrationId),
   // sorting index
-  idx_compound: index().on(t.registrationId, t.id)
+  idx_compound: index2().on(t.registrationId, t.id)
 });
-var nameRegistered = onchainTable(
-  "name_registered",
+var subgraph_nameRegistered = onchainTable3(
+  "subgraph_name_registered",
   (t) => ({
     ...registrationEvent(t),
     registrantId: t.hex().notNull(),
@@ -387,16 +875,16 @@ var nameRegistered = onchainTable(
   }),
   registrationEventIndex
 );
-var nameRenewed = onchainTable(
-  "name_renewed",
+var subgraph_nameRenewed = onchainTable3(
+  "subgraph_name_renewed",
   (t) => ({
     ...registrationEvent(t),
     expiryDate: t.bigint().notNull()
   }),
   registrationEventIndex
 );
-var nameTransferred = onchainTable(
-  "name_transferred",
+var subgraph_nameTransferred = onchainTable3(
+  "subgraph_name_transferred",
   (t) => ({
     ...registrationEvent(t),
     newOwnerId: t.hex().notNull()
@@ -409,20 +897,20 @@ var resolverEvent = (t) => ({
 });
 var resolverEventIndex = (t) => ({
   // primary reverse lookup
-  idx: index().on(t.resolverId),
+  idx: index2().on(t.resolverId),
   // sorting index
-  idx_compound: index().on(t.resolverId, t.id)
+  idx_compound: index2().on(t.resolverId, t.id)
 });
-var addrChanged = onchainTable(
-  "addr_changed",
+var subgraph_addrChanged = onchainTable3(
+  "subgraph_addr_changed",
   (t) => ({
     ...resolverEvent(t),
     addrId: t.hex().notNull()
   }),
   resolverEventIndex
 );
-var multicoinAddrChanged = onchainTable(
-  "multicoin_addr_changed",
+var subgraph_multicoinAddrChanged = onchainTable3(
+  "subgraph_multicoin_addr_changed",
   (t) => ({
     ...resolverEvent(t),
     coinType: t.bigint().notNull(),
@@ -430,24 +918,24 @@ var multicoinAddrChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var nameChanged = onchainTable(
-  "name_changed",
+var subgraph_nameChanged = onchainTable3(
+  "subgraph_name_changed",
   (t) => ({
     ...resolverEvent(t),
     name: t.text().notNull()
   }),
   resolverEventIndex
 );
-var abiChanged = onchainTable(
-  "abi_changed",
+var subgraph_abiChanged = onchainTable3(
+  "subgraph_abi_changed",
   (t) => ({
     ...resolverEvent(t),
     contentType: t.bigint().notNull()
   }),
   resolverEventIndex
 );
-var pubkeyChanged = onchainTable(
-  "pubkey_changed",
+var subgraph_pubkeyChanged = onchainTable3(
+  "subgraph_pubkey_changed",
   (t) => ({
     ...resolverEvent(t),
     x: t.hex().notNull(),
@@ -455,8 +943,8 @@ var pubkeyChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var textChanged = onchainTable(
-  "text_changed",
+var subgraph_textChanged = onchainTable3(
+  "subgraph_text_changed",
   (t) => ({
     ...resolverEvent(t),
     key: t.text().notNull(),
@@ -464,16 +952,16 @@ var textChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var contenthashChanged = onchainTable(
-  "contenthash_changed",
+var subgraph_contenthashChanged = onchainTable3(
+  "subgraph_contenthash_changed",
   (t) => ({
     ...resolverEvent(t),
     hash: t.hex().notNull()
   }),
   resolverEventIndex
 );
-var interfaceChanged = onchainTable(
-  "interface_changed",
+var subgraph_interfaceChanged = onchainTable3(
+  "subgraph_interface_changed",
   (t) => ({
     ...resolverEvent(t),
     interfaceID: t.hex().notNull(),
@@ -481,8 +969,8 @@ var interfaceChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var authorisationChanged = onchainTable(
-  "authorisation_changed",
+var subgraph_authorisationChanged = onchainTable3(
+  "subgraph_authorisation_changed",
   (t) => ({
     ...resolverEvent(t),
     owner: t.hex().notNull(),
@@ -491,229 +979,203 @@ var authorisationChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var versionChanged = onchainTable(
-  "version_changed",
+var subgraph_versionChanged = onchainTable3(
+  "subgraph_version_changed",
   (t) => ({
     ...resolverEvent(t),
     version: t.bigint().notNull()
   }),
   resolverEventIndex
 );
-var transferRelations = relations(transfer, ({ one }) => ({
-  domain: one(domain, { fields: [transfer.domainId], references: [domain.id] }),
-  owner: one(account, { fields: [transfer.ownerId], references: [account.id] })
-}));
-var newOwnerRelations = relations(newOwner, ({ one }) => ({
-  domain: one(domain, { fields: [newOwner.domainId], references: [domain.id] }),
-  owner: one(account, { fields: [newOwner.ownerId], references: [account.id] }),
-  parentDomain: one(domain, {
-    fields: [newOwner.parentDomainId],
-    references: [domain.id]
-  })
-}));
-var newResolverRelations = relations(newResolver, ({ one }) => ({
-  domain: one(domain, {
-    fields: [newResolver.domainId],
-    references: [domain.id]
+var subgraph_transferRelations = relations3(subgraph_transfer, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_transfer.domainId],
+    references: [subgraph_domain.id]
   }),
-  resolver: one(resolver, {
-    fields: [newResolver.resolverId],
-    references: [resolver.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_transfer.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var newTTLRelations = relations(newTTL, ({ one }) => ({
-  domain: one(domain, { fields: [newTTL.domainId], references: [domain.id] })
-}));
-var wrappedTransferRelations = relations(wrappedTransfer, ({ one }) => ({
-  domain: one(domain, {
-    fields: [wrappedTransfer.domainId],
-    references: [domain.id]
+var subgraph_newOwnerRelations = relations3(subgraph_newOwner, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newOwner.domainId],
+    references: [subgraph_domain.id]
   }),
-  owner: one(account, {
-    fields: [wrappedTransfer.ownerId],
-    references: [account.id]
-  })
-}));
-var nameWrappedRelations = relations(nameWrapped, ({ one }) => ({
-  domain: one(domain, {
-    fields: [nameWrapped.domainId],
-    references: [domain.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_newOwner.ownerId],
+    references: [subgraph_account.id]
   }),
-  owner: one(account, {
-    fields: [nameWrapped.ownerId],
-    references: [account.id]
+  parentDomain: one(subgraph_domain, {
+    fields: [subgraph_newOwner.parentDomainId],
+    references: [subgraph_domain.id]
   })
 }));
-var nameUnwrappedRelations = relations(nameUnwrapped, ({ one }) => ({
-  domain: one(domain, {
-    fields: [nameUnwrapped.domainId],
-    references: [domain.id]
+var subgraph_newResolverRelations = relations3(subgraph_newResolver, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newResolver.domainId],
+    references: [subgraph_domain.id]
   }),
-  owner: one(account, {
-    fields: [nameUnwrapped.ownerId],
-    references: [account.id]
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_newResolver.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var fusesSetRelations = relations(fusesSet, ({ one }) => ({
-  domain: one(domain, { fields: [fusesSet.domainId], references: [domain.id] })
-}));
-var expiryExtendedRelations = relations(expiryExtended, ({ one }) => ({
-  domain: one(domain, {
-    fields: [expiryExtended.domainId],
-    references: [domain.id]
+var subgraph_newTTLRelations = relations3(subgraph_newTTL, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newTTL.domainId],
+    references: [subgraph_domain.id]
   })
 }));
-var nameRegisteredRelations = relations(nameRegistered, ({ one }) => ({
-  registration: one(registration, {
-    fields: [nameRegistered.registrationId],
-    references: [registration.id]
+var subgraph_wrappedTransferRelations = relations3(subgraph_wrappedTransfer, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_wrappedTransfer.domainId],
+    references: [subgraph_domain.id]
   }),
-  registrant: one(account, {
-    fields: [nameRegistered.registrantId],
-    references: [account.id]
-  })
-}));
-var nameRenewedRelations = relations(nameRenewed, ({ one }) => ({
-  registration: one(registration, {
-    fields: [nameRenewed.registrationId],
-    references: [registration.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_wrappedTransfer.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var nameTransferredRelations = relations(nameTransferred, ({ one }) => ({
-  registration: one(registration, {
-    fields: [nameTransferred.registrationId],
-    references: [registration.id]
+var subgraph_nameWrappedRelations = relations3(subgraph_nameWrapped, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_nameWrapped.domainId],
+    references: [subgraph_domain.id]
   }),
-  newOwner: one(account, {
-    fields: [nameTransferred.newOwnerId],
-    references: [account.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_nameWrapped.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var addrChangedRelations = relations(addrChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [addrChanged.resolverId],
-    references: [resolver.id]
+var subgraph_nameUnwrappedRelations = relations3(subgraph_nameUnwrapped, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_nameUnwrapped.domainId],
+    references: [subgraph_domain.id]
   }),
-  addr: one(account, {
-    fields: [addrChanged.addrId],
-    references: [account.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_nameUnwrapped.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var multicoinAddrChangedRelations = relations(multicoinAddrChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [multicoinAddrChanged.resolverId],
-    references: [resolver.id]
+var subgraph_fusesSetRelations = relations3(subgraph_fusesSet, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_fusesSet.domainId],
+    references: [subgraph_domain.id]
   })
 }));
-var nameChangedRelations = relations(nameChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [nameChanged.resolverId],
-    references: [resolver.id]
+var subgraph_expiryExtendedRelations = relations3(subgraph_expiryExtended, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_expiryExtended.domainId],
+    references: [subgraph_domain.id]
   })
 }));
-var abiChangedRelations = relations(abiChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [abiChanged.resolverId],
-    references: [resolver.id]
+var subgraph_nameRegisteredRelations = relations3(subgraph_nameRegistered, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameRegistered.registrationId],
+    references: [subgraph_registration.id]
+  }),
+  registrant: one(subgraph_account, {
+    fields: [subgraph_nameRegistered.registrantId],
+    references: [subgraph_account.id]
   })
 }));
-var pubkeyChangedRelations = relations(pubkeyChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [pubkeyChanged.resolverId],
-    references: [resolver.id]
+var subgraph_nameRenewedRelations = relations3(subgraph_nameRenewed, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameRenewed.registrationId],
+    references: [subgraph_registration.id]
   })
 }));
-var textChangedRelations = relations(textChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [textChanged.resolverId],
-    references: [resolver.id]
+var subgraph_nameTransferredRelations = relations3(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 contenthashChangedRelations = relations(contenthashChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [contenthashChanged.resolverId],
-    references: [resolver.id]
+var subgraph_addrChangedRelations = relations3(subgraph_addrChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_addrChanged.resolverId],
+    references: [subgraph_resolver.id]
+  }),
+  addr: one(subgraph_account, {
+    fields: [subgraph_addrChanged.addrId],
+    references: [subgraph_account.id]
   })
 }));
-var interfaceChangedRelations = relations(interfaceChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [interfaceChanged.resolverId],
-    references: [resolver.id]
+var subgraph_multicoinAddrChangedRelations = relations3(
+  subgraph_multicoinAddrChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_multicoinAddrChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
   })
-}));
-var authorisationChangedRelations = relations(authorisationChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [authorisationChanged.resolverId],
-    references: [resolver.id]
+);
+var subgraph_nameChangedRelations = relations3(subgraph_nameChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_nameChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var versionChangedRelations = relations(versionChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [versionChanged.resolverId],
-    references: [resolver.id]
+var subgraph_abiChangedRelations = relations3(subgraph_abiChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_abiChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-
-// src/resolver-records.schema.ts
-import { onchainTable as onchainTable2, relations as relations2, uniqueIndex } from "ponder";
-var ext_resolverRecords_resolver_relations = relations2(resolver, ({ one, many }) => ({
-  // resolver has many address records
-  addressRecords: many(ext_resolverAddressRecords),
-  // resolver has many text records
-  // NOTE: can't use `texts` because Resolver.texts is used by subgraph schema
-  textRecords: many(ext_resolverTextRecords)
+var subgraph_pubkeyChangedRelations = relations3(subgraph_pubkeyChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_pubkeyChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
 }));
-var ext_resolverAddressRecords = onchainTable2(
-  "ext_resolver_address_records",
-  (t) => ({
-    // keyed by (resolverId, coinType)
-    id: t.text().primaryKey(),
-    resolverId: t.text().notNull(),
-    coinType: t.bigint().notNull(),
-    address: t.text().notNull()
-  }),
-  (t) => ({
-    byResolverIdAndCoinType: uniqueIndex().on(t.resolverId, t.coinType)
+var subgraph_textChangedRelations = relations3(subgraph_textChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_textChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
-);
-var ext_resolverAddressRecordsRelations = relations2(
-  ext_resolverAddressRecords,
-  ({ one, many }) => ({
-    // belongs to resolver
-    resolver: one(resolver, {
-      fields: [ext_resolverAddressRecords.resolverId],
-      references: [resolver.id]
+}));
+var subgraph_contenthashChangedRelations = relations3(
+  subgraph_contenthashChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_contenthashChanged.resolverId],
+      references: [subgraph_resolver.id]
     })
   })
 );
-var ext_resolverTextRecords = onchainTable2(
-  "ext_resolver_text_records",
-  (t) => ({
-    // keyed by (resolverId, key)
-    id: t.text().primaryKey(),
-    resolverId: t.text().notNull(),
-    key: t.text().notNull(),
-    value: t.text().notNull()
-  }),
-  (t) => ({
-    byResolverIdAndKey: uniqueIndex().on(t.resolverId, t.key)
+var subgraph_interfaceChangedRelations = relations3(
+  subgraph_interfaceChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_interfaceChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
   })
 );
-var ext_resolverTextRecordsRelations = relations2(
-  ext_resolverTextRecords,
-  ({ one, many }) => ({
-    // belongs to resolver
-    resolver: one(resolver, {
-      fields: [ext_resolverTextRecords.resolverId],
-      references: [resolver.id]
+var subgraph_authorisationChangedRelations = relations3(
+  subgraph_authorisationChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_authorisationChanged.resolverId],
+      references: [subgraph_resolver.id]
     })
   })
 );
+var subgraph_versionChangedRelations = relations3(subgraph_versionChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_versionChanged.resolverId],
+    references: [subgraph_resolver.id]
+  })
+}));
 
-// src/tokenscope.schema.ts
-import { index as index2, onchainTable as onchainTable3 } from "ponder";
-var ext_nameSales = onchainTable3(
-  "ext_name_sales",
+// src/schemas/tokenscope.schema.ts
+import { index as index3, onchainTable as onchainTable4 } from "ponder";
+var nameSales = onchainTable4(
+  "name_sales",
   (t) => ({
     /**
      * Unique and deterministic identifier of the onchain event associated with the sale.
@@ -801,15 +1263,15 @@ var ext_nameSales = onchainTable3(
     timestamp: t.bigint().notNull()
   }),
   (t) => ({
-    idx_domainId: index2().on(t.domainId),
-    idx_assetId: index2().on(t.assetId),
-    idx_buyer: index2().on(t.buyer),
-    idx_seller: index2().on(t.seller),
-    idx_timestamp: index2().on(t.timestamp)
+    idx_domainId: index3().on(t.domainId),
+    idx_assetId: index3().on(t.assetId),
+    idx_buyer: index3().on(t.buyer),
+    idx_seller: index3().on(t.seller),
+    idx_timestamp: index3().on(t.timestamp)
   })
 );
-var ext_nameTokens = onchainTable3(
-  "ext_name_tokens",
+var nameTokens = onchainTable4(
+  "name_tokens",
   (t) => ({
     /**
      * The CAIP-19 Asset ID of the token.
@@ -888,261 +1350,83 @@ var ext_nameTokens = onchainTable3(
     mintStatus: t.text().notNull()
   }),
   (t) => ({
-    idx_domainId: index2().on(t.domainId),
-    idx_owner: index2().on(t.owner)
-  })
-);
-
-// src/resolver-relations.schema.ts
-import { onchainTable as onchainTable4, relations as relations3, uniqueIndex as uniqueIndex2 } from "ponder";
-var ext_resolverRelations_domain_relations = relations3(domain, ({ one, many }) => ({
-  // domain has many resolver relations (i.e. one per chain, see above)
-  resolverRelations: many(ext_domainResolverRelation)
-}));
-var ext_resolverRelations_resolver_relations = relations3(resolver, ({ one, many }) => ({
-  // resolver has many domain relations
-  domainRelations: many(ext_domainResolverRelation)
-}));
-var ext_domainResolverRelation = onchainTable4(
-  "ext_domain_resolver_relations",
-  (t) => ({
-    // keyed by (chainId, domainId)
-    id: t.text().primaryKey(),
-    chainId: t.integer().notNull(),
-    domainId: t.text().notNull(),
-    resolverId: t.text().notNull()
-  }),
-  (t) => ({
-    byChainIdAndDomain: uniqueIndex2().on(t.chainId, t.domainId)
-  })
-);
-var ext_domainResolverRelationsRelations = relations3(
-  ext_domainResolverRelation,
-  ({ one, many }) => ({
-    // belongs to domain
-    domain: one(domain, {
-      fields: [ext_domainResolverRelation.domainId],
-      references: [domain.id]
-    }),
-    // belongs to resolver
-    resolver: one(resolver, {
-      fields: [ext_domainResolverRelation.resolverId],
-      references: [resolver.id]
-    })
+    idx_domainId: index3().on(t.domainId),
+    idx_owner: index3().on(t.owner)
   })
 );
-
-// src/referrals.schema.ts
-import { index as index3, onchainTable as onchainTable5, relations as relations4 } from "ponder";
-var ext_registrationReferral = onchainTable5(
-  "ext_registration_referral",
-  (t) => ({
-    // keyed by any arbitrary unique id, usually `event.id`
-    id: t.text().primaryKey(),
-    referrerId: t.hex().notNull(),
-    domainId: t.text().notNull(),
-    refereeId: t.hex().notNull(),
-    baseCost: t.bigint().notNull(),
-    premium: t.bigint().notNull(),
-    total: t.bigint().notNull(),
-    // chainId the transaction occurred on
-    chainId: t.integer().notNull(),
-    // transaction's hash
-    transactionHash: t.hex().notNull(),
-    // block's Unix timestamp in seconds
-    timestamp: t.bigint().notNull()
-  }),
-  (t) => ({
-    byRefereeId: index3().on(t.refereeId),
-    byReferrerId: index3().on(t.referrerId)
-  })
-);
-var ext_registrationReferral_relations = relations4(
-  ext_registrationReferral,
-  ({ one, many }) => ({
-    // RegistrationReferral references one Referrer
-    referrer: one(ext_referrer, {
-      fields: [ext_registrationReferral.referrerId],
-      references: [ext_referrer.id]
-    }),
-    // RegistrationReferral references one Account (as referee)
-    referee: one(account, {
-      fields: [ext_registrationReferral.refereeId],
-      references: [account.id]
-    }),
-    // RegistrationReferral references one Domain
-    domain: one(domain, {
-      fields: [ext_registrationReferral.domainId],
-      references: [domain.id]
-    })
-  })
-);
-var ext_renewalReferral = onchainTable5(
-  "ext_renewal_referral",
-  (t) => ({
-    // keyed by any arbitrary unique id, usually `event.id`
-    id: t.text().primaryKey(),
-    referrerId: t.hex().notNull(),
-    refereeId: t.hex().notNull(),
-    domainId: t.text().notNull(),
-    cost: t.bigint().notNull(),
-    // chainId the transaction occurred on
-    chainId: t.integer().notNull(),
-    // transaction's hash
-    transactionHash: t.hex().notNull(),
-    // Block's Unix timestamp in seconds
-    timestamp: t.bigint().notNull()
-  }),
-  (t) => ({
-    byRefereeId: index3().on(t.refereeId),
-    byReferrerId: index3().on(t.referrerId)
-  })
-);
-var ext_renewalReferral_relations = relations4(ext_renewalReferral, ({ one, many }) => ({
-  // RenewalReferral references one Referrer
-  referrer: one(ext_referrer, {
-    fields: [ext_renewalReferral.referrerId],
-    references: [ext_referrer.id]
-  }),
-  // RenewalReferral references one Account (as referee)
-  referee: one(account, {
-    fields: [ext_renewalReferral.refereeId],
-    references: [account.id]
-  }),
-  // RenewalReferral references one Domain
-  domain: one(domain, {
-    fields: [ext_renewalReferral.domainId],
-    references: [domain.id]
-  })
-}));
-var ext_referrals_domain_relations = relations4(domain, ({ one, many }) => ({
-  // Domain has many RegistrationReferrals
-  registrationReferrals: many(ext_registrationReferral),
-  // Domain has many RenewalReferrals
-  renewalReferrals: many(ext_renewalReferral)
-}));
-var ext_referrer = onchainTable5(
-  "ext_referral_totals",
-  (t) => ({
-    // keyed by Referrer's id (bytes32 hex)
-    id: t.hex().primaryKey(),
-    valueWei: t.bigint().notNull()
-  }),
-  (t) => ({})
-);
-var ext_referrer_relations = relations4(ext_referrer, ({ one, many }) => ({
-  // Referrer has many RegistrationReferrals
-  registrationReferrals: many(ext_registrationReferral),
-  // Referrer has many RenewalReferrals
-  renewalReferrals: many(ext_renewalReferral)
-}));
-
-// src/primary-names.schema.ts
-import { onchainTable as onchainTable6, relations as relations5, uniqueIndex as uniqueIndex3 } from "ponder";
-var ext_primaryNames_domain_relations = relations5(account, ({ one, many }) => ({
-  // account has many primary names
-  primaryNames: many(ext_primaryName)
-}));
-var ext_primaryName = onchainTable6(
-  "ext_primary_names",
-  (t) => ({
-    // keyed by (address, coinType)
-    id: t.text().primaryKey(),
-    address: t.hex().notNull(),
-    coinType: t.bigint().notNull(),
-    /**
-     * Represents the ENSIP-19 Primary Name value for a given (address, coinType).
-     *
-     * The value of this field is guaranteed to be a non-empty-string normalized ENS name.
-     */
-    name: t.text().notNull()
-  }),
-  (t) => ({
-    byAddressAndCoinType: uniqueIndex3().on(t.address, t.coinType)
-  })
-);
-var ext_primaryNameRelations = relations5(ext_primaryName, ({ one, many }) => ({
-  // belongs to account
-  account: one(account, {
-    fields: [ext_primaryName.address],
-    references: [account.id]
-  })
-}));
 export {
-  abiChanged,
-  abiChangedRelations,
-  account,
-  accountRelations,
-  addrChanged,
-  addrChangedRelations,
-  authorisationChanged,
-  authorisationChangedRelations,
-  contenthashChanged,
-  contenthashChangedRelations,
-  domain,
-  domainRelations,
-  expiryExtended,
-  expiryExtendedRelations,
-  ext_domainResolverRelation,
-  ext_domainResolverRelationsRelations,
-  ext_nameSales,
-  ext_nameTokens,
-  ext_primaryName,
-  ext_primaryNameRelations,
-  ext_primaryNames_domain_relations,
-  ext_referrals_domain_relations,
-  ext_referrer,
-  ext_referrer_relations,
-  ext_registrationReferral,
-  ext_registrationReferral_relations,
-  ext_renewalReferral,
-  ext_renewalReferral_relations,
-  ext_resolverAddressRecords,
-  ext_resolverAddressRecordsRelations,
-  ext_resolverRecords_resolver_relations,
-  ext_resolverRelations_domain_relations,
-  ext_resolverRelations_resolver_relations,
-  ext_resolverTextRecords,
-  ext_resolverTextRecordsRelations,
-  fusesSet,
-  fusesSetRelations,
-  interfaceChanged,
-  interfaceChangedRelations,
-  multicoinAddrChanged,
-  multicoinAddrChangedRelations,
-  nameChanged,
-  nameChangedRelations,
-  nameRegistered,
-  nameRegisteredRelations,
-  nameRenewed,
-  nameRenewedRelations,
-  nameTransferred,
-  nameTransferredRelations,
-  nameUnwrapped,
-  nameUnwrappedRelations,
-  nameWrapped,
-  nameWrappedRelations,
-  newOwner,
-  newOwnerRelations,
-  newResolver,
-  newResolverRelations,
-  newTTL,
-  newTTLRelations,
-  pubkeyChanged,
-  pubkeyChangedRelations,
-  registration,
-  registrationRelations,
-  resolver,
-  resolverRelations,
-  textChanged,
-  textChangedRelations,
-  transfer,
-  transferRelations,
-  versionChanged,
-  versionChangedRelations,
-  wrappedDomain,
-  wrappedDomainRelations,
-  wrappedTransfer,
-  wrappedTransferRelations
+  internal_registrarActionMetadata,
+  migratedNode,
+  nameSales,
+  nameTokens,
+  nodeResolverRelation,
+  registrarActionRelations,
+  registrarActionType,
+  registrarActions,
+  registrationLifecycleRelations,
+  registrationLifecycles,
+  resolverAddressRecord,
+  resolverAddressRecordRelations,
+  resolverRecords,
+  resolverRecords_relations,
+  resolverTextRecord,
+  resolverTextRecordRelations,
+  reverseNameRecord,
+  subgraph_abiChanged,
+  subgraph_abiChangedRelations,
+  subgraph_account,
+  subgraph_accountRelations,
+  subgraph_addrChanged,
+  subgraph_addrChangedRelations,
+  subgraph_authorisationChanged,
+  subgraph_authorisationChangedRelations,
+  subgraph_contenthashChanged,
+  subgraph_contenthashChangedRelations,
+  subgraph_domain,
+  subgraph_domainRelations,
+  subgraph_expiryExtended,
+  subgraph_expiryExtendedRelations,
+  subgraph_fusesSet,
+  subgraph_fusesSetRelations,
+  subgraph_interfaceChanged,
+  subgraph_interfaceChangedRelations,
+  subgraph_multicoinAddrChanged,
+  subgraph_multicoinAddrChangedRelations,
+  subgraph_nameChanged,
+  subgraph_nameChangedRelations,
+  subgraph_nameRegistered,
+  subgraph_nameRegisteredRelations,
+  subgraph_nameRenewed,
+  subgraph_nameRenewedRelations,
+  subgraph_nameTransferred,
+  subgraph_nameTransferredRelations,
+  subgraph_nameUnwrapped,
+  subgraph_nameUnwrappedRelations,
+  subgraph_nameWrapped,
+  subgraph_nameWrappedRelations,
+  subgraph_newOwner,
+  subgraph_newOwnerRelations,
+  subgraph_newResolver,
+  subgraph_newResolverRelations,
+  subgraph_newTTL,
+  subgraph_newTTLRelations,
+  subgraph_pubkeyChanged,
+  subgraph_pubkeyChangedRelations,
+  subgraph_registration,
+  subgraph_registrationRelations,
+  subgraph_resolver,
+  subgraph_resolverRelations,
+  subgraph_textChanged,
+  subgraph_textChangedRelations,
+  subgraph_transfer,
+  subgraph_transferRelations,
+  subgraph_versionChanged,
+  subgraph_versionChangedRelations,
+  subgraph_wrappedDomain,
+  subgraph_wrappedDomainRelations,
+  subgraph_wrappedTransfer,
+  subgraph_wrappedTransferRelations,
+  subregistries,
+  subregistryRelations
 };
 //# sourceMappingURL=ponder.schema.js.map