fix: asset metadata updates (#248)

chains-cfg/_root.yaml

@@ -174,4 +174,9 @@ dataSources:
           kind: substrate/EventHandler
           filter:
             module: oraclePriceFeed
-            method: Fed
+            method: Fed
+        - handler: handleAssetMetadataSet
+          kind: substrate/EventHandler
+          filter:
+            module: uniques
+            method: MetadataSet

schema.graphql

@@ -449,8 +449,8 @@ type Asset @entity {
   type: AssetType!
   valuationMethod: AssetValuationMethod!
 
-  collateralNftClassId: BigInt
-  collateralNftItemId: BigInt
+  collateralNftClassId: BigInt @index
+  collateralNftItemId: BigInt @index
 
   metadata: String
   name: String

src/helpers/types.ts

@@ -1,6 +1,6 @@
 //find out types: const a = createType(api.registry, '[u8;32]', 18)
 import { AugmentedCall, AugmentedRpc, PromiseRpcResult } from '@polkadot/api/types'
-import { Enum, Null, Struct, u128, u32, u64, U8aFixed, Option, Vec, Bytes, Result } from '@polkadot/types'
+import { Enum, Null, Struct, u128, u32, u64, U8aFixed, Option, Vec, Bytes, Result, bool } from '@polkadot/types'
 import { AccountId32, Perquintill, Balance } from '@polkadot/types/interfaces'
 import { ITuple, Observable } from '@polkadot/types/types'
 
@@ -480,6 +480,8 @@ export type TokensEndowedDepositedWithdrawnEvent = ITuple<
   [currencyId: TokensCurrencyId, who: AccountId32, amount: u128]
 >
 
+export type UniquesMetadataSetEvent = ITuple<[collection: u64, item: u128, data: Bytes, isFrozen: bool]>
+
 export type PoolFeesProposedEvent = ITuple<[poolId: u64, feeId: u64, bucket: PoolFeeBucket, fee: PoolFeeInfo]>
 export type PoolFeesAddedEvent = ITuple<[poolId: u64, bucket: PoolFeeBucket, feeId: u64, fee: PoolFeeInfo]>
 export type PoolFeesRemovedEvent = ITuple<[poolId: u64, bucket: PoolFeeBucket, feeId: u64]>

src/index.ts

@@ -26,3 +26,4 @@ export * from './mappings/handlers/evmHandlers'
 export * from './mappings/handlers/ethHandlers'
 export * from './mappings/handlers/poolFeesHandlers'
 export * from './mappings/handlers/oracleHandlers'
+export * from './mappings/handlers/uniquesHandlers'

src/mappings/handlers/poolsHandlers.ts

@@ -14,6 +14,7 @@ import { AssetTransactionData, AssetTransactionService } from '../services/asset
 import { substrateStateSnapshotter } from '../../helpers/stateSnapshot'
 import { Pool, PoolSnapshot } from '../../types'
 import { InvestorPositionService } from '../services/investorPositionService'
+import { PoolFeeService } from '../services/poolFeeService'
 
 export const handlePoolCreated = errorHandler(_handlePoolCreated)
 async function _handlePoolCreated(event: SubstrateEvent<PoolCreatedEvent>): Promise<void> {
@@ -41,10 +42,16 @@ async function _handlePoolCreated(event: SubstrateEvent<PoolCreatedEvent>): Prom
     event.block.block.header.number.toNumber()
   )
   await pool.initData()
-  await pool.initIpfsMetadata().catch((err) => {
+  const poolFeesMetadata = await pool.initIpfsMetadata().catch<ReturnType<typeof pool.initIpfsMetadata>>((err) => {
     logger.error(`IPFS Request failed ${err}`)
-    return Promise.resolve()
+    return Promise.resolve([])
   })
+
+  for (const { id: feeId, name } of poolFeesMetadata) {
+    const poolFee = await PoolFeeService.getById(pool.id, feeId.toString(10))
+    await poolFee.setName(name)
+    await poolFee.save()
+  }
   await pool.save()
 
   // Initialise the tranches

src/mappings/handlers/uniquesHandlers.ts

@@ -0,0 +1,27 @@
+import { SubstrateEvent } from '@subql/types'
+import { errorHandler } from '../../helpers/errorHandler'
+import { UniquesMetadataSetEvent } from '../../helpers/types'
+import { AssetService } from '../services/assetService'
+
+export const handleAssetMetadataSet = errorHandler(_handleAssetMetadataSet)
+async function _handleAssetMetadataSet(event: SubstrateEvent<UniquesMetadataSetEvent>) {
+  const [_collectionId, _itemId, _metadata] = event.event.data
+
+  const collectionId = _collectionId.toString(10)
+  const itemId = _itemId.toString(10)
+  const metadata = _metadata.toUtf8()
+
+  logger.info(
+    `uniques.MetadataSet event fired for ${collectionId}:${itemId}` +
+      `at block ${event.block.block.header.number.toNumber()}`
+  )
+
+  const asset = await AssetService.getByNftId(collectionId, itemId)
+  if (!asset) return logger.warn('Corresponding asset not found. Maybe not yet initialised? Skipping...')
+
+  logger.info(`Found corresponding asset ${asset.id}`)
+
+  await asset.setMetadata(metadata)
+  await asset.updateIpfsAssetName()
+  await asset.save()
+}

src/mappings/services/assetService.ts

@@ -84,6 +84,16 @@ export class AssetService extends Asset {
     return asset
   }
 
+  static async getByNftId(collectionId: string, itemId: string) {
+    const asset = (
+      await AssetService.getByFields([
+        ['collateralNftClassId', '=', collectionId],
+        ['collateralNftItemId', '=', itemId],
+      ])
+    ).pop() as AssetService
+    return asset
+  }
+
   public borrow(amount: bigint) {
     logger.info(`Increasing borrowings for asset ${this.id} by ${amount}`)
     this.borrowedAmountByPeriod += amount
@@ -176,6 +186,10 @@ export class AssetService extends Asset {
     return this
   }
 
+  public setMetadata(metadata: string) {
+    this.metadata = metadata
+  }
+
   static extractPrincipalAmount(principalObject: LoanPricingAmount) {
     let principal: bigint
     switch (principalObject.type) {

src/mappings/services/poolFeeService.ts

@@ -115,6 +115,7 @@ export class PoolFeeService extends PoolFee {
   }
 
   public setName(name: string) {
+    logger.info(`Setting name for fee ${this.id} to: ${name}`)
     this.name = name
   }
 

src/mappings/services/poolService.ts

@@ -147,7 +147,7 @@ export class PoolService extends Pool {
     this.metadata = metadata
   }
 
-  public async initIpfsMetadata() {
+  public async initIpfsMetadata(): Promise<PoolIpfsMetadata['pool']['poolFees']> {
     if (!this.metadata) {
       logger.warn('No IPFS metadata')
       return
@@ -157,16 +157,26 @@ export class PoolService extends Pool {
     this.assetClass = metadata.pool.asset.class
     this.assetSubclass = metadata.pool.asset.subClass
     this.icon = metadata.pool.icon.uri
+    return metadata.pool.poolFees ?? []
   }
 
-  public async getIpfsPoolFeeName(poolFeeId: string): Promise<string> {
+  public async getIpfsPoolFeeMetadata(): Promise<PoolIpfsMetadata['pool']['poolFees']> {
     if (!this.metadata) return logger.warn('No IPFS metadata')
     const metadata = await readIpfs<PoolIpfsMetadata>(this.metadata.match(cid)[0])
     if (!metadata.pool.poolFees) {
+      return null
+    }
+    return metadata.pool.poolFees
+  }
+
+  public async getIpfsPoolFeeName(poolFeeId: string): Promise<string> {
+    if (!this.metadata) return logger.warn('No IPFS metadata')
+    const poolFeeMetadata = await this.getIpfsPoolFeeMetadata()
+    if (!poolFeeMetadata) {
       logger.warn('Missing poolFee object in pool metadata!')
       return null
     }
-    return metadata.pool.poolFees.find((elem) => elem.id.toString(10) === poolFeeId)?.name ?? null
+    return poolFeeMetadata.find((elem) => elem.id.toString(10) === poolFeeId)?.name ?? null
   }
 
   static async getById(poolId: string) {