@ensnode/ensnode-schema 0.36.0 → 1.0.1

package/dist/ponder.schema.js

@@ -1,16 +1,495 @@
+// 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/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, onchainTable, relations } from "ponder";
+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/schemas/subgraph.schema.ts
-var subgraph_domain = onchainTable(
+var subgraph_domain = onchainTable3(
   "subgraph_domains",
   (t) => ({
     // The namehash of the name
@@ -79,16 +558,16 @@ var subgraph_domain = onchainTable(
     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)
+    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 = relations(subgraph_domain, ({ one, many }) => ({
+var subgraph_domainRelations = relations3(subgraph_domain, ({ one, many }) => ({
   resolvedAddress: one(subgraph_account, {
     fields: [subgraph_domain.resolvedAddressId],
     references: [subgraph_account.id]
@@ -133,15 +612,15 @@ var subgraph_domainRelations = relations(subgraph_domain, ({ one, many }) => ({
   fusesSets: many(subgraph_fusesSet),
   expiryExtendeds: many(subgraph_expiryExtended)
 }));
-var subgraph_account = onchainTable("subgraph_accounts", (t) => ({
+var subgraph_account = onchainTable3("subgraph_accounts", (t) => ({
   id: t.hex().primaryKey()
 }));
-var subgraph_accountRelations = relations(subgraph_account, ({ many }) => ({
+var subgraph_accountRelations = relations3(subgraph_account, ({ many }) => ({
   domains: many(subgraph_domain),
   wrappedDomains: many(subgraph_wrappedDomain),
   registrations: many(subgraph_registration)
 }));
-var subgraph_resolver = onchainTable(
+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
@@ -162,10 +641,10 @@ var subgraph_resolver = onchainTable(
     coinTypes: t.bigint().array()
   }),
   (t) => ({
-    byDomainId: index().on(t.domainId)
+    byDomainId: index2().on(t.domainId)
   })
 );
-var subgraph_resolverRelations = relations(subgraph_resolver, ({ one, many }) => ({
+var subgraph_resolverRelations = relations3(subgraph_resolver, ({ one, many }) => ({
   addr: one(subgraph_account, {
     fields: [subgraph_resolver.addrId],
     references: [subgraph_account.id]
@@ -186,7 +665,7 @@ var subgraph_resolverRelations = relations(subgraph_resolver, ({ one, many }) =>
   authorisationChangeds: many(subgraph_authorisationChanged),
   versionChangeds: many(subgraph_versionChanged)
 }));
-var subgraph_registration = onchainTable(
+var subgraph_registration = onchainTable3(
   "subgraph_registrations",
   (t) => ({
     // The unique identifier of the registration
@@ -223,11 +702,11 @@ var subgraph_registration = onchainTable(
     labelName: t.text()
   }),
   (t) => ({
-    byDomainId: index().on(t.domainId),
-    byRegistrationDate: index().on(t.registrationDate)
+    byDomainId: index2().on(t.domainId),
+    byRegistrationDate: index2().on(t.registrationDate)
   })
 );
-var subgraph_registrationRelations = relations(subgraph_registration, ({ one, many }) => ({
+var subgraph_registrationRelations = relations3(subgraph_registration, ({ one, many }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_registration.domainId],
     references: [subgraph_domain.id]
@@ -241,7 +720,7 @@ var subgraph_registrationRelations = relations(subgraph_registration, ({ one, ma
   nameReneweds: many(subgraph_nameRenewed),
   nameTransferreds: many(subgraph_nameTransferred)
 }));
-var subgraph_wrappedDomain = onchainTable(
+var subgraph_wrappedDomain = onchainTable3(
   "subgraph_wrapped_domains",
   (t) => ({
     // The unique identifier for each instance of the WrappedDomain entity
@@ -273,10 +752,10 @@ var subgraph_wrappedDomain = onchainTable(
     name: t.text()
   }),
   (t) => ({
-    byDomainId: index().on(t.domainId)
+    byDomainId: index2().on(t.domainId)
   })
 );
-var subgraph_wrappedDomainRelations = relations(subgraph_wrappedDomain, ({ one }) => ({
+var subgraph_wrappedDomainRelations = relations3(subgraph_wrappedDomain, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_wrappedDomain.domainId],
     references: [subgraph_domain.id]
@@ -297,11 +776,11 @@ 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 subgraph_transfer = onchainTable(
+var subgraph_transfer = onchainTable3(
   "subgraph_transfers",
   (t) => ({
     ...domainEvent(t),
@@ -309,7 +788,7 @@ var subgraph_transfer = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_newOwner = onchainTable(
+var subgraph_newOwner = onchainTable3(
   "subgraph_new_owners",
   (t) => ({
     ...domainEvent(t),
@@ -318,7 +797,7 @@ var subgraph_newOwner = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_newResolver = onchainTable(
+var subgraph_newResolver = onchainTable3(
   "subgraph_new_resolvers",
   (t) => ({
     ...domainEvent(t),
@@ -326,7 +805,7 @@ var subgraph_newResolver = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_newTTL = onchainTable(
+var subgraph_newTTL = onchainTable3(
   "subgraph_new_ttls",
   (t) => ({
     ...domainEvent(t),
@@ -334,7 +813,7 @@ var subgraph_newTTL = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_wrappedTransfer = onchainTable(
+var subgraph_wrappedTransfer = onchainTable3(
   "subgraph_wrapped_transfers",
   (t) => ({
     ...domainEvent(t),
@@ -342,7 +821,7 @@ var subgraph_wrappedTransfer = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_nameWrapped = onchainTable(
+var subgraph_nameWrapped = onchainTable3(
   "subgraph_name_wrapped",
   (t) => ({
     ...domainEvent(t),
@@ -353,7 +832,7 @@ var subgraph_nameWrapped = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_nameUnwrapped = onchainTable(
+var subgraph_nameUnwrapped = onchainTable3(
   "subgraph_name_unwrapped",
   (t) => ({
     ...domainEvent(t),
@@ -361,7 +840,7 @@ var subgraph_nameUnwrapped = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_fusesSet = onchainTable(
+var subgraph_fusesSet = onchainTable3(
   "subgraph_fuses_set",
   (t) => ({
     ...domainEvent(t),
@@ -369,7 +848,7 @@ var subgraph_fusesSet = onchainTable(
   }),
   domainEventIndex
 );
-var subgraph_expiryExtended = onchainTable(
+var subgraph_expiryExtended = onchainTable3(
   "subgraph_expiry_extended",
   (t) => ({
     ...domainEvent(t),
@@ -383,11 +862,11 @@ 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 subgraph_nameRegistered = onchainTable(
+var subgraph_nameRegistered = onchainTable3(
   "subgraph_name_registered",
   (t) => ({
     ...registrationEvent(t),
@@ -396,7 +875,7 @@ var subgraph_nameRegistered = onchainTable(
   }),
   registrationEventIndex
 );
-var subgraph_nameRenewed = onchainTable(
+var subgraph_nameRenewed = onchainTable3(
   "subgraph_name_renewed",
   (t) => ({
     ...registrationEvent(t),
@@ -404,7 +883,7 @@ var subgraph_nameRenewed = onchainTable(
   }),
   registrationEventIndex
 );
-var subgraph_nameTransferred = onchainTable(
+var subgraph_nameTransferred = onchainTable3(
   "subgraph_name_transferred",
   (t) => ({
     ...registrationEvent(t),
@@ -418,11 +897,11 @@ 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 subgraph_addrChanged = onchainTable(
+var subgraph_addrChanged = onchainTable3(
   "subgraph_addr_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -430,7 +909,7 @@ var subgraph_addrChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_multicoinAddrChanged = onchainTable(
+var subgraph_multicoinAddrChanged = onchainTable3(
   "subgraph_multicoin_addr_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -439,7 +918,7 @@ var subgraph_multicoinAddrChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_nameChanged = onchainTable(
+var subgraph_nameChanged = onchainTable3(
   "subgraph_name_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -447,7 +926,7 @@ var subgraph_nameChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_abiChanged = onchainTable(
+var subgraph_abiChanged = onchainTable3(
   "subgraph_abi_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -455,7 +934,7 @@ var subgraph_abiChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_pubkeyChanged = onchainTable(
+var subgraph_pubkeyChanged = onchainTable3(
   "subgraph_pubkey_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -464,7 +943,7 @@ var subgraph_pubkeyChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_textChanged = onchainTable(
+var subgraph_textChanged = onchainTable3(
   "subgraph_text_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -473,7 +952,7 @@ var subgraph_textChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_contenthashChanged = onchainTable(
+var subgraph_contenthashChanged = onchainTable3(
   "subgraph_contenthash_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -481,7 +960,7 @@ var subgraph_contenthashChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_interfaceChanged = onchainTable(
+var subgraph_interfaceChanged = onchainTable3(
   "subgraph_interface_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -490,7 +969,7 @@ var subgraph_interfaceChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_authorisationChanged = onchainTable(
+var subgraph_authorisationChanged = onchainTable3(
   "subgraph_authorisation_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -500,7 +979,7 @@ var subgraph_authorisationChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_versionChanged = onchainTable(
+var subgraph_versionChanged = onchainTable3(
   "subgraph_version_changed",
   (t) => ({
     ...resolverEvent(t),
@@ -508,7 +987,7 @@ var subgraph_versionChanged = onchainTable(
   }),
   resolverEventIndex
 );
-var subgraph_transferRelations = relations(subgraph_transfer, ({ one }) => ({
+var subgraph_transferRelations = relations3(subgraph_transfer, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_transfer.domainId],
     references: [subgraph_domain.id]
@@ -518,7 +997,7 @@ var subgraph_transferRelations = relations(subgraph_transfer, ({ one }) => ({
     references: [subgraph_account.id]
   })
 }));
-var subgraph_newOwnerRelations = relations(subgraph_newOwner, ({ one }) => ({
+var subgraph_newOwnerRelations = relations3(subgraph_newOwner, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_newOwner.domainId],
     references: [subgraph_domain.id]
@@ -532,7 +1011,7 @@ var subgraph_newOwnerRelations = relations(subgraph_newOwner, ({ one }) => ({
     references: [subgraph_domain.id]
   })
 }));
-var subgraph_newResolverRelations = relations(subgraph_newResolver, ({ one }) => ({
+var subgraph_newResolverRelations = relations3(subgraph_newResolver, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_newResolver.domainId],
     references: [subgraph_domain.id]
@@ -542,13 +1021,13 @@ var subgraph_newResolverRelations = relations(subgraph_newResolver, ({ one }) =>
     references: [subgraph_resolver.id]
   })
 }));
-var subgraph_newTTLRelations = relations(subgraph_newTTL, ({ one }) => ({
+var subgraph_newTTLRelations = relations3(subgraph_newTTL, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_newTTL.domainId],
     references: [subgraph_domain.id]
   })
 }));
-var subgraph_wrappedTransferRelations = relations(subgraph_wrappedTransfer, ({ one }) => ({
+var subgraph_wrappedTransferRelations = relations3(subgraph_wrappedTransfer, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_wrappedTransfer.domainId],
     references: [subgraph_domain.id]
@@ -558,7 +1037,7 @@ var subgraph_wrappedTransferRelations = relations(subgraph_wrappedTransfer, ({ o
     references: [subgraph_account.id]
   })
 }));
-var subgraph_nameWrappedRelations = relations(subgraph_nameWrapped, ({ one }) => ({
+var subgraph_nameWrappedRelations = relations3(subgraph_nameWrapped, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_nameWrapped.domainId],
     references: [subgraph_domain.id]
@@ -568,7 +1047,7 @@ var subgraph_nameWrappedRelations = relations(subgraph_nameWrapped, ({ one }) =>
     references: [subgraph_account.id]
   })
 }));
-var subgraph_nameUnwrappedRelations = relations(subgraph_nameUnwrapped, ({ one }) => ({
+var subgraph_nameUnwrappedRelations = relations3(subgraph_nameUnwrapped, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_nameUnwrapped.domainId],
     references: [subgraph_domain.id]
@@ -578,19 +1057,19 @@ var subgraph_nameUnwrappedRelations = relations(subgraph_nameUnwrapped, ({ one }
     references: [subgraph_account.id]
   })
 }));
-var subgraph_fusesSetRelations = relations(subgraph_fusesSet, ({ one }) => ({
+var subgraph_fusesSetRelations = relations3(subgraph_fusesSet, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_fusesSet.domainId],
     references: [subgraph_domain.id]
   })
 }));
-var subgraph_expiryExtendedRelations = relations(subgraph_expiryExtended, ({ one }) => ({
+var subgraph_expiryExtendedRelations = relations3(subgraph_expiryExtended, ({ one }) => ({
   domain: one(subgraph_domain, {
     fields: [subgraph_expiryExtended.domainId],
     references: [subgraph_domain.id]
   })
 }));
-var subgraph_nameRegisteredRelations = relations(subgraph_nameRegistered, ({ one }) => ({
+var subgraph_nameRegisteredRelations = relations3(subgraph_nameRegistered, ({ one }) => ({
   registration: one(subgraph_registration, {
     fields: [subgraph_nameRegistered.registrationId],
     references: [subgraph_registration.id]
@@ -600,13 +1079,13 @@ var subgraph_nameRegisteredRelations = relations(subgraph_nameRegistered, ({ one
     references: [subgraph_account.id]
   })
 }));
-var subgraph_nameRenewedRelations = relations(subgraph_nameRenewed, ({ one }) => ({
+var subgraph_nameRenewedRelations = relations3(subgraph_nameRenewed, ({ one }) => ({
   registration: one(subgraph_registration, {
     fields: [subgraph_nameRenewed.registrationId],
     references: [subgraph_registration.id]
   })
 }));
-var subgraph_nameTransferredRelations = relations(subgraph_nameTransferred, ({ one }) => ({
+var subgraph_nameTransferredRelations = relations3(subgraph_nameTransferred, ({ one }) => ({
   registration: one(subgraph_registration, {
     fields: [subgraph_nameTransferred.registrationId],
     references: [subgraph_registration.id]
@@ -616,7 +1095,7 @@ var subgraph_nameTransferredRelations = relations(subgraph_nameTransferred, ({ o
     references: [subgraph_account.id]
   })
 }));
-var subgraph_addrChangedRelations = relations(subgraph_addrChanged, ({ one }) => ({
+var subgraph_addrChangedRelations = relations3(subgraph_addrChanged, ({ one }) => ({
   resolver: one(subgraph_resolver, {
     fields: [subgraph_addrChanged.resolverId],
     references: [subgraph_resolver.id]
@@ -626,7 +1105,7 @@ var subgraph_addrChangedRelations = relations(subgraph_addrChanged, ({ one }) =>
     references: [subgraph_account.id]
   })
 }));
-var subgraph_multicoinAddrChangedRelations = relations(
+var subgraph_multicoinAddrChangedRelations = relations3(
   subgraph_multicoinAddrChanged,
   ({ one }) => ({
     resolver: one(subgraph_resolver, {
@@ -635,31 +1114,31 @@ var subgraph_multicoinAddrChangedRelations = relations(
     })
   })
 );
-var subgraph_nameChangedRelations = relations(subgraph_nameChanged, ({ one }) => ({
+var subgraph_nameChangedRelations = relations3(subgraph_nameChanged, ({ one }) => ({
   resolver: one(subgraph_resolver, {
     fields: [subgraph_nameChanged.resolverId],
     references: [subgraph_resolver.id]
   })
 }));
-var subgraph_abiChangedRelations = relations(subgraph_abiChanged, ({ one }) => ({
+var subgraph_abiChangedRelations = relations3(subgraph_abiChanged, ({ one }) => ({
   resolver: one(subgraph_resolver, {
     fields: [subgraph_abiChanged.resolverId],
     references: [subgraph_resolver.id]
   })
 }));
-var subgraph_pubkeyChangedRelations = relations(subgraph_pubkeyChanged, ({ one }) => ({
+var subgraph_pubkeyChangedRelations = relations3(subgraph_pubkeyChanged, ({ one }) => ({
   resolver: one(subgraph_resolver, {
     fields: [subgraph_pubkeyChanged.resolverId],
     references: [subgraph_resolver.id]
   })
 }));
-var subgraph_textChangedRelations = relations(subgraph_textChanged, ({ one }) => ({
+var subgraph_textChangedRelations = relations3(subgraph_textChanged, ({ one }) => ({
   resolver: one(subgraph_resolver, {
     fields: [subgraph_textChanged.resolverId],
     references: [subgraph_resolver.id]
   })
 }));
-var subgraph_contenthashChangedRelations = relations(
+var subgraph_contenthashChangedRelations = relations3(
   subgraph_contenthashChanged,
   ({ one }) => ({
     resolver: one(subgraph_resolver, {
@@ -668,7 +1147,7 @@ var subgraph_contenthashChangedRelations = relations(
     })
   })
 );
-var subgraph_interfaceChangedRelations = relations(
+var subgraph_interfaceChangedRelations = relations3(
   subgraph_interfaceChanged,
   ({ one }) => ({
     resolver: one(subgraph_resolver, {
@@ -677,7 +1156,7 @@ var subgraph_interfaceChangedRelations = relations(
     })
   })
 );
-var subgraph_authorisationChangedRelations = relations(
+var subgraph_authorisationChangedRelations = relations3(
   subgraph_authorisationChanged,
   ({ one }) => ({
     resolver: one(subgraph_resolver, {
@@ -686,220 +1165,13 @@ var subgraph_authorisationChangedRelations = relations(
     })
   })
 );
-var subgraph_versionChangedRelations = relations(subgraph_versionChanged, ({ one }) => ({
+var subgraph_versionChangedRelations = relations3(subgraph_versionChanged, ({ one }) => ({
   resolver: one(subgraph_resolver, {
     fields: [subgraph_versionChanged.resolverId],
     references: [subgraph_resolver.id]
   })
 }));
 
-// 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 resolverAddressRecord = onchainTable2(
-  "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 = 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 resolverTextRecord = onchainTable2(
-  "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 = 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/schemas/tokenscope.schema.ts
 import { index as index3, onchainTable as onchainTable4 } from "ponder";
 var nameSales = onchainTable4(
@@ -1083,16 +1355,16 @@ var nameTokens = onchainTable4(
   })
 );
 export {
+  internal_registrarActionMetadata,
   migratedNode,
   nameSales,
   nameTokens,
   nodeResolverRelation,
-  referrer,
-  referrer_relations,
-  registrationReferral,
-  registrationReferral_relations,
-  renewalReferral,
-  renewalReferral_relations,
+  registrarActionRelations,
+  registrarActionType,
+  registrarActions,
+  registrationLifecycleRelations,
+  registrationLifecycles,
   resolverAddressRecord,
   resolverAddressRecordRelations,
   resolverRecords,
@@ -1153,6 +1425,8 @@ export {
   subgraph_wrappedDomain,
   subgraph_wrappedDomainRelations,
   subgraph_wrappedTransfer,
-  subgraph_wrappedTransferRelations
+  subgraph_wrappedTransferRelations,
+  subregistries,
+  subregistryRelations
 };
 //# sourceMappingURL=ponder.schema.js.map