feat: Balance update improved for staking rewards

Author: ipapandinas

project.yaml

@@ -22,23 +22,31 @@ dataSources:
       file: "./dist/index.js"
       handlers:
         # Batch Calls
-        - handler: batchCallHandler
+        - handler: accountUpdateHandler
           kind: substrate/CallHandler
           filter:
             module: utility
             method: batchAll
             success: true
-        - handler: batchCallHandler
+        - handler: accountUpdateHandler
           kind: substrate/CallHandler
           filter:
             module: utility
             method: batch
-        - handler: batchCallHandler
+        - handler: accountUpdateHandler
           kind: substrate/CallHandler
           filter:
             module: utility
             method: forceBatch
 
+        # Staking Calls
+        - handler: accountUpdateHandler
+          kind: substrate/CallHandler
+          filter:
+            module: staking
+            method: payoutStakers
+            success: true
+
         # Balance
         - handler: handleEvent
           kind: substrate/EventHandler

src/callHandlers/batch.ts renamed to src/callHandlers/account.ts

@@ -1,9 +1,9 @@
 import { SubstrateExtrinsic } from "@subql/types"
-import { updateAccount } from "../helpers"
+import { updateAccounts } from "../helpers"
 
 const balanceMethods = ["BalanceSet", "Deposit", "DustLost", "Endowed", "Reserved", "Slashed", "Unreserved", "Withdraw"]
 
-export async function batchCallHandler(extrinsic: SubstrateExtrinsic): Promise<void> {
+export async function accountUpdateHandler(extrinsic: SubstrateExtrinsic): Promise<void> {
   if (!extrinsic.success) {
     return
   }
@@ -23,5 +23,5 @@ export async function batchCallHandler(extrinsic: SubstrateExtrinsic): Promise<v
     }
   }
 
-  await Promise.all(addressStack.map(async (address) => await updateAccount(address)))
+  await updateAccounts(addressStack)
 }

src/callHandlers/index.ts

@@ -1 +1 @@
-export * from "./batch"
+export * from "./account"

src/eventHandlers/balances.ts

@@ -1,16 +1,16 @@
 import { SubstrateEvent } from "@subql/types"
 import { Codec } from "@polkadot/types/types"
 import { Balance } from "@polkadot/types/interfaces"
-import { updateAccount, getCommonEventData, roundPrice, CommonEventData, getSigner } from "../helpers"
+import { updateAccounts, getCommonEventData, roundPrice, CommonEventData, getSigner } from "../helpers"
 import { TransferEntity } from "../types"
 
 export const transferHandler = async (event: SubstrateEvent): Promise<void> => {
   const commonEventData = getCommonEventData(event)
   const signer = getSigner(event)
   const [from, to, amount] = event.event.data
   await genericTransferHandler(from, to, amount, commonEventData)
-  if (from.toString() !== signer) await updateAccount(from.toString())
-  await updateAccount(to.toString())
+  if (from.toString() !== signer) await updateAccounts([from.toString()])
+  await updateAccounts([to.toString()])
 }
 
 export const genericTransferHandler = async (

src/helpers/account.ts

@@ -1,38 +1,41 @@
 import type { AccountInfo } from "@polkadot/types/interfaces"
 
-import { AccountEntity } from "../types/models/AccountEntity"
 import { roundPrice } from "../helpers"
+import { AccountEntity } from "../types"
 
-export const updateAccount = async (user: string) => {
+export const updateAccounts = async (addresses: string[]) => {
   try {
-    const res = await api.query.system.account<AccountInfo>(user)
-    const balance = res.data
-    if (balance) {
-      const { feeFrozen, free, miscFrozen, reserved } = balance
-      const date = new Date()
-      let record = await AccountEntity.get(user)
-      if (record === undefined) {
-        record = new AccountEntity(user)
-        record.createdAt = date
-      }
-      const balanceFrozenFee = feeFrozen.toBigInt()
-      const balanceFrozenMisc = miscFrozen.toBigInt()
-      const balanceReserved = reserved.toBigInt()
-      const balanceFree = free.toBigInt()
-      const frozen = balanceFrozenFee > balanceFrozenMisc ? balanceFrozenMisc : balanceFrozenMisc
-      const total = balanceFree + balanceReserved
-      const transferable = balanceFree - frozen
-      record.capsAmount = transferable.toString()
-      record.capsAmountFrozen = frozen.toString()
-      record.capsAmountTotal = total.toString()
-      record.capsAmountRounded = roundPrice(record.capsAmount)
-      record.capsAmountFrozenRounded = roundPrice(record.capsAmountFrozen)
-      record.capsAmountTotalRounded = roundPrice(record.capsAmountTotal)
-      record.updatedAt = date
-      await record.save()
-    } else {
-      logger.error("Error in update accout : Balance not found")
-    }
+    const res = await api.query.system.account.multi<AccountInfo>(addresses)
+    await Promise.all(
+      res.map(async ({ data: balance }, idx) => {
+        if (balance) {
+          const { free, miscFrozen, reserved } = balance
+          const address = addresses[idx]
+          const date = new Date()
+          const balanceFrozenMisc = miscFrozen.toBigInt()
+          const balanceReserved = reserved.toBigInt()
+          const balanceFree = free.toBigInt()
+          const capsAmountFrozen = balanceFrozenMisc.toString()
+          const capsAmountTotal = (balanceFree + balanceReserved).toString()
+          const capsAmount = (balanceFree - balanceFrozenMisc).toString()
+          let record = await AccountEntity.get(address)
+          if (record === undefined) {
+            record = new AccountEntity(address)
+            record.createdAt = date
+          }
+          record.capsAmount = capsAmount
+          record.capsAmountFrozen = capsAmountFrozen
+          record.capsAmountTotal = capsAmountTotal
+          record.capsAmountRounded = roundPrice(record.capsAmount)
+          record.capsAmountFrozenRounded = roundPrice(record.capsAmountFrozen)
+          record.capsAmountTotalRounded = roundPrice(record.capsAmountTotal)
+          record.updatedAt = date
+          await record.save()
+        } else {
+          logger.error("Error in update accout : Balance not found")
+        }
+      }),
+    )
   } catch (err) {
     logger.error("Error in update accout : " + err.toString())
     if (err.sql) logger.error("Error in update accout : " + JSON.stringify(err.sql))

src/mappings/mappingHandlers.ts

@@ -1,6 +1,6 @@
 import { SubstrateEvent } from "@subql/types"
 import * as eventHandlers from "../eventHandlers"
-import { checkIfAnyBatch, checkIfTransfer, updateAccount } from "../helpers"
+import { checkIfAnyBatch, checkIfTransfer, updateAccounts } from "../helpers"
 
 export async function handleEvent(event: SubstrateEvent): Promise<void> {
   const key = `${event.event.section}.${event.event.method}`
@@ -19,12 +19,12 @@ export async function handleEvent(event: SubstrateEvent): Promise<void> {
         const isTransferCall = event.extrinsic && checkIfTransfer(event.extrinsic)
         if (!isBatchCall && !isTransferCall) {
           const [who] = event.event.data
-          await updateAccount(who.toString())
+          await updateAccounts([who.toString()])
         }
         break
       case "transactionPayment.TransactionFeePaid":
         const [whoPaid] = event.event.data
-        await updateAccount(whoPaid.toString())
+        await updateAccounts([whoPaid.toString()])
         break
       case "balances.Transfer":
         await eventHandlers.transferHandler(event)