added base PaidOut support

project-kusama.yaml

@@ -41,6 +41,12 @@ dataSources:
             module: staking
             method: Rewarded
 
+        - handler: handleKusamaPoolStakingReward
+          kind: substrate/EventHandler
+          filter:
+            module: nominationPools
+            method: PaidOut
+
         - handler: handleKusamaStakingSlash
           kind: substrate/EventHandler
           filter:

schema.graphql

@@ -60,4 +60,5 @@ type Reward @entity {
   amount: BigInt!
   accumulatedAmount: BigInt!
   type: RewardType!
+  poolId: Int
 }

src/mappings/common.ts

@@ -17,4 +17,12 @@ export async function handleNewEra(
     )
 
     await stakingStats.indexEraStats()
+}
+
+export function stakingTypeDirect(stakingType: string): string {
+    return `${stakingType}-${"direct"}`
+}
+
+export function stakingTypePooled(stakingType: string): string {
+    return `${stakingType}-${"pooled"}`
 }

src/mappings/kusama.ts

@@ -1,13 +1,15 @@
 import {SubstrateEvent} from "@subql/types";
-import {handleNewEra} from "./common";
+import {handleNewEra, stakingTypeDirect, stakingTypePooled} from "./common";
 import {RelaychainRewardCalculator} from "./rewards/Relaychain";
 import {ValidatorEraInfoDataSource} from "./era/ValidatorEraInfoDataSource";
 import {Codec} from "@polkadot/types/types";
 import {INumber} from "@polkadot/types-codec/types/interfaces";
-import {handleRelaychainStakingReward, handleRelaychainStakingSlash} from "./rewards/history/relaychain";
+import {handleRelaychainStakingReward, handleRelaychainStakingSlash, handleRelaychainPooledStakingReward} from "./rewards/history/relaychain";
 
 const KUSAMA_GENESIS = "0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe"
 const STAKING_TYPE = "relaychain"
+const DIRECT_STAKING_TYPE = stakingTypeDirect(STAKING_TYPE)
+const POOLED_STAKING_TYPE = stakingTypePooled(STAKING_TYPE)
 
 export async function handleKusamaNewEra(_: SubstrateEvent): Promise<void> {
     let validatorEraInfoDataSource = new ValidatorEraInfoDataSource();
@@ -16,18 +18,24 @@ export async function handleKusamaNewEra(_: SubstrateEvent): Promise<void> {
         validatorEraInfoDataSource,
         await RelaychainRewardCalculator(validatorEraInfoDataSource),
         KUSAMA_GENESIS,
-        STAKING_TYPE
+        DIRECT_STAKING_TYPE
     )
 }
 
 export async function handleKusamaStakingReward(
     event: SubstrateEvent<[accountId: Codec, reward: INumber]>,
 ): Promise<void> {
-    await handleRelaychainStakingReward(event, KUSAMA_GENESIS, STAKING_TYPE)
+    await handleRelaychainStakingReward(event, KUSAMA_GENESIS, DIRECT_STAKING_TYPE)
 }
 
 export async function handleKusamaStakingSlash(
     event: SubstrateEvent<[account: Codec, slash: INumber]>,
 ): Promise<void> {
-    await handleRelaychainStakingSlash(event, KUSAMA_GENESIS, STAKING_TYPE)
+    await handleRelaychainStakingSlash(event, KUSAMA_GENESIS, DIRECT_STAKING_TYPE)
+}
+
+export async function handleKusamaPoolStakingReward(
+    event: SubstrateEvent<[accountId: Codec, poolId: INumber, reward: INumber]>,
+): Promise<void> {
+    await handleRelaychainPooledStakingReward(event, KUSAMA_GENESIS, POOLED_STAKING_TYPE)
 }

src/mappings/rewards/history/common.ts

@@ -12,6 +12,8 @@ export interface RewardArgs {
     chainId: string
 
     stakingType: string
+
+    poolId?: number
 }
 
 export async function handleReward(rewardProps: RewardArgs, event: SubstrateEvent) {
@@ -32,6 +34,10 @@ export async function handleReward(rewardProps: RewardArgs, event: SubstrateEven
         stakingType: rewardProps.stakingType
     });
 
+    if (rewardProps.poolId !== undefined) {
+        accountReward.poolId = rewardProps.poolId
+    }
+
     await accountReward.save()
 }
 

src/mappings/rewards/history/relaychain.ts

@@ -12,6 +12,25 @@ export async function handleRelaychainStakingReward(
     await handleRelaychainStakingRewardType(event, RewardType.reward, chainId, stakingType)
 }
 
+export async function handleRelaychainPooledStakingReward(
+    event: SubstrateEvent<[accountId: Codec, poolId: INumber, reward: INumber]>,
+    chainId: string,
+    stakingType: string
+): Promise<void> {
+    const {event: {data: [accountId, poolId, amount]}} = event
+
+    const rewardProps: RewardArgs = {
+        amount: amount.toBigInt(),
+        address: accountId.toString(),
+        type: RewardType.reward,
+        chainId: chainId,
+        stakingType: stakingType,
+        poolId: poolId.toNumber()
+    }
+
+    await handleReward(rewardProps, event)
+}
+
 export async function handleRelaychainStakingSlash(
     event: SubstrateEvent<[account: Codec, slash: INumber]>,
     chainId: string,