Feat/142 collection stats

.gitignore

@@ -10,3 +10,5 @@
 
 .DS_Store
 dump_*.sql
+
+.env

db/migrations/1681318561000-Data.js

@@ -0,0 +1,19 @@
+module.exports = class Data1681318561000 {
+ name = 'Data1681318561000'
+
+ async up(db) {
+ await db.query(`ALTER TABLE "collection_entity" ADD "distribution" integer NOT NULL DEFAULT '0'`)
+ await db.query(`ALTER TABLE "collection_entity" ADD "floor" numeric NOT NULL DEFAULT '0'`)
+ await db.query(`ALTER TABLE "collection_entity" ADD "highest_sale" numeric NOT NULL DEFAULT '0'`)
+ await db.query(`ALTER TABLE "collection_entity" ADD "owner_count" integer NOT NULL DEFAULT '0'`)
+ await db.query(`ALTER TABLE "collection_entity" ADD "volume" numeric NOT NULL DEFAULT '0'`)
+ }
+
+ async down(db) {
+ await db.query(`ALTER TABLE "collection_entity" DROP COLUMN "distribution"`)
+ await db.query(`ALTER TABLE "collection_entity" DROP COLUMN "floor"`)
+ await db.query(`ALTER TABLE "collection_entity" DROP COLUMN "highest_sale"`)
+ await db.query(`ALTER TABLE "collection_entity" DROP COLUMN "owner_count"`)
+ await db.query(`ALTER TABLE "collection_entity" DROP COLUMN "volume"`)
+ }
+}

schema.graphql

@@ -1,21 +1,26 @@
 type CollectionEntity @entity {
  id: ID!
  blockNumber: BigInt
+ burned: Boolean!
  createdAt: DateTime!
  currentOwner: String!
- burned: Boolean!
+ distribution: Int!
  events: [CollectionEvent!] @derivedFrom(field: "collection")
+ floor: BigInt!
+ highestSale: BigInt!
  image: String
  issuer: String!
  meta: MetadataEntity
  metadata: String
  media: String
  name: String @index
  nfts: [NFTEntity!] @derivedFrom(field: "collection")
+ ownerCount: Int!
  updatedAt: DateTime!
  nftCount: Int!
  supply: Int!
  type: CollectionType!
+ volume: BigInt!
 }
 
 type NFTEntity @entity {

src/mappings/index.ts

@@ -13,7 +13,9 @@ import {
 import { CollectionType } from '../model/generated/_collectionType';
 import { Extrinsic } from '../processable';
 import { plsBe, real, remintable } from './utils/consolidator';
-import { create, get, getOrCreate } from './utils/entity';
+import {
+ calculateCollectionOwnerCountAndDistribution, create, get, getOrCreate,
+} from './utils/entity';
 import { unwrap } from './utils/extract';
 import {
  getAcceptOfferEvent,
@@ -85,15 +87,19 @@ export async function handleCollectionCreate(context: Context): Promise<void> {
 
  final.id = event.id;
  final.issuer = event.caller;
- final.currentOwner = event.caller;
  final.blockNumber = BigInt(event.blockNumber);
- final.metadata = ensureMetadataUri(event.metadata, type);
  final.burned = false;
+ final.currentOwner = event.caller;
+ final.distribution = 0;
+ final.floor = BigInt(0);
+ final.highestSale = BigInt(0);
+ final.metadata = ensureMetadataUri(event.metadata, type);
  final.createdAt = event.timestamp;
  final.updatedAt = event.timestamp;
  final.nftCount = 0;
  final.supply = 0;
  final.type = type;
+ final.volume = BigInt(0);
 
  logger.debug(`metadata: ${final.metadata}`);
 
@@ -153,7 +159,6 @@ export async function handleTokenCreate(context: Context): Promise<void> {
  collection.updatedAt = event.timestamp;
  collection.nftCount += 1;
  collection.supply += 1;
-
  logger.debug(`metadata: ${final.metadata}`);
 
  if (final.metadata) {
@@ -187,10 +192,24 @@ export async function handleTokenTransfer(context: Context): Promise<void> {
  entity.currentOwner = event.to;
  entity.updatedAt = event.timestamp;
 
+ const collection = ensure<CE>(
+ await get<CE>(context.store, CE, event.collectionId),
+ );
+ plsBe(real, collection);
+ const { ownerCount, distribution } = await calculateCollectionOwnerCountAndDistribution(
+ context.store,
+ entity.id,
+ event.to,
+ currentOwner,
+ );
+ collection.ownerCount = ownerCount;
+ collection.distribution = distribution;
+
  logger.success(
  `[SEND] ${id} from ${event.caller} to ${event.to}`,
  );
  await context.store.save(entity);
+ await context.store.save(collection);
  await createEvent(entity, Interaction.SEND, event, event.to || '', context.store, currentOwner);
  await updateCache(event.timestamp, context.store);
 }
@@ -212,6 +231,15 @@ export async function handleTokenBurn(context: Context): Promise<void> {
  collection.updatedAt = event.timestamp;
  collection.supply -= 1;
 
+ const { ownerCount, distribution } = await calculateCollectionOwnerCountAndDistribution(
+ context.store,
+ entity.id,
+ undefined,
+ entity.currentOwner,
+ );
+ collection.ownerCount = ownerCount;
+ collection.distribution = distribution;
+
  await context.store.save(entity);
  await context.store.save(collection);
  const meta = entity.metadata ?? '';
@@ -228,8 +256,16 @@ export async function handleTokenList(context: Context): Promise<void> {
  plsBe(real, entity);
 
  entity.price = event.price;
+
+ const collection = ensure<CE>(await get<CE>(context.store, CE, event.collectionId));
+ plsBe(real, collection);
+ if (event.price && event.price < collection.floor) {
+ collection.floor = event.price;
+ }
+
  logger.success(`[LIST] ${id} by ${event.caller}} for ${String(event.price)}`);
  await context.store.save(entity);
+ await context.store.save(collection);
  const meta = String(event.price || '');
  const interaction = event.price ? Interaction.LIST : Interaction.UNLIST;
  await createEvent(entity, interaction, event, meta, context.store);
@@ -242,14 +278,28 @@ export async function handleTokenBuy(context: Context): Promise<void> {
  const id = createTokenId(event.collectionId, event.sn);
  const entity = ensure<NE>(await get(context.store, NE, id));
  plsBe(real, entity);
+ const { currentOwner } = entity;
  entity.price = BigInt(0);
  entity.currentOwner = event.caller;
  entity.updatedAt = event.timestamp;
 
  const collection = ensure<CE>(await get<CE>(context.store, CE, event.collectionId));
  plsBe(real, collection);
+ collection.volume += event.price || BigInt(0);
+ if (event.price && collection.highestSale < event.price) {
+ collection.highestSale = event.price;
+ }
  collection.updatedAt = event.timestamp;
 
+ const { ownerCount, distribution } = await calculateCollectionOwnerCountAndDistribution(
+ context.store,
+ entity.id,
+ event.caller,
+ currentOwner,
+ );
+ collection.ownerCount = ownerCount;
+ collection.distribution = distribution;
+
  logger.success(`[BUY] ${id} by ${event.caller}`);
  await context.store.save(entity);
  await context.store.save(collection);

src/mappings/utils/entity.ts

@@ -72,3 +72,36 @@ export function create<T extends EntityWithId>(
  Object.assign(entity, init);
  return entity;
 }
+
+export async function calculateCollectionOwnerCountAndDistribution(
+ store: Store,
+ collectionId: string,
+ newOwner?: string,
+ originalOwner?: string,
+): Promise<{ ownerCount: number; distribution: number }> {
+ const query = `
+ SELECT COUNT(DISTINCT current_owner) AS distribution,
+ COUNT(current_owner) AS owner_count
+ ${
+ newOwner
+ && `
+ ,(SELECT max(CASE
+ WHEN current_owner = '${newOwner}' THEN 0
+ ELSE 1
+ END)
+ FROM nft_entity) AS adjustment
+ `
+} 
+ FROM nft_entity
+ WHERE collection_id = '${collectionId}'
+ ${newOwner && `AND current_owner != '${originalOwner}'`}
+ `;
+ const [result]: { owner_count: number; distribution: number; adjustment?: number }[] = await store.query(query);
+
+ const adjustedResults = {
+ ownerCount: result.owner_count - (result.adjustment ?? 0),
+ distribution: result.distribution - (result.adjustment ?? 0),
+ };
+
+ return adjustedResults;
+}

src/mappings/utils/helper.ts

@@ -1,7 +1,7 @@
 import * as ss58 from '@subsquid/ss58';
 import { decodeHex } from '@subsquid/substrate-processor';
 import { Event } from '../../processable';
-import { Context, SomethingWithOptionalMeta } from './types';
+import { Context, SomethingWithOptionalMeta, Store } from './types';
 
 export function isEmpty(obj: Record<string, unknown>): boolean {
  // eslint-disable-next-line guard-for-in, @typescript-eslint/naming-convention

src/model/generated/collectionEntity.model.ts

@@ -17,18 +17,27 @@ export class CollectionEntity {
  @Column_("numeric", {transformer: marshal.bigintTransformer, nullable: true})
  blockNumber!: bigint | undefined | null
 
+ @Column_("bool", {nullable: false})
+ burned!: boolean
+
  @Column_("timestamp with time zone", {nullable: false})
  createdAt!: Date
 
  @Column_("text", {nullable: false})
  currentOwner!: string
 
- @Column_("bool", {nullable: false})
- burned!: boolean
+ @Column_("int4", {nullable: false})
+ distribution!: number
 
  @OneToMany_(() => CollectionEvent, e => e.collection)
  events!: CollectionEvent[]
 
+ @Column_("numeric", {transformer: marshal.bigintTransformer, nullable: false})
+ floor!: bigint
+
+ @Column_("numeric", {transformer: marshal.bigintTransformer, nullable: false})
+ highestSale!: bigint
+
  @Column_("text", {nullable: true})
  image!: string | undefined | null
 
@@ -52,6 +61,9 @@ export class CollectionEntity {
  @OneToMany_(() => NFTEntity, e => e.collection)
  nfts!: NFTEntity[]
 
+ @Column_("int4", {nullable: false})
+ ownerCount!: number
+
  @Column_("timestamp with time zone", {nullable: false})
  updatedAt!: Date
 
@@ -63,4 +75,7 @@ export class CollectionEntity {
 
  @Column_("varchar", {length: 15, nullable: false})
  type!: CollectionType
+
+ @Column_("numeric", {transformer: marshal.bigintTransformer, nullable: false})
+ volume!: bigint
 }

src/model/generated/nftEntity.model.ts

@@ -7,6 +7,9 @@ import {MetadataEntity} from "./metadataEntity.model"
 
 @Entity_()
 export class NFTEntity {
+ static createQueryBuilder(arg0: string) {
+ throw new Error('Method not implemented.')
+ }
  constructor(props?: Partial<NFTEntity>) {
  Object.assign(this, props)
  }