Cache all api.query queries

project.yaml

@@ -7,7 +7,7 @@ network:
 dataSources:
   - name: main
     kind: substrate/Runtime
-    startBlock: 8647000
+    startBlock: 0
 
     # polkadot test slash bloks: 3570179
 

src/mappings/NewEra.ts

@@ -1,19 +1,18 @@
 import {SubstrateEvent} from "@subql/types";
-import {eventId} from "./common";
+import {cachedCurrentEra, cachedEraStakers, eventId} from "./common";
 import { EraValidatorInfo } from "../types/models/EraValidatorInfo";
 
 export async function handleNewEra(event: SubstrateEvent): Promise<void> {
-    let eraOption = await api.query.staking.currentEra()
-    let eraIndex = eraOption.unwrap()
+    let currentEra = await cachedCurrentEra(event.block)
 
-    const exposures = await api.query.staking.erasStakers.entries(eraIndex);
+    const exposures = await cachedEraStakers(currentEra.toNumber());
 
     let eraValidatorInfos = exposures.map(([key, exposure]) => {
         const [, validatorId] = key.args
 
         let validatorIdString = validatorId.toString()
         const eraValidatorInfo = new EraValidatorInfo(eventId(event)+validatorIdString)
-        eraValidatorInfo.era = eraIndex.toNumber()
+        eraValidatorInfo.era = currentEra.toNumber()
         eraValidatorInfo.address = validatorIdString
         eraValidatorInfo.total = exposure.total.toString()
         eraValidatorInfo.own = exposure.own.toString()
@@ -27,4 +26,4 @@ export async function handleNewEra(event: SubstrateEvent): Promise<void> {
     })
 
     await Promise.allSettled(eraValidatorInfos)
-}
+}

src/mappings/Rewards.ts

@@ -7,7 +7,9 @@ import {
     timestamp,
     eventId,
     isProxy,
-    callFromProxy
+    callFromProxy,
+    cachedCurrentEra,
+    cachedEraStakers
 } from "./common";
 import {CallBase} from "@polkadot/types/types/calls";
 import {AnyTuple} from "@polkadot/types/types/codec";
@@ -147,12 +149,12 @@ async function handleSlashForTxHistory(slashEvent: SubstrateEvent): Promise<void
         return;
     }
 
-    const currentEra = (await api.query.staking.currentEra()).unwrap();
+    const currentEra = await cachedCurrentEra(slashEvent.block);
     const slashDefferDuration = api.consts.staking.slashDeferDuration
 
     const slashEra = currentEra.toNumber() - slashDefferDuration.toNumber()
 
-    const eraStakersInSlashEra = await api.query.staking.erasStakers.entries(slashEra);
+    const eraStakersInSlashEra = await cachedEraStakers(slashEra);
     const validatorsInSlashEra = eraStakersInSlashEra.map(([key, exposure]) => {
         let [, validatorId] = key.args
 

src/mappings/StakeChanged.ts

@@ -1,6 +1,6 @@
 import {SubstrateEvent} from "@subql/types";
 import {AccumulatedStake, StakeChange} from "../types";
-import {eventId, timestamp} from "./common";
+import {blockNumber, eventId, timestamp} from "./common";
 import {Balance} from "@polkadot/types/interfaces";
 import {RewardDestination} from "@polkadot/types/interfaces/staking";
 
@@ -55,11 +55,51 @@ export async function handleSlashForAnalytics(event: SubstrateEvent): Promise<vo
     await element.save()
 }
 
+let rewardDestinationByAddress: {[blockId: string]: {[address: string]: RewardDestination}} = {}
+
+async function cachedRewardDestination(accountAddress: string, event: SubstrateEvent): Promise<RewardDestination> {
+    const blockId = blockNumber(event)
+    let cachedBlock = rewardDestinationByAddress[blockId]
+
+    if (cachedBlock !== undefined) {
+        return cachedBlock[accountAddress]
+    } else {
+        const allAccountsInBlock = event.block.events
+            .filter(event => { 
+                return event.event.method == "Reward" && event.event.section == "staking"
+            })
+            .map(event => { 
+                let {event: {data: [accountId, ]}} = event
+                return accountId
+            });
+
+        const payees = await api.query.staking.payee.multi(allAccountsInBlock);
+        const rewardDestinations = payees.map(payee => { return payee as RewardDestination });
+
+        let destinationByAddress: {[address: string]: RewardDestination} = {}
+
+        // something went wrong, so just query for single accountAddress
+        if (rewardDestinations.length !== allAccountsInBlock.length) {
+            const payee = await api.query.staking.payee(accountAddress);
+            destinationByAddress[accountAddress] = payee;
+            rewardDestinationByAddress[blockId] = destinationByAddress
+            return payee
+        }
+        allAccountsInBlock.forEach((account, index) => { 
+            let accountAddress = account.toString()
+            let rewardDestination = rewardDestinations[index]
+            destinationByAddress[accountAddress] = rewardDestination
+        })
+        rewardDestinationByAddress[blockId] = destinationByAddress
+        return destinationByAddress[accountAddress]
+    }
+}
+
 export async function handleRewardRestakeForAnalytics(event: SubstrateEvent): Promise<void> {
     let {event: {data: [accountId, amount]}} = event
     let accountAddress = accountId.toString()
 
-    const payee: RewardDestination = await api.query.staking.payee(accountAddress);
+    const payee = await cachedRewardDestination(accountAddress, event)
     if (payee.isStaked) {
         let amountBalance = (amount as Balance).toBigInt()
         let accumulatedAmount = await handleAccumulatedStake(accountAddress, amountBalance)

src/mappings/common.ts

@@ -4,6 +4,10 @@ import {Balance} from "@polkadot/types/interfaces";
 import {CallBase} from "@polkadot/types/types/calls";
 import {AnyTuple} from "@polkadot/types/types/codec";
 import { Vec } from '@polkadot/types';
+import {EraIndex} from "@polkadot/types/interfaces/staking"
+import { StorageKey } from "@polkadot/types";
+import { AccountId } from "@polkadot/types/interfaces";
+import { Exposure } from "@polkadot/types/interfaces";
 
 const batchCalls = ["batch", "batchAll"]
 const transferCalls = ["transfer", "transferKeepAlive"]
@@ -79,3 +83,31 @@ export function exportFeeFromDepositEventAsString(extrinsic?: SubstrateExtrinsic
         return "0"
     } 
 }
+
+let currentEraByBlockId: {[blockId: string]: EraIndex} = {}
+
+export async function cachedCurrentEra(block: SubstrateBlock): Promise<EraIndex> {
+    let key = block.block.header.number.toString()
+    let cachedValue = currentEraByBlockId[key]
+    if (cachedValue !== undefined) {
+        return cachedValue
+    } else {
+        let eraOption = await api.query.staking.currentEra()
+        let eraIndex = eraOption.unwrap()
+        currentEraByBlockId[key] = eraIndex
+        return eraIndex
+    }
+}
+
+let eraStakersByEra: {[era: number]: [StorageKey<[EraIndex, AccountId]>, Exposure][]} = {}
+
+export async function cachedEraStakers(era: number): Promise<[StorageKey<[EraIndex, AccountId]>, Exposure][]> {
+    let cachedValue = eraStakersByEra[era]
+    if (cachedValue !== undefined) {
+        return cachedValue
+    } else {
+        let eraStakers = await api.query.staking.erasStakers.entries(era);
+        eraStakersByEra[era] = eraStakers
+        return eraStakers
+    }
+}