@ensnode/ensnode-schema 0.34.0 → 0.36.0

package/dist/ponder.schema.js

@@ -1,7 +1,7 @@
-// src/subgraph.schema.ts
+// src/schemas/subgraph.schema.ts
 import { index, onchainTable, relations } from "ponder";
 
-// src/collate.ts
+// src/lib/collate.ts
 function monkeypatchCollate(col, collation) {
   col.getSQLType = function() {
     return Object.getPrototypeOf(this).getSQLType.call(this) + " COLLATE " + collation;
@@ -9,90 +9,140 @@ function monkeypatchCollate(col, 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, if known. Unknown portions replaced with hash in square brackets (eg, foo.[1234].eth)
-  name: t.text(),
-  // The human readable label name (imported from CSV), if known
-  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]
-  }),
-  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]
-  }),
-  subdomains: many(domain, { relationName: "parent" }),
-  registrant: one(account, {
-    fields: [domain.registrantId],
-    references: [account.id]
-  }),
-  wrappedOwner: one(account, {
-    fields: [domain.wrappedOwnerId],
-    references: [account.id]
-  }),
-  wrappedDomain: one(wrappedDomain, {
-    fields: [domain.id],
-    references: [wrappedDomain.domainId]
-  }),
-  registration: one(registration, {
-    fields: [domain.id],
-    references: [registration.domainId]
+// src/schemas/subgraph.schema.ts
+var subgraph_domain = onchainTable(
+  "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: index().on(t.labelhash),
+    byParentId: index().on(t.parentId),
+    byOwnerId: index().on(t.ownerId),
+    byRegistrantId: index().on(t.registrantId),
+    byWrappedOwnerId: index().on(t.wrappedOwnerId)
+  })
+);
+monkeypatchCollate(subgraph_domain.name, '"C"');
+monkeypatchCollate(subgraph_domain.labelName, '"C"');
+var subgraph_domainRelations = relations(subgraph_domain, ({ one, many }) => ({
+  resolvedAddress: one(subgraph_account, {
+    fields: [subgraph_domain.resolvedAddressId],
+    references: [subgraph_account.id]
+  }),
+  owner: one(subgraph_account, {
+    fields: [subgraph_domain.ownerId],
+    references: [subgraph_account.id]
+  }),
+  parent: one(subgraph_domain, {
+    fields: [subgraph_domain.parentId],
+    references: [subgraph_domain.id]
+  }),
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_domain.resolverId],
+    references: [subgraph_resolver.id]
+  }),
+  subdomains: many(subgraph_domain, { relationName: "parent" }),
+  registrant: one(subgraph_account, {
+    fields: [subgraph_domain.registrantId],
+    references: [subgraph_account.id]
+  }),
+  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 = onchainTable("subgraph_accounts", (t) => ({
   id: t.hex().primaryKey()
 }));
-var accountRelations = relations(account, ({ many }) => ({
-  domains: many(domain),
-  wrappedDomains: many(wrappedDomain),
-  registrations: many(registration)
+var subgraph_accountRelations = relations(subgraph_account, ({ many }) => ({
+  domains: many(subgraph_domain),
+  wrappedDomains: many(subgraph_wrappedDomain),
+  registrations: many(subgraph_registration)
 }));
-var resolver = onchainTable(
-  "resolvers",
+var subgraph_resolver = onchainTable(
+  "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(),
@@ -109,33 +159,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(),
-    // NOTE(resolver-records): include the value of the reverse-resolution name() record
-    // https://docs.ens.domains/ensip/3
-    // NOTE: this is the sanitized name record value with  (see @/lib/sanitize-name-record)
-    name: t.text()
+    coinTypes: t.bigint().array()
   }),
   (t) => ({
-    idx: index().on(t.domainId)
+    byDomainId: index().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 = relations(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 = onchainTable(
+  "subgraph_registrations",
   (t) => ({
     // The unique identifier of the registration
     id: t.hex().primaryKey(),
@@ -149,29 +201,48 @@ var registration = onchainTable(
     cost: t.bigint(),
     // The account that registered the domain
     registrantId: t.hex().notNull(),
-    // The human-readable label name associated with the domain registration
+    /**
+     * The Label associated with the domain registration.
+     *
+     * 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) 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, 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
+     */
     labelName: t.text()
   }),
   (t) => ({
-    idx: index().on(t.domainId)
+    byDomainId: index().on(t.domainId),
+    byRegistrationDate: index().on(t.registrationDate)
   })
 );
-var registrationRelations = relations(registration, ({ one, many }) => ({
-  domain: one(domain, {
-    fields: [registration.domainId],
-    references: [domain.id]
+var subgraph_registrationRelations = relations(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 = onchainTable(
+  "subgraph_wrapped_domains",
   (t) => ({
     // The unique identifier for each instance of the WrappedDomain entity
     id: t.hex().primaryKey(),
@@ -183,21 +254,36 @@ var wrappedDomain = onchainTable(
     fuses: t.integer().notNull(),
     // The account that owns this WrappedDomain
     ownerId: t.hex().notNull(),
-    // The name of the wrapped domain
+    /**
+     * 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`.
+     *
+     * 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#subgraph-indexability--labelname-interpretation
+     *
+     * 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#interpreted-name
+     */
     name: t.text()
   }),
   (t) => ({
-    idx: index().on(t.domainId)
+    byDomainId: index().on(t.domainId)
   })
 );
-var wrappedDomainRelations = relations(wrappedDomain, ({ one }) => ({
-  domain: one(domain, {
-    fields: [wrappedDomain.domainId],
-    references: [domain.id]
+var subgraph_wrappedDomainRelations = relations(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) => ({
@@ -215,16 +301,16 @@ var domainEventIndex = (t) => ({
   // sorting index
   idx_compound: index().on(t.domainId, t.id)
 });
-var transfer = onchainTable(
-  "transfers",
+var subgraph_transfer = onchainTable(
+  "subgraph_transfers",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull()
   }),
   domainEventIndex
 );
-var newOwner = onchainTable(
-  "new_owners",
+var subgraph_newOwner = onchainTable(
+  "subgraph_new_owners",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull(),
@@ -232,32 +318,32 @@ var newOwner = onchainTable(
   }),
   domainEventIndex
 );
-var newResolver = onchainTable(
-  "new_resolvers",
+var subgraph_newResolver = onchainTable(
+  "subgraph_new_resolvers",
   (t) => ({
     ...domainEvent(t),
     resolverId: t.text().notNull()
   }),
   domainEventIndex
 );
-var newTTL = onchainTable(
-  "new_ttls",
+var subgraph_newTTL = onchainTable(
+  "subgraph_new_ttls",
   (t) => ({
     ...domainEvent(t),
     ttl: t.bigint().notNull()
   }),
   domainEventIndex
 );
-var wrappedTransfer = onchainTable(
-  "wrapped_transfers",
+var subgraph_wrappedTransfer = onchainTable(
+  "subgraph_wrapped_transfers",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull()
   }),
   domainEventIndex
 );
-var nameWrapped = onchainTable(
-  "name_wrapped",
+var subgraph_nameWrapped = onchainTable(
+  "subgraph_name_wrapped",
   (t) => ({
     ...domainEvent(t),
     name: t.text(),
@@ -267,24 +353,24 @@ var nameWrapped = onchainTable(
   }),
   domainEventIndex
 );
-var nameUnwrapped = onchainTable(
-  "name_unwrapped",
+var subgraph_nameUnwrapped = onchainTable(
+  "subgraph_name_unwrapped",
   (t) => ({
     ...domainEvent(t),
     ownerId: t.hex().notNull()
   }),
   domainEventIndex
 );
-var fusesSet = onchainTable(
-  "fuses_set",
+var subgraph_fusesSet = onchainTable(
+  "subgraph_fuses_set",
   (t) => ({
     ...domainEvent(t),
     fuses: t.integer().notNull()
   }),
   domainEventIndex
 );
-var expiryExtended = onchainTable(
-  "expiry_extended",
+var subgraph_expiryExtended = onchainTable(
+  "subgraph_expiry_extended",
   (t) => ({
     ...domainEvent(t),
     expiryDate: t.bigint().notNull()
@@ -301,8 +387,8 @@ var registrationEventIndex = (t) => ({
   // sorting index
   idx_compound: index().on(t.registrationId, t.id)
 });
-var nameRegistered = onchainTable(
-  "name_registered",
+var subgraph_nameRegistered = onchainTable(
+  "subgraph_name_registered",
   (t) => ({
     ...registrationEvent(t),
     registrantId: t.hex().notNull(),
@@ -310,16 +396,16 @@ var nameRegistered = onchainTable(
   }),
   registrationEventIndex
 );
-var nameRenewed = onchainTable(
-  "name_renewed",
+var subgraph_nameRenewed = onchainTable(
+  "subgraph_name_renewed",
   (t) => ({
     ...registrationEvent(t),
     expiryDate: t.bigint().notNull()
   }),
   registrationEventIndex
 );
-var nameTransferred = onchainTable(
-  "name_transferred",
+var subgraph_nameTransferred = onchainTable(
+  "subgraph_name_transferred",
   (t) => ({
     ...registrationEvent(t),
     newOwnerId: t.hex().notNull()
@@ -336,16 +422,16 @@ var resolverEventIndex = (t) => ({
   // sorting index
   idx_compound: index().on(t.resolverId, t.id)
 });
-var addrChanged = onchainTable(
-  "addr_changed",
+var subgraph_addrChanged = onchainTable(
+  "subgraph_addr_changed",
   (t) => ({
     ...resolverEvent(t),
     addrId: t.hex().notNull()
   }),
   resolverEventIndex
 );
-var multicoinAddrChanged = onchainTable(
-  "multicoin_addr_changed",
+var subgraph_multicoinAddrChanged = onchainTable(
+  "subgraph_multicoin_addr_changed",
   (t) => ({
     ...resolverEvent(t),
     coinType: t.bigint().notNull(),
@@ -353,24 +439,24 @@ var multicoinAddrChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var nameChanged = onchainTable(
-  "name_changed",
+var subgraph_nameChanged = onchainTable(
+  "subgraph_name_changed",
   (t) => ({
     ...resolverEvent(t),
     name: t.text().notNull()
   }),
   resolverEventIndex
 );
-var abiChanged = onchainTable(
-  "abi_changed",
+var subgraph_abiChanged = onchainTable(
+  "subgraph_abi_changed",
   (t) => ({
     ...resolverEvent(t),
     contentType: t.bigint().notNull()
   }),
   resolverEventIndex
 );
-var pubkeyChanged = onchainTable(
-  "pubkey_changed",
+var subgraph_pubkeyChanged = onchainTable(
+  "subgraph_pubkey_changed",
   (t) => ({
     ...resolverEvent(t),
     x: t.hex().notNull(),
@@ -378,8 +464,8 @@ var pubkeyChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var textChanged = onchainTable(
-  "text_changed",
+var subgraph_textChanged = onchainTable(
+  "subgraph_text_changed",
   (t) => ({
     ...resolverEvent(t),
     key: t.text().notNull(),
@@ -387,16 +473,16 @@ var textChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var contenthashChanged = onchainTable(
-  "contenthash_changed",
+var subgraph_contenthashChanged = onchainTable(
+  "subgraph_contenthash_changed",
   (t) => ({
     ...resolverEvent(t),
     hash: t.hex().notNull()
   }),
   resolverEventIndex
 );
-var interfaceChanged = onchainTable(
-  "interface_changed",
+var subgraph_interfaceChanged = onchainTable(
+  "subgraph_interface_changed",
   (t) => ({
     ...resolverEvent(t),
     interfaceID: t.hex().notNull(),
@@ -404,8 +490,8 @@ var interfaceChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var authorisationChanged = onchainTable(
-  "authorisation_changed",
+var subgraph_authorisationChanged = onchainTable(
+  "subgraph_authorisation_changed",
   (t) => ({
     ...resolverEvent(t),
     owner: t.hex().notNull(),
@@ -414,229 +500,410 @@ var authorisationChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var versionChanged = onchainTable(
-  "version_changed",
+var subgraph_versionChanged = onchainTable(
+  "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 subgraph_transferRelations = relations(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 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 subgraph_newOwnerRelations = relations(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 newResolverRelations = relations(newResolver, ({ one }) => ({
-  domain: one(domain, {
-    fields: [newResolver.domainId],
-    references: [domain.id]
+var subgraph_newResolverRelations = relations(subgraph_newResolver, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newResolver.domainId],
+    references: [subgraph_domain.id]
   }),
-  resolver: one(resolver, {
-    fields: [newResolver.resolverId],
-    references: [resolver.id]
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_newResolver.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var newTTLRelations = relations(newTTL, ({ one }) => ({
-  domain: one(domain, { fields: [newTTL.domainId], references: [domain.id] })
+var subgraph_newTTLRelations = relations(subgraph_newTTL, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_newTTL.domainId],
+    references: [subgraph_domain.id]
+  })
 }));
-var wrappedTransferRelations = relations(wrappedTransfer, ({ one }) => ({
-  domain: one(domain, {
-    fields: [wrappedTransfer.domainId],
-    references: [domain.id]
+var subgraph_wrappedTransferRelations = relations(subgraph_wrappedTransfer, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_wrappedTransfer.domainId],
+    references: [subgraph_domain.id]
   }),
-  owner: one(account, {
-    fields: [wrappedTransfer.ownerId],
-    references: [account.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_wrappedTransfer.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var nameWrappedRelations = relations(nameWrapped, ({ one }) => ({
-  domain: one(domain, {
-    fields: [nameWrapped.domainId],
-    references: [domain.id]
+var subgraph_nameWrappedRelations = relations(subgraph_nameWrapped, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_nameWrapped.domainId],
+    references: [subgraph_domain.id]
   }),
-  owner: one(account, {
-    fields: [nameWrapped.ownerId],
-    references: [account.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_nameWrapped.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var nameUnwrappedRelations = relations(nameUnwrapped, ({ one }) => ({
-  domain: one(domain, {
-    fields: [nameUnwrapped.domainId],
-    references: [domain.id]
+var subgraph_nameUnwrappedRelations = relations(subgraph_nameUnwrapped, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_nameUnwrapped.domainId],
+    references: [subgraph_domain.id]
   }),
-  owner: one(account, {
-    fields: [nameUnwrapped.ownerId],
-    references: [account.id]
+  owner: one(subgraph_account, {
+    fields: [subgraph_nameUnwrapped.ownerId],
+    references: [subgraph_account.id]
   })
 }));
-var fusesSetRelations = relations(fusesSet, ({ one }) => ({
-  domain: one(domain, { fields: [fusesSet.domainId], references: [domain.id] })
+var subgraph_fusesSetRelations = relations(subgraph_fusesSet, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_fusesSet.domainId],
+    references: [subgraph_domain.id]
+  })
 }));
-var expiryExtendedRelations = relations(expiryExtended, ({ one }) => ({
-  domain: one(domain, {
-    fields: [expiryExtended.domainId],
-    references: [domain.id]
+var subgraph_expiryExtendedRelations = relations(subgraph_expiryExtended, ({ one }) => ({
+  domain: one(subgraph_domain, {
+    fields: [subgraph_expiryExtended.domainId],
+    references: [subgraph_domain.id]
   })
 }));
-var nameRegisteredRelations = relations(nameRegistered, ({ one }) => ({
-  registration: one(registration, {
-    fields: [nameRegistered.registrationId],
-    references: [registration.id]
+var subgraph_nameRegisteredRelations = relations(subgraph_nameRegistered, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameRegistered.registrationId],
+    references: [subgraph_registration.id]
   }),
-  registrant: one(account, {
-    fields: [nameRegistered.registrantId],
-    references: [account.id]
+  registrant: one(subgraph_account, {
+    fields: [subgraph_nameRegistered.registrantId],
+    references: [subgraph_account.id]
   })
 }));
-var nameRenewedRelations = relations(nameRenewed, ({ one }) => ({
-  registration: one(registration, {
-    fields: [nameRenewed.registrationId],
-    references: [registration.id]
+var subgraph_nameRenewedRelations = relations(subgraph_nameRenewed, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameRenewed.registrationId],
+    references: [subgraph_registration.id]
   })
 }));
-var nameTransferredRelations = relations(nameTransferred, ({ one }) => ({
-  registration: one(registration, {
-    fields: [nameTransferred.registrationId],
-    references: [registration.id]
+var subgraph_nameTransferredRelations = relations(subgraph_nameTransferred, ({ one }) => ({
+  registration: one(subgraph_registration, {
+    fields: [subgraph_nameTransferred.registrationId],
+    references: [subgraph_registration.id]
   }),
-  newOwner: one(account, {
-    fields: [nameTransferred.newOwnerId],
-    references: [account.id]
+  newOwner: one(subgraph_account, {
+    fields: [subgraph_nameTransferred.newOwnerId],
+    references: [subgraph_account.id]
   })
 }));
-var addrChangedRelations = relations(addrChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [addrChanged.resolverId],
-    references: [resolver.id]
+var subgraph_addrChangedRelations = relations(subgraph_addrChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_addrChanged.resolverId],
+    references: [subgraph_resolver.id]
   }),
-  addr: one(account, {
-    fields: [addrChanged.addrId],
-    references: [account.id]
+  addr: one(subgraph_account, {
+    fields: [subgraph_addrChanged.addrId],
+    references: [subgraph_account.id]
   })
 }));
-var multicoinAddrChangedRelations = relations(multicoinAddrChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [multicoinAddrChanged.resolverId],
-    references: [resolver.id]
+var subgraph_multicoinAddrChangedRelations = relations(
+  subgraph_multicoinAddrChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_multicoinAddrChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
   })
-}));
-var nameChangedRelations = relations(nameChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [nameChanged.resolverId],
-    references: [resolver.id]
+);
+var subgraph_nameChangedRelations = relations(subgraph_nameChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_nameChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var abiChangedRelations = relations(abiChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [abiChanged.resolverId],
-    references: [resolver.id]
+var subgraph_abiChangedRelations = relations(subgraph_abiChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_abiChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var pubkeyChangedRelations = relations(pubkeyChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [pubkeyChanged.resolverId],
-    references: [resolver.id]
+var subgraph_pubkeyChangedRelations = relations(subgraph_pubkeyChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_pubkeyChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var textChangedRelations = relations(textChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [textChanged.resolverId],
-    references: [resolver.id]
+var subgraph_textChangedRelations = relations(subgraph_textChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_textChanged.resolverId],
+    references: [subgraph_resolver.id]
   })
 }));
-var contenthashChangedRelations = relations(contenthashChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [contenthashChanged.resolverId],
-    references: [resolver.id]
+var subgraph_contenthashChangedRelations = relations(
+  subgraph_contenthashChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_contenthashChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
   })
-}));
-var interfaceChangedRelations = relations(interfaceChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [interfaceChanged.resolverId],
-    references: [resolver.id]
+);
+var subgraph_interfaceChangedRelations = relations(
+  subgraph_interfaceChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_interfaceChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
   })
-}));
-var authorisationChangedRelations = relations(authorisationChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [authorisationChanged.resolverId],
-    references: [resolver.id]
+);
+var subgraph_authorisationChangedRelations = relations(
+  subgraph_authorisationChanged,
+  ({ one }) => ({
+    resolver: one(subgraph_resolver, {
+      fields: [subgraph_authorisationChanged.resolverId],
+      references: [subgraph_resolver.id]
+    })
   })
-}));
-var versionChangedRelations = relations(versionChanged, ({ one }) => ({
-  resolver: one(resolver, {
-    fields: [versionChanged.resolverId],
-    references: [resolver.id]
+);
+var subgraph_versionChangedRelations = relations(subgraph_versionChanged, ({ one }) => ({
+  resolver: one(subgraph_resolver, {
+    fields: [subgraph_versionChanged.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)
+// src/schemas/protocol-acceleration.schema.ts
+import { onchainTable as onchainTable2, primaryKey, relations as relations2 } from "ponder";
+var reverseNameRecord = onchainTable2(
+  "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 = onchainTable2(
+  "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 = onchainTable2(
+  "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 = relations2(resolverRecords, ({ one, many }) => ({
+  // resolverRecord has many address records
+  addressRecords: many(resolverAddressRecord),
+  // resolverRecord has many text records
+  textRecords: many(resolverTextRecord)
 }));
-var ext_resolverAddressRecords = onchainTable2(
-  "ext_resolver_address_records",
+var resolverAddressRecord = onchainTable2(
+  "resolver_address_records",
   (t) => ({
-    // keyed by (resolverId, coinType)
-    id: t.text().primaryKey(),
-    resolverId: t.text().notNull(),
+    // 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) => ({
-    byResolverIdAndCoinType: uniqueIndex().on(t.resolverId, t.coinType)
+    pk: primaryKey({ columns: [t.chainId, t.resolver, t.node, t.coinType] })
   })
 );
-var ext_resolverAddressRecordsRelations = relations2(
-  ext_resolverAddressRecords,
-  ({ one, many }) => ({
-    // belongs to resolver
-    resolver: one(resolver, {
-      fields: [ext_resolverAddressRecords.resolverId],
-      references: [resolver.id]
-    })
+var resolverAddressRecordRelations = relations2(resolverAddressRecord, ({ one, many }) => ({
+  // belongs to resolverRecord
+  resolver: one(resolverRecords, {
+    fields: [
+      resolverAddressRecord.chainId,
+      resolverAddressRecord.resolver,
+      resolverAddressRecord.node
+    ],
+    references: [resolverRecords.chainId, resolverRecords.resolver, resolverRecords.node]
   })
-);
-var ext_resolverTextRecords = onchainTable2(
-  "ext_resolver_text_records",
+}));
+var resolverTextRecord = onchainTable2(
+  "resolver_trecords",
   (t) => ({
-    // keyed by (resolverId, key)
-    id: t.text().primaryKey(),
-    resolverId: t.text().notNull(),
+    // 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) => ({
-    byResolverIdAndKey: uniqueIndex().on(t.resolverId, t.key)
+    pk: primaryKey({ columns: [t.chainId, t.resolver, t.node, t.key] })
   })
 );
-var ext_resolverTextRecordsRelations = relations2(
-  ext_resolverTextRecords,
-  ({ one, many }) => ({
-    // belongs to resolver
-    resolver: one(resolver, {
-      fields: [ext_resolverTextRecords.resolverId],
-      references: [resolver.id]
-    })
+var resolverTextRecordRelations = relations2(resolverTextRecord, ({ one, many }) => ({
+  // belongs to resolverRecord
+  resolver: one(resolverRecords, {
+    fields: [resolverTextRecord.chainId, resolverTextRecord.resolver, resolverTextRecord.node],
+    references: [resolverRecords.chainId, resolverRecords.resolver, resolverRecords.node]
+  })
+}));
+var migratedNode = onchainTable2("migrated_nodes", (t) => ({
+  node: t.hex().primaryKey()
+}));
+
+// src/schemas/referrals.schema.ts
+import { index as index2, onchainTable as onchainTable3, relations as relations3 } from "ponder";
+var registrationReferral = onchainTable3(
+  "registration_referral",
+  (t) => ({
+    // keyed by any arbitrary unique id, usually `event.id`
+    id: t.text().primaryKey(),
+    referrer: t.hex().notNull(),
+    node: t.hex().notNull(),
+    referee: 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) => ({
+    byReferee: index2().on(t.referee),
+    byReferrer: index2().on(t.referrer)
+  })
+);
+var registrationReferral_relations = relations3(registrationReferral, ({ one, many }) => ({
+  // RegistrationReferral belongs to Referrer
+  referrer: one(referrer, {
+    fields: [registrationReferral.referrer],
+    references: [referrer.id]
+  })
+}));
+var renewalReferral = onchainTable3(
+  "renewal_referral",
+  (t) => ({
+    // keyed by any arbitrary unique id, usually `event.id`
+    id: t.text().primaryKey(),
+    referrer: t.hex().notNull(),
+    referee: t.hex().notNull(),
+    node: t.hex().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) => ({
+    byReferee: index2().on(t.referee),
+    byReferrer: index2().on(t.referrer)
+  })
+);
+var renewalReferral_relations = relations3(renewalReferral, ({ one, many }) => ({
+  // RenewalReferral belongs to Referrer
+  referrer: one(referrer, {
+    fields: [renewalReferral.referrer],
+    references: [referrer.id]
   })
+}));
+var referrer = onchainTable3(
+  "referral_totals",
+  (t) => ({
+    // keyed by Referrer's id (bytes32 hex)
+    id: t.hex().primaryKey(),
+    valueWei: t.bigint().notNull()
+  }),
+  (t) => ({})
 );
+var referrer_relations = relations3(referrer, ({ one, many }) => ({
+  // Referrer has many RegistrationReferrals
+  registrationReferrals: many(registrationReferral),
+  // Referrer has many RenewalReferrals
+  renewalReferrals: many(renewalReferral)
+}));
 
-// src/tokenscope.schema.ts
-import { index as index2, onchainTable as onchainTable3 } from "ponder";
-var 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.
@@ -671,9 +938,9 @@ var nameSales = onchainTable3(
     /**
      * The tokenId managed by contractAddress that was sold.
      *
-     * Interpretation depends on 'assetNamespace':
-     * - erc721: Unique token within contract
-     * - erc1155: Token type identifier (multiple copies may exist)
+     * 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(),
     /**
@@ -690,7 +957,7 @@ var nameSales = onchainTable3(
      */
     assetId: t.text().notNull(),
     /**
-     * The namehash of the ENS domain that was sold.
+     * The namehash (Node) of the ENS domain that was sold.
      */
     domainId: t.hex().notNull(),
     /**
@@ -724,259 +991,168 @@ var 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)
-  })
-);
-
-// 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]
-    })
-  })
-);
-
-// 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]
-    })
+    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_renewalReferral = onchainTable5(
-  "ext_renewal_referral",
+var nameTokens = onchainTable4(
+  "name_tokens",
   (t) => ({
-    // keyed by any arbitrary unique id, usually `event.id`
+    /**
+     * 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(),
-    referrerId: t.hex().notNull(),
-    refereeId: t.hex().notNull(),
-    domainId: t.text().notNull(),
-    cost: t.bigint().notNull(),
-    // chainId the transaction occurred on
+    /**
+     * 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.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(),
-    // NOTE: this is the sanitized name record value (see @/lib/sanitize-name-record)
-    name: t.text().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()
   }),
   (t) => ({
-    byAddressAndCoinType: uniqueIndex3().on(t.address, t.coinType)
+    idx_domainId: index3().on(t.domainId),
+    idx_owner: index3().on(t.owner)
   })
 );
-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_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,
+  migratedNode,
   nameSales,
-  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
+  nameTokens,
+  nodeResolverRelation,
+  referrer,
+  referrer_relations,
+  registrationReferral,
+  registrationReferral_relations,
+  renewalReferral,
+  renewalReferral_relations,
+  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
 };
 //# sourceMappingURL=ponder.schema.js.map