Merge pull request #41 from gear-foundation/fix-meta

Fix meta

indexer/src/processing/events.processing.ts

@@ -69,6 +69,9 @@ import { DraftNftApprovedHandler } from './draft-nft/draft-nft-approved.handler'
 import { DraftNftApprovalRevokedHandler } from './draft-nft/draft-nft-approval-revoked.handler';
 import { DraftTransferredHandler } from './draft-nft/draft-transferred.handler';
 import { DraftMeta } from './draft-nft/DraftMeta';
+import { MetadataDeletedHandler } from './nft/metadata-deleted.handler';
+import { MetadataChangedHandler } from './nft/metadata-changed.handler';
+import { ImageLinkChangedHandler } from './nft/img-link-changed.handler';
 
 const marketplaceEventsToHandler: Record<
   NftMarketplaceEventType,
@@ -107,6 +110,9 @@ const nftEventsToHandler: Record<NftEventType, INftEventHandler | undefined> = {
   [NftEventType.ConfigChanged]: new ConfigChangedHandler(),
   [NftEventType.ImageChanged]: new ImageChangedHandler(),
   [NftEventType.MetadataAdded]: new MetadataAddedHandler(),
+  [NftEventType.MetadataDeleted]: new MetadataDeletedHandler(),
+  [NftEventType.MetadataChanged]: new MetadataChangedHandler(),
+  [NftEventType.ImageLinkChanged]: new ImageLinkChangedHandler(),
   [NftEventType.TokenInfoReceived]: undefined,
   [NftEventType.Transferred]: new TransferredHandler(),
   [NftEventType.UserForMintDeleted]: new UserForMintDeletedHandler(),

indexer/src/processing/nft/img-link-changed.handler.ts

@@ -0,0 +1,29 @@
+import { ImageLinkChangedEvent } from '../../types/nft.events';
+import { EntitiesService } from '../entities.service';
+import { INftEventHandler } from './nft.handler';
+import { Nft } from '../../model';
+import { EventInfo } from '../event-info.type';
+
+export class ImageLinkChangedHandler implements INftEventHandler {
+  async handle(
+    event: ImageLinkChangedEvent,
+    { source: collectionAddress, timestamp }: EventInfo,
+    storage: EntitiesService,
+  ): Promise<void> {
+    const { nftId, imgLink } = event;
+    const nft = await storage.getNft(collectionAddress, nftId);
+    if (nft === undefined) {
+      console.warn(
+        `[ImageLinkChangedHandler] ${collectionAddress}-${nftId}: nft is not found`,
+      );
+      return;
+    }
+    await storage.setNft(
+      new Nft({
+        ...nft,
+        mediaUrl: imgLink,
+        updatedAt: timestamp,
+      }),
+    );
+  }
+}

indexer/src/processing/nft/metadata-added.handler.ts

@@ -18,10 +18,12 @@ export class MetadataAddedHandler implements INftEventHandler {
       );
       return;
     }
+    const oldMeta = JSON.parse(nft.metadata || '[]');
+    const newMeta = [...oldMeta, metadata];
     await storage.setNft(
       new Nft({
         ...nft,
-        metadata,
+        metadata: JSON.stringify(newMeta),
         updatedAt: timestamp,
       }),
     );

indexer/src/processing/nft/metadata-changed.handler.ts

@@ -0,0 +1,30 @@
+import { MetadataChangedEvent } from '../../types/nft.events';
+import { EntitiesService } from '../entities.service';
+import { INftEventHandler } from './nft.handler';
+import { Nft } from '../../model';
+import { EventInfo } from '../event-info.type';
+
+export class MetadataChangedHandler implements INftEventHandler {
+  async handle(
+    event: MetadataChangedEvent,
+    { source: collectionAddress, timestamp }: EventInfo,
+    storage: EntitiesService,
+  ): Promise<void> {
+    const { tokenId, metadata } = event;
+    const nft = await storage.getNft(collectionAddress, tokenId);
+    if (nft === undefined) {
+      console.warn(
+        `[MetadataChangedHandler] ${collectionAddress}-${tokenId}: nft is not found`,
+      );
+      return;
+    }
+    const newMeta = metadata;
+    await storage.setNft(
+      new Nft({
+        ...nft,
+        metadata: JSON.stringify(newMeta),
+        updatedAt: timestamp,
+      }),
+    );
+  }
+}

indexer/src/processing/nft/metadata-deleted.handler.ts

@@ -0,0 +1,29 @@
+import { MetadataDeletedEvent } from '../../types/nft.events';
+import { EntitiesService } from '../entities.service';
+import { INftEventHandler } from './nft.handler';
+import { Nft } from '../../model';
+import { EventInfo } from '../event-info.type';
+
+export class MetadataDeletedHandler implements INftEventHandler {
+  async handle(
+    event: MetadataDeletedEvent,
+    { source: collectionAddress, timestamp }: EventInfo,
+    storage: EntitiesService,
+  ): Promise<void> {
+    const { tokenId } = event;
+    const nft = await storage.getNft(collectionAddress, tokenId);
+    if (nft === undefined) {
+      console.warn(
+        `[MetadataDeletedHandler] ${collectionAddress}-${tokenId}: nft is not found`,
+      );
+      return;
+    }
+    await storage.setNft(
+      new Nft({
+        ...nft,
+        metadata: JSON.stringify([]),
+        updatedAt: timestamp,
+      }),
+    );
+  }
+}

indexer/src/processing/nft/nft-minted.handler.ts

@@ -1,7 +1,7 @@
 import { MintedEvent } from '../../types/nft.events';
 import { EntitiesService } from '../entities.service';
 import { INftEventHandler } from './nft.handler';
-import { Nft, Offer } from '../../model';
+import { Nft } from '../../model';
 import { EventInfo } from '../event-info.type';
 
 export class NftMintedHandler implements INftEventHandler {
@@ -18,7 +18,7 @@ export class NftMintedHandler implements INftEventHandler {
       return;
     }
     const { tokenId } = event;
-    let { description, mediaUrl, metadata, name, owner } = event.nftData;
+    const { description, mediaUrl, metadata, name, owner } = event.nftData;
     await storage.setNft(
       new Nft({
         id: `${collection.id}-${tokenId}`,

indexer/src/types/nft.events.ts

@@ -17,6 +17,9 @@ export enum NftEventType {
   ConfigChanged = 'ConfigChanged',
   ImageChanged = 'ImageChanged',
   MetadataAdded = 'MetadataAdded',
+  MetadataChanged = 'MetadataChanged',
+  MetadataDeleted = 'MetadataDeleted',
+  ImageLinkChanged = 'ImageLinkChanged',
   UsersForMintAdded = 'UsersForMintAdded',
   UserForMintDeleted = 'UserForMintDeleted',
   LiftRestrictionMint = 'LiftRestrictionMint',
@@ -131,6 +134,23 @@ export type LiftRestrictionMintEvent = {
   type: NftEventType.LiftRestrictionMint;
 };
 
+export type MetadataChangedEvent = {
+  type: NftEventType.MetadataChanged;
+  tokenId: number;
+  metadata: string[];
+};
+
+export type MetadataDeletedEvent = {
+  type: NftEventType.MetadataDeleted;
+  tokenId: number;
+};
+
+export type ImageLinkChangedEvent = {
+  type: NftEventType.ImageLinkChanged;
+  nftId: number;
+  imgLink: string;
+};
+
 export type NftEvent =
   | TransferEvent
   | TokenInfoReceivedEvent
@@ -144,7 +164,10 @@ export type NftEvent =
   | MetadataAddedEvent
   | UsersForMintAddedEvent
   | UserForMintDeletedEvent
-  | LiftRestrictionMintEvent;
+  | LiftRestrictionMintEvent
+  | MetadataChangedEvent
+  | MetadataDeletedEvent
+  | ImageLinkChangedEvent;
 
 export interface AdditionalLinkPlain {
   externalUrl: Option<Text>;
@@ -219,7 +242,7 @@ export interface NftEventPlain extends Enum {
     imgLink: Text;
   };
   metadataAdded: {
-    tokenId: u64;
+    nftId: u64;
     metadata: Text;
   };
   usersForMintAdded: {
@@ -228,7 +251,18 @@ export interface NftEventPlain extends Enum {
   userForMintDeleted: {
     user: Hash;
   };
-  liftRestrictionMint: {};
+  liftRestrictionMint: Record<string, never>;
+  metadataChanged: {
+    nftId: u64;
+    metadata: Vec<Text>;
+  };
+  metadataDeleted: {
+    nftId: u64;
+  };
+  imageLinkChanged: {
+    nftId: u64;
+    imgLink: Text;
+  };
 }
 
 export function getNftEvent(event: NftEventPlain): NftEvent | undefined {
@@ -401,7 +435,7 @@ export function getNftEvent(event: NftEventPlain): NftEvent | undefined {
   if (event.metadataAdded) {
     return {
       type: NftEventType.MetadataAdded,
-      tokenId: safeUnwrapToNumber(event.metadataAdded.tokenId)!,
+      tokenId: safeUnwrapToNumber(event.metadataAdded.nftId)!,
       metadata: event.metadataAdded.metadata.toString(),
     };
   }
@@ -422,5 +456,25 @@ export function getNftEvent(event: NftEventPlain): NftEvent | undefined {
       type: NftEventType.LiftRestrictionMint,
     };
   }
+  if (event.metadataChanged) {
+    return {
+      type: NftEventType.MetadataChanged,
+      tokenId: safeUnwrapToNumber(event.metadataChanged.nftId)!,
+      metadata: event.metadataChanged.metadata.map((m) => m.toString()),
+    };
+  }
+  if (event.metadataDeleted) {
+    return {
+      type: NftEventType.MetadataDeleted,
+      tokenId: safeUnwrapToNumber(event.metadataDeleted.nftId)!,
+    };
+  }
+  if (event.imageLinkChanged) {
+    return {
+      type: NftEventType.ImageLinkChanged,
+      nftId: safeUnwrapToNumber(event.imageLinkChanged.nftId)!,
+      imgLink: event.imageLinkChanged.imgLink.toString(),
+    };
+  }
   return undefined;
 }