@ensnode/ensnode-schema/dist/ponder.schema.js

The ponder schema for ENSNode

// src/subgraph.schema.ts
import { index, onchainTable, relations } from "ponder";

// src/collate.ts
function monkeypatchCollate(col, collation) {
  col.getSQLType = function() {
    return Object.getPrototypeOf(this).getSQLType.call(this) + " COLLATE " + collation;
  };
  return col;
}

// src/subgraph.schema.ts
var domain = onchainTable("domains", (t) => ({
  // The namehash of the name
  id: t.hex().primaryKey(),
  // The human readable name, 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]
  }),
  // 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)
}));
var account = onchainTable("accounts", (t) => ({
  id: t.hex().primaryKey()
}));
var accountRelations = relations(account, ({ many }) => ({
  domains: many(domain),
  wrappedDomains: many(wrappedDomain),
  registrations: many(registration)
}));
var resolver = onchainTable(
  "resolvers",
  (t) => ({
    // The unique identifier for this resolver, which is a concatenation of the domain namehash and the resolver address
    id: t.text().primaryKey(),
    // The domain that this resolver is associated with
    domainId: t.hex().notNull(),
    // The address of the resolver contract
    address: t.hex().notNull().$type(),
    // The current value of the 'addr' record for this resolver, as determined by the associated events
    addrId: t.hex(),
    // The content hash for this resolver, in binary format
    contentHash: t.text(),
    // The set of observed text record keys for this resolver
    // NOTE: we avoid .notNull.default([]) to match subgraph behavior
    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
    name: t.text()
  }),
  (t) => ({
    idx: 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] }),
  // 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)
}));
var registration = onchainTable(
  "registrations",
  (t) => ({
    // The unique identifier of the registration
    id: t.hex().primaryKey(),
    // The domain name associated with the registration
    domainId: t.hex().notNull(),
    // The registration date of the domain
    registrationDate: t.bigint().notNull(),
    // The expiry date of the domain
    expiryDate: t.bigint().notNull(),
    // The cost associated with the domain registration
    cost: t.bigint(),
    // The account that registered the domain
    registrantId: t.hex().notNull(),
    // The human-readable label name associated with the domain registration
    labelName: t.text()
  }),
  (t) => ({
    idx: index().on(t.domainId)
  })
);
var registrationRelations = relations(registration, ({ one, many }) => ({
  domain: one(domain, {
    fields: [registration.domainId],
    references: [domain.id]
  }),
  registrant: one(account, {
    fields: [registration.registrantId],
    references: [account.id]
  }),
  // event relations
  nameRegistereds: many(nameRegistered),
  nameReneweds: many(nameRenewed),
  nameTransferreds: many(nameTransferred)
}));
var wrappedDomain = onchainTable(
  "wrapped_domains",
  (t) => ({
    // The unique identifier for each instance of the WrappedDomain entity
    id: t.hex().primaryKey(),
    // The domain that is wrapped by this WrappedDomain
    domainId: t.hex().notNull(),
    // The expiry date of the wrapped domain
    expiryDate: t.bigint().notNull(),
    // The number of fuses remaining on the wrapped domain
    fuses: t.integer().notNull(),
    // The account that owns this WrappedDomain
    ownerId: t.hex().notNull(),
    // The name of the wrapped domain
    name: t.text()
  }),
  (t) => ({
    idx: index().on(t.domainId)
  })
);
var wrappedDomainRelations = relations(wrappedDomain, ({ one }) => ({
  domain: one(domain, {
    fields: [wrappedDomain.domainId],
    references: [domain.id]
  }),
  owner: one(account, {
    fields: [wrappedDomain.ownerId],
    references: [account.id]
  })
}));
var sharedEventColumns = (t) => ({
  id: t.text().primaryKey(),
  blockNumber: t.integer().notNull(),
  transactionID: t.hex().notNull()
});
var domainEvent = (t) => ({
  ...sharedEventColumns(t),
  domainId: t.hex().notNull()
});
var domainEventIndex = (t) => ({
  // primary reverse lookup
  idx: index().on(t.domainId),
  // sorting index
  idx_compound: index().on(t.domainId, t.id)
});
var transfer = onchainTable(
  "transfers",
  (t) => ({
    ...domainEvent(t),
    ownerId: t.hex().notNull()
  }),
  domainEventIndex
);
var newOwner = onchainTable(
  "new_owners",
  (t) => ({
    ...domainEvent(t),
    ownerId: t.hex().notNull(),
    parentDomainId: t.hex().notNull()
  }),
  domainEventIndex
);
var newResolver = onchainTable(
  "new_resolvers",
  (t) => ({
    ...domainEvent(t),
    resolverId: t.text().notNull()
  }),
  domainEventIndex
);
var newTTL = onchainTable(
  "new_ttls",
  (t) => ({
    ...domainEvent(t),
    ttl: t.bigint().notNull()
  }),
  domainEventIndex
);
var wrappedTransfer = onchainTable(
  "wrapped_transfers",
  (t) => ({
    ...domainEvent(t),
    ownerId: t.hex().notNull()
  }),
  domainEventIndex
);
var nameWrapped = onchainTable(
  "name_wrapped",
  (t) => ({
    ...domainEvent(t),
    name: t.text(),
    fuses: t.integer().notNull(),
    ownerId: t.hex().notNull(),
    expiryDate: t.bigint().notNull()
  }),
  domainEventIndex
);
var nameUnwrapped = onchainTable(
  "name_unwrapped",
  (t) => ({
    ...domainEvent(t),
    ownerId: t.hex().notNull()
  }),
  domainEventIndex
);
var fusesSet = onchainTable(
  "fuses_set",
  (t) => ({
    ...domainEvent(t),
    fuses: t.integer().notNull()
  }),
  domainEventIndex
);
var expiryExtended = onchainTable(
  "expiry_extended",
  (t) => ({
    ...domainEvent(t),
    expiryDate: t.bigint().notNull()
  }),
  domainEventIndex
);
var registrationEvent = (t) => ({
  ...sharedEventColumns(t),
  registrationId: t.hex().notNull()
});
var registrationEventIndex = (t) => ({
  // primary reverse lookup
  idx: index().on(t.registrationId),
  // sorting index
  idx_compound: index().on(t.registrationId, t.id)
});
var nameRegistered = onchainTable(
  "name_registered",
  (t) => ({
    ...registrationEvent(t),
    registrantId: t.hex().notNull(),
    expiryDate: t.bigint().notNull()
  }),
  registrationEventIndex
);
var nameRenewed = onchainTable(
  "name_renewed",
  (t) => ({
    ...registrationEvent(t),
    expiryDate: t.bigint().notNull()
  }),
  registrationEventIndex
);
var nameTransferred = onchainTable(
  "name_transferred",
  (t) => ({
    ...registrationEvent(t),
    newOwnerId: t.hex().notNull()
  }),
  registrationEventIndex
);
var resolverEvent = (t) => ({
  ...sharedEventColumns(t),
  resolverId: t.text().notNull()
});
var resolverEventIndex = (t) => ({
  // primary reverse lookup
  idx: index().on(t.resolverId),
  // sorting index
  idx_compound: index().on(t.resolverId, t.id)
});
var addrChanged = onchainTable(
  "addr_changed",
  (t) => ({
    ...resolverEvent(t),
    addrId: t.hex().notNull()
  }),
  resolverEventIndex
);
var multicoinAddrChanged = onchainTable(
  "multicoin_addr_changed",
  (t) => ({
    ...resolverEvent(t),
    coinType: t.bigint().notNull(),
    addr: t.hex().notNull()
  }),
  resolverEventIndex
);
var nameChanged = onchainTable(
  "name_changed",
  (t) => ({
    ...resolverEvent(t),
    name: t.text().notNull()
  }),
  resolverEventIndex
);
var abiChanged = onchainTable(
  "abi_changed",
  (t) => ({
    ...resolverEvent(t),
    contentType: t.bigint().notNull()
  }),
  resolverEventIndex
);
var pubkeyChanged = onchainTable(
  "pubkey_changed",
  (t) => ({
    ...resolverEvent(t),
    x: t.hex().notNull(),
    y: t.hex().notNull()
  }),
  resolverEventIndex
);
var textChanged = onchainTable(
  "text_changed",
  (t) => ({
    ...resolverEvent(t),
    key: t.text().notNull(),
    value: t.text()
  }),
  resolverEventIndex
);
var contenthashChanged = onchainTable(
  "contenthash_changed",
  (t) => ({
    ...resolverEvent(t),
    hash: t.hex().notNull()
  }),
  resolverEventIndex
);
var interfaceChanged = onchainTable(
  "interface_changed",
  (t) => ({
    ...resolverEvent(t),
    interfaceID: t.hex().notNull(),
    implementer: t.hex().notNull()
  }),
  resolverEventIndex
);
var authorisationChanged = onchainTable(
  "authorisation_changed",
  (t) => ({
    ...resolverEvent(t),
    owner: t.hex().notNull(),
    target: t.hex().notNull(),
    isAuthorized: t.boolean().notNull()
  }),
  resolverEventIndex
);
var versionChanged = onchainTable(
  "version_changed",
  (t) => ({
    ...resolverEvent(t),
    version: t.bigint().notNull()
  }),
  resolverEventIndex
);
var transferRelations = relations(transfer, ({ one }) => ({
  domain: one(domain, { fields: [transfer.domainId], references: [domain.id] }),
  owner: one(account, { fields: [transfer.ownerId], references: [account.id] })
}));
var newOwnerRelations = relations(newOwner, ({ one }) => ({
  domain: one(domain, { fields: [newOwner.domainId], references: [domain.id] }),
  owner: one(account, { fields: [newOwner.ownerId], references: [account.id] }),
  parentDomain: one(domain, {
    fields: [newOwner.parentDomainId],
    references: [domain.id]
  })
}));
var newResolverRelations = relations(newResolver, ({ one }) => ({
  domain: one(domain, {
    fields: [newResolver.domainId],
    references: [domain.id]
  }),
  resolver: one(resolver, {
    fields: [newResolver.resolverId],
    references: [resolver.id]
  })
}));
var newTTLRelations = relations(newTTL, ({ one }) => ({
  domain: one(domain, { fields: [newTTL.domainId], references: [domain.id] })
}));
var wrappedTransferRelations = relations(wrappedTransfer, ({ one }) => ({
  domain: one(domain, {
    fields: [wrappedTransfer.domainId],
    references: [domain.id]
  }),
  owner: one(account, {
    fields: [wrappedTransfer.ownerId],
    references: [account.id]
  })
}));
var nameWrappedRelations = relations(nameWrapped, ({ one }) => ({
  domain: one(domain, {
    fields: [nameWrapped.domainId],
    references: [domain.id]
  }),
  owner: one(account, {
    fields: [nameWrapped.ownerId],
    references: [account.id]
  })
}));
var nameUnwrappedRelations = relations(nameUnwrapped, ({ one }) => ({
  domain: one(domain, {
    fields: [nameUnwrapped.domainId],
    references: [domain.id]
  }),
  owner: one(account, {
    fields: [nameUnwrapped.ownerId],
    references: [account.id]
  })
}));
var fusesSetRelations = relations(fusesSet, ({ one }) => ({
  domain: one(domain, { fields: [fusesSet.domainId], references: [domain.id] })
}));
var expiryExtendedRelations = relations(expiryExtended, ({ one }) => ({
  domain: one(domain, {
    fields: [expiryExtended.domainId],
    references: [domain.id]
  })
}));
var nameRegisteredRelations = relations(nameRegistered, ({ one }) => ({
  registration: one(registration, {
    fields: [nameRegistered.registrationId],
    references: [registration.id]
  }),
  registrant: one(account, {
    fields: [nameRegistered.registrantId],
    references: [account.id]
  })
}));
var nameRenewedRelations = relations(nameRenewed, ({ one }) => ({
  registration: one(registration, {
    fields: [nameRenewed.registrationId],
    references: [registration.id]
  })
}));
var nameTransferredRelations = relations(nameTransferred, ({ one }) => ({
  registration: one(registration, {
    fields: [nameTransferred.registrationId],
    references: [registration.id]
  }),
  newOwner: one(account, {
    fields: [nameTransferred.newOwnerId],
    references: [account.id]
  })
}));
var addrChangedRelations = relations(addrChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [addrChanged.resolverId],
    references: [resolver.id]
  }),
  addr: one(account, {
    fields: [addrChanged.addrId],
    references: [account.id]
  })
}));
var multicoinAddrChangedRelations = relations(multicoinAddrChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [multicoinAddrChanged.resolverId],
    references: [resolver.id]
  })
}));
var nameChangedRelations = relations(nameChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [nameChanged.resolverId],
    references: [resolver.id]
  })
}));
var abiChangedRelations = relations(abiChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [abiChanged.resolverId],
    references: [resolver.id]
  })
}));
var pubkeyChangedRelations = relations(pubkeyChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [pubkeyChanged.resolverId],
    references: [resolver.id]
  })
}));
var textChangedRelations = relations(textChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [textChanged.resolverId],
    references: [resolver.id]
  })
}));
var contenthashChangedRelations = relations(contenthashChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [contenthashChanged.resolverId],
    references: [resolver.id]
  })
}));
var interfaceChangedRelations = relations(interfaceChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [interfaceChanged.resolverId],
    references: [resolver.id]
  })
}));
var authorisationChangedRelations = relations(authorisationChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [authorisationChanged.resolverId],
    references: [resolver.id]
  })
}));
var versionChangedRelations = relations(versionChanged, ({ one }) => ({
  resolver: one(resolver, {
    fields: [versionChanged.resolverId],
    references: [resolver.id]
  })
}));

// src/resolver-records.schema.ts
import { index as index2, onchainTable as onchainTable2, relations as relations2 } from "ponder";
var ext_resolverRelations = relations2(resolver, ({ one, many }) => ({
  // resolver has many address records
  addressRecords: many(ext_resolverAddressRecords),
  // resolver has many text records
  // NOTE: can't use `texts` because Resolver.texts is used by subgraph schema
  textRecords: many(ext_resolverTextRecords)
}));
var ext_resolverAddressRecords = onchainTable2(
  "ext_resolver_address_records",
  (t) => ({
    // keyed by (resolverId, coinType)
    id: t.text().primaryKey(),
    resolverId: t.text().notNull(),
    coinType: t.bigint().notNull(),
    address: t.text().notNull()
  }),
  (t) => ({
    byCoinType: index2().on(t.id, t.coinType)
  })
);
var ext_resolverAddressRecordsRelations = relations2(
  ext_resolverAddressRecords,
  ({ one, many }) => ({
    // belongs to resolver
    resolver: one(resolver, {
      fields: [ext_resolverAddressRecords.resolverId],
      references: [resolver.id]
    })
  })
);
var ext_resolverTextRecords = onchainTable2(
  "ext_resolver_text_records",
  (t) => ({
    // keyed by (resolverId, key)
    id: t.text().primaryKey(),
    resolverId: t.text().notNull(),
    key: t.text().notNull(),
    value: t.text().notNull()
  }),
  (t) => ({
    byKey: index2().on(t.id, t.key)
  })
);
var ext_resolverTextRecordsRelations = relations2(
  ext_resolverTextRecords,
  ({ one, many }) => ({
    // belongs to resolver
    resolver: one(resolver, {
      fields: [ext_resolverTextRecords.resolverId],
      references: [resolver.id]
    })
  })
);
export {
  abiChanged,
  abiChangedRelations,
  account,
  accountRelations,
  addrChanged,
  addrChangedRelations,
  authorisationChanged,
  authorisationChangedRelations,
  contenthashChanged,
  contenthashChangedRelations,
  domain,
  domainRelations,
  expiryExtended,
  expiryExtendedRelations,
  ext_resolverAddressRecords,
  ext_resolverAddressRecordsRelations,
  ext_resolverRelations,
  ext_resolverTextRecords,
  ext_resolverTextRecordsRelations,
  fusesSet,
  fusesSetRelations,
  interfaceChanged,
  interfaceChangedRelations,
  multicoinAddrChanged,
  multicoinAddrChangedRelations,
  nameChanged,
  nameChangedRelations,
  nameRegistered,
  nameRegisteredRelations,
  nameRenewed,
  nameRenewedRelations,
  nameTransferred,
  nameTransferredRelations,
  nameUnwrapped,
  nameUnwrappedRelations,
  nameWrapped,
  nameWrappedRelations,
  newOwner,
  newOwnerRelations,
  newResolver,
  newResolverRelations,
  newTTL,
  newTTLRelations,
  pubkeyChanged,
  pubkeyChangedRelations,
  registration,
  registrationRelations,
  resolver,
  resolverRelations,
  textChanged,
  textChangedRelations,
  transfer,
  transferRelations,
  versionChanged,
  versionChangedRelations,
  wrappedDomain,
  wrappedDomainRelations,
  wrappedTransfer,
  wrappedTransferRelations
};
//# sourceMappingURL=ponder.schema.js.map