refactor query-node mappings to Hydra v3 format

query-node/manifest.yml

@@ -1,11 +1,10 @@
-version: '0.1'
+version: '3.0'
 description: Joystream query-node manifest file for olympia
 repository: https://github.com/Joystream/joystream
 hydraVersion: "3"
 dataSource:
   kind: substrate
   chain: joystream
-  indexerVersion: '0.1.6'
 entities:
   - generated/graphql-server/dist/src/modules/**/*.model.js
 typegen:
@@ -57,9 +56,6 @@ typegen:
     lib: '@joystream/types/augment/all/types'
     typedefsLoc: '../types/augment/all/defs.json'
 mappings:
-  hydraCommonVersion: '0.0.3'
-  # process only blocks with height >= 1M
-  # blockInterval: '[1000000,]'
   # js module that exports the handler functions
   mappingsModule: mappings/lib
   # additinal libraries the processor loads
@@ -69,213 +65,213 @@ mappings:
   eventHandlers:
     # Membership module
     - event: members.MembershipBought
-      handler: members_MembershipBought(DatabaseManager, SubstrateEvent)
+      handler: members_MembershipBought
     - event: members.MemberProfileUpdated
-      handler: members_MemberProfileUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_MemberProfileUpdated
     - event: members.MemberAccountsUpdated
-      handler: members_MemberAccountsUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_MemberAccountsUpdated
     - event: members.MemberVerificationStatusUpdated
-      handler: members_MemberVerificationStatusUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_MemberVerificationStatusUpdated
     - event: members.InvitesTransferred
-      handler: members_InvitesTransferred(DatabaseManager, SubstrateEvent)
+      handler: members_InvitesTransferred
     - event: members.MemberInvited
-      handler: members_MemberInvited(DatabaseManager, SubstrateEvent)
+      handler: members_MemberInvited
     - event: members.StakingAccountAdded
-      handler: members_StakingAccountAdded(DatabaseManager, SubstrateEvent)
+      handler: members_StakingAccountAdded
     - event: members.StakingAccountConfirmed
-      handler: members_StakingAccountConfirmed(DatabaseManager, SubstrateEvent)
+      handler: members_StakingAccountConfirmed
     - event: members.StakingAccountRemoved
-      handler: members_StakingAccountRemoved(DatabaseManager, SubstrateEvent)
+      handler: members_StakingAccountRemoved
     - event: members.InitialInvitationCountUpdated
-      handler: members_InitialInvitationCountUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_InitialInvitationCountUpdated
     - event: members.MembershipPriceUpdated
-      handler: members_MembershipPriceUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_MembershipPriceUpdated
     - event: members.ReferralCutUpdated
-      handler: members_ReferralCutUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_ReferralCutUpdated
     - event: members.InitialInvitationBalanceUpdated
-      handler: members_InitialInvitationBalanceUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_InitialInvitationBalanceUpdated
     - event: members.LeaderInvitationQuotaUpdated
-      handler: members_LeaderInvitationQuotaUpdated(DatabaseManager, SubstrateEvent)
+      handler: members_LeaderInvitationQuotaUpdated
     # Storage working group
     - event: storageWorkingGroup.OpeningAdded
-      handler: workingGroups_OpeningAdded(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningAdded
     - event: storageWorkingGroup.AppliedOnOpening
-      handler: workingGroups_AppliedOnOpening(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_AppliedOnOpening
     - event: storageWorkingGroup.OpeningFilled
-      handler: workingGroups_OpeningFilled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningFilled
     - event: storageWorkingGroup.LeaderSet
-      handler: workingGroups_LeaderSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderSet
     - event: storageWorkingGroup.WorkerRoleAccountUpdated
-      handler: workingGroups_WorkerRoleAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRoleAccountUpdated
     - event: storageWorkingGroup.LeaderUnset
-      handler: workingGroups_LeaderUnset(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderUnset
     - event: storageWorkingGroup.WorkerExited
-      handler: workingGroups_WorkerExited(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerExited
     - event: storageWorkingGroup.TerminatedWorker
-      handler: workingGroups_TerminatedWorker(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedWorker
     - event: storageWorkingGroup.TerminatedLeader
-      handler: workingGroups_TerminatedLeader(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedLeader
     - event: storageWorkingGroup.StakeSlashed
-      handler: workingGroups_StakeSlashed(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeSlashed
     - event: storageWorkingGroup.StakeDecreased
-      handler: workingGroups_StakeDecreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeDecreased
     - event: storageWorkingGroup.StakeIncreased
-      handler: workingGroups_StakeIncreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeIncreased
     - event: storageWorkingGroup.ApplicationWithdrawn
-      handler: workingGroups_ApplicationWithdrawn(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_ApplicationWithdrawn
     - event: storageWorkingGroup.OpeningCanceled
-      handler: workingGroups_OpeningCanceled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningCanceled
     - event: storageWorkingGroup.BudgetSet
-      handler: workingGroups_BudgetSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSet
     - event: storageWorkingGroup.WorkerRewardAccountUpdated
-      handler: workingGroups_WorkerRewardAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAccountUpdated
     - event: storageWorkingGroup.WorkerRewardAmountUpdated
-      handler: workingGroups_WorkerRewardAmountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAmountUpdated
     - event: storageWorkingGroup.StatusTextChanged
-      handler: workingGroups_StatusTextChanged(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StatusTextChanged
     - event: storageWorkingGroup.BudgetSpending
-      handler: workingGroups_BudgetSpending(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSpending
     - event: storageWorkingGroup.RewardPaid
-      handler: workingGroups_RewardPaid(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_RewardPaid
     - event: storageWorkingGroup.NewMissedRewardLevelReached
-      handler: workingGroups_NewMissedRewardLevelReached(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_NewMissedRewardLevelReached
     - event: storageWorkingGroup.WorkerStartedLeaving
-      handler: workingGroups_WorkerStartedLeaving(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerStartedLeaving
     # Forum working group
     - event: forumWorkingGroup.OpeningAdded
-      handler: workingGroups_OpeningAdded(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningAdded
     - event: forumWorkingGroup.AppliedOnOpening
-      handler: workingGroups_AppliedOnOpening(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_AppliedOnOpening
     - event: forumWorkingGroup.OpeningFilled
-      handler: workingGroups_OpeningFilled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningFilled
     - event: forumWorkingGroup.LeaderSet
-      handler: workingGroups_LeaderSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderSet
     - event: forumWorkingGroup.WorkerRoleAccountUpdated
-      handler: workingGroups_WorkerRoleAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRoleAccountUpdated
     - event: forumWorkingGroup.LeaderUnset
-      handler: workingGroups_LeaderUnset(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderUnset
     - event: forumWorkingGroup.WorkerExited
-      handler: workingGroups_WorkerExited(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerExited
     - event: forumWorkingGroup.TerminatedWorker
-      handler: workingGroups_TerminatedWorker(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedWorker
     - event: forumWorkingGroup.TerminatedLeader
-      handler: workingGroups_TerminatedLeader(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedLeader
     - event: forumWorkingGroup.StakeSlashed
-      handler: workingGroups_StakeSlashed(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeSlashed
     - event: forumWorkingGroup.StakeDecreased
-      handler: workingGroups_StakeDecreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeDecreased
     - event: forumWorkingGroup.StakeIncreased
-      handler: workingGroups_StakeIncreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeIncreased
     - event: forumWorkingGroup.ApplicationWithdrawn
-      handler: workingGroups_ApplicationWithdrawn(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_ApplicationWithdrawn
     - event: forumWorkingGroup.OpeningCanceled
-      handler: workingGroups_OpeningCanceled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningCanceled
     - event: forumWorkingGroup.BudgetSet
-      handler: workingGroups_BudgetSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSet
     - event: forumWorkingGroup.WorkerRewardAccountUpdated
-      handler: workingGroups_WorkerRewardAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAccountUpdated
     - event: forumWorkingGroup.WorkerRewardAmountUpdated
-      handler: workingGroups_WorkerRewardAmountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAmountUpdated
     - event: forumWorkingGroup.StatusTextChanged
-      handler: workingGroups_StatusTextChanged(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StatusTextChanged
     - event: forumWorkingGroup.BudgetSpending
-      handler: workingGroups_BudgetSpending(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSpending
     - event: forumWorkingGroup.RewardPaid
-      handler: workingGroups_RewardPaid(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_RewardPaid
     - event: forumWorkingGroup.NewMissedRewardLevelReached
-      handler: workingGroups_NewMissedRewardLevelReached(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_NewMissedRewardLevelReached
     - event: forumWorkingGroup.WorkerStartedLeaving
-      handler: workingGroups_WorkerStartedLeaving(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerStartedLeaving
     # Membership working group
     - event: membershipWorkingGroup.OpeningAdded
-      handler: workingGroups_OpeningAdded(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningAdded
     - event: membershipWorkingGroup.AppliedOnOpening
-      handler: workingGroups_AppliedOnOpening(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_AppliedOnOpening
     - event: membershipWorkingGroup.OpeningFilled
-      handler: workingGroups_OpeningFilled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningFilled
     - event: membershipWorkingGroup.LeaderSet
-      handler: workingGroups_LeaderSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderSet
     - event: membershipWorkingGroup.WorkerRoleAccountUpdated
-      handler: workingGroups_WorkerRoleAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRoleAccountUpdated
     - event: membershipWorkingGroup.LeaderUnset
-      handler: workingGroups_LeaderUnset(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderUnset
     - event: membershipWorkingGroup.WorkerExited
-      handler: workingGroups_WorkerExited(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerExited
     - event: membershipWorkingGroup.TerminatedWorker
-      handler: workingGroups_TerminatedWorker(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedWorker
     - event: membershipWorkingGroup.TerminatedLeader
-      handler: workingGroups_TerminatedLeader(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedLeader
     - event: membershipWorkingGroup.StakeSlashed
-      handler: workingGroups_StakeSlashed(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeSlashed
     - event: membershipWorkingGroup.StakeDecreased
-      handler: workingGroups_StakeDecreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeDecreased
     - event: membershipWorkingGroup.StakeIncreased
-      handler: workingGroups_StakeIncreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeIncreased
     - event: membershipWorkingGroup.ApplicationWithdrawn
-      handler: workingGroups_ApplicationWithdrawn(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_ApplicationWithdrawn
     - event: membershipWorkingGroup.OpeningCanceled
-      handler: workingGroups_OpeningCanceled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningCanceled
     - event: membershipWorkingGroup.BudgetSet
-      handler: workingGroups_BudgetSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSet
     - event: membershipWorkingGroup.WorkerRewardAccountUpdated
-      handler: workingGroups_WorkerRewardAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAccountUpdated
     - event: membershipWorkingGroup.WorkerRewardAmountUpdated
-      handler: workingGroups_WorkerRewardAmountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAmountUpdated
     - event: membershipWorkingGroup.StatusTextChanged
-      handler: workingGroups_StatusTextChanged(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StatusTextChanged
     - event: membershipWorkingGroup.BudgetSpending
-      handler: workingGroups_BudgetSpending(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSpending
     - event: membershipWorkingGroup.RewardPaid
-      handler: workingGroups_RewardPaid(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_RewardPaid
     - event: membershipWorkingGroup.NewMissedRewardLevelReached
-      handler: workingGroups_NewMissedRewardLevelReached(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_NewMissedRewardLevelReached
     - event: membershipWorkingGroup.WorkerStartedLeaving
-      handler: workingGroups_WorkerStartedLeaving(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerStartedLeaving
     # Content directory working group
     - event: contentDirectoryWorkingGroup.OpeningAdded
-      handler: workingGroups_OpeningAdded(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningAdded
     - event: contentDirectoryWorkingGroup.AppliedOnOpening
-      handler: workingGroups_AppliedOnOpening(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_AppliedOnOpening
     - event: contentDirectoryWorkingGroup.OpeningFilled
-      handler: workingGroups_OpeningFilled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningFilled
     - event: contentDirectoryWorkingGroup.LeaderSet
-      handler: workingGroups_LeaderSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderSet
     - event: contentDirectoryWorkingGroup.WorkerRoleAccountUpdated
-      handler: workingGroups_WorkerRoleAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRoleAccountUpdated
     - event: contentDirectoryWorkingGroup.LeaderUnset
-      handler: workingGroups_LeaderUnset(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_LeaderUnset
     - event: contentDirectoryWorkingGroup.WorkerExited
-      handler: workingGroups_WorkerExited(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerExited
     - event: contentDirectoryWorkingGroup.TerminatedWorker
-      handler: workingGroups_TerminatedWorker(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedWorker
     - event: contentDirectoryWorkingGroup.TerminatedLeader
-      handler: workingGroups_TerminatedLeader(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_TerminatedLeader
     - event: contentDirectoryWorkingGroup.StakeSlashed
-      handler: workingGroups_StakeSlashed(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeSlashed
     - event: contentDirectoryWorkingGroup.StakeDecreased
-      handler: workingGroups_StakeDecreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeDecreased
     - event: contentDirectoryWorkingGroup.StakeIncreased
-      handler: workingGroups_StakeIncreased(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StakeIncreased
     - event: contentDirectoryWorkingGroup.ApplicationWithdrawn
-      handler: workingGroups_ApplicationWithdrawn(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_ApplicationWithdrawn
     - event: contentDirectoryWorkingGroup.OpeningCanceled
-      handler: workingGroups_OpeningCanceled(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_OpeningCanceled
     - event: contentDirectoryWorkingGroup.BudgetSet
-      handler: workingGroups_BudgetSet(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSet
     - event: contentDirectoryWorkingGroup.WorkerRewardAccountUpdated
-      handler: workingGroups_WorkerRewardAccountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAccountUpdated
     - event: contentDirectoryWorkingGroup.WorkerRewardAmountUpdated
-      handler: workingGroups_WorkerRewardAmountUpdated(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerRewardAmountUpdated
     - event: contentDirectoryWorkingGroup.StatusTextChanged
-      handler: workingGroups_StatusTextChanged(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_StatusTextChanged
     - event: contentDirectoryWorkingGroup.BudgetSpending
-      handler: workingGroups_BudgetSpending(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_BudgetSpending
     - event: contentDirectoryWorkingGroup.RewardPaid
-      handler: workingGroups_RewardPaid(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_RewardPaid
     - event: contentDirectoryWorkingGroup.NewMissedRewardLevelReached
-      handler: workingGroups_NewMissedRewardLevelReached(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_NewMissedRewardLevelReached
     - event: contentDirectoryWorkingGroup.WorkerStartedLeaving
-      handler: workingGroups_WorkerStartedLeaving(DatabaseManager, SubstrateEvent)
+      handler: workingGroups_WorkerStartedLeaving
   extrinsicHandlers:
     # infer defaults here
     #- extrinsic: Balances.Transfer

query-node/mappings/membership.ts

@@ -1,7 +1,12 @@
 /*
 eslint-disable @typescript-eslint/naming-convention
 */
-import { SubstrateEvent, DatabaseManager } from '@dzlzv/hydra-common'
+import {
+  EventContext,
+  StoreContext,
+  DatabaseManager,
+  SubstrateEvent
+} from '@dzlzv/hydra-common'
 import { Members } from './generated/types'
 import { MemberId, BuyMembershipParameters, InviteMembershipParameters } from '@joystream/types/augment/all'
 import { MembershipMetadata } from '@joystream/metadata-protobuf'
@@ -29,49 +34,49 @@ import {
   MembershipEntryInvited,
 } from 'query-node/dist/model'
 
-async function getMemberById(db: DatabaseManager, id: MemberId): Promise<Membership> {
-  const member = await db.get(Membership, { where: { id: id.toString() }, relations: ['metadata'] })
+async function getMemberById(store: DatabaseManager, id: MemberId): Promise<Membership> {
+  const member = await store.get(Membership, { where: { id: id.toString() }, relations: ['metadata'] })
   if (!member) {
     throw new Error(`Member(${id}) not found`)
   }
   return member
 }
 
-async function getLatestMembershipSystemSnapshot(db: DatabaseManager): Promise<MembershipSystemSnapshot> {
-  const membershipSystem = await db.get(MembershipSystemSnapshot, {
+async function getLatestMembershipSystemSnapshot(store: DatabaseManager): Promise<MembershipSystemSnapshot> {
+  const membershipSystem = await store.get(MembershipSystemSnapshot, {
     order: { snapshotBlock: 'DESC' },
   })
   if (!membershipSystem) {
-    throw new Error(`Membership system snapshot not found! Forgot to run "yarn workspace query-node-root db:init"?`)
+    throw new Error(`Membership system snapshot not found! Forgot to run "yarn workspace query-node-root store:init"?`)
   }
   return membershipSystem
 }
 
-async function getOrCreateMembershipSnapshot(db: DatabaseManager, event_: SubstrateEvent) {
-  const latestSnapshot = await getLatestMembershipSystemSnapshot(db)
-  const eventTime = new Date(event_.blockTimestamp)
-  return latestSnapshot.snapshotBlock === event_.blockNumber
+async function getOrCreateMembershipSnapshot({ store, event }: EventContext & StoreContext) {
+  const latestSnapshot = await getLatestMembershipSystemSnapshot(store)
+  const eventTime = new Date(event.blockTimestamp)
+  return latestSnapshot.snapshotBlock === event.blockNumber
     ? latestSnapshot
     : new MembershipSystemSnapshot({
         ...latestSnapshot,
         createdAt: eventTime,
         updatedAt: eventTime,
         id: undefined,
-        snapshotBlock: event_.blockNumber,
+        snapshotBlock: event.blockNumber,
       })
 }
 
 async function createNewMemberFromParams(
-  db: DatabaseManager,
-  event_: SubstrateEvent,
+  store: DatabaseManager,
+  event: SubstrateEvent,
   memberId: MemberId,
   entryMethod: typeof MembershipEntryMethod,
   params: BuyMembershipParameters | InviteMembershipParameters
 ): Promise<Membership> {
-  const { defaultInviteCount } = await getLatestMembershipSystemSnapshot(db)
+  const { defaultInviteCount } = await getLatestMembershipSystemSnapshot(store)
   const { root_account: rootAccount, controller_account: controllerAccount, handle, metadata: metatadaBytes } = params
   const metadata = deserializeMetadata(MembershipMetadata, metatadaBytes)
-  const eventTime = new Date(event_.blockTimestamp)
+  const eventTime = new Date(event.blockTimestamp)
 
   const metadataEntity = new MemberMetadata({
     createdAt: eventTime,
@@ -90,7 +95,7 @@ async function createNewMemberFromParams(
     handle: handle.unwrap().toString(),
     metadata: metadataEntity,
     entry: entryMethod,
-    referredBy:
+    referrestorey:
       entryMethod.isTypeOf === 'MembershipEntryPaid' && (params as BuyMembershipParameters).referrer_id.isSome
         ? new Membership({ id: (params as BuyMembershipParameters).referrer_id.unwrap().toString() })
         : undefined,
@@ -99,27 +104,27 @@ async function createNewMemberFromParams(
     boundAccounts: [],
     invitees: [],
     referredMembers: [],
-    invitedBy:
+    invitestorey:
       entryMethod.isTypeOf === 'MembershipEntryInvited'
         ? new Membership({ id: (params as InviteMembershipParameters).inviting_member_id.toString() })
         : undefined,
     isFoundingMember: false,
   })
 
-  await db.save<MemberMetadata>(member.metadata)
-  await db.save<Membership>(member)
+  await store.save<MemberMetadata>(member.metadata)
+  await store.save<Membership>(member)
 
   return member
 }
 
-export async function members_MembershipBought(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [memberId, buyMembershipParameters] = new Members.MembershipBoughtEvent(event_).params
+export async function members_MembershipBought({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [memberId, buyMembershipParameters] = new Members.MembershipBoughtEvent(event).params
 
   const memberEntry = new MembershipEntryPaid()
-  const member = await createNewMemberFromParams(db, event_, memberId, memberEntry, buyMembershipParameters)
+  const member = await createNewMemberFromParams(store, event, memberId, memberEntry, buyMembershipParameters)
 
   const membershipBoughtEvent = new MembershipBoughtEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     newMember: member,
     controllerAccount: member.controllerAccount,
     rootAccount: member.rootAccount,
@@ -128,25 +133,25 @@ export async function members_MembershipBought(db: DatabaseManager, event_: Subs
       ...member.metadata,
       id: undefined,
     }),
-    referrer: member.referredBy,
+    referrer: member.referrestorey,
   })
 
-  await db.save<MemberMetadata>(membershipBoughtEvent.metadata)
-  await db.save<MembershipBoughtEvent>(membershipBoughtEvent)
+  await store.save<MemberMetadata>(membershipBoughtEvent.metadata)
+  await store.save<MembershipBoughtEvent>(membershipBoughtEvent)
 
   // Update the other side of event<->membership relation
   memberEntry.membershipBoughtEventId = membershipBoughtEvent.id
-  await db.save<Membership>(member)
+  await store.save<Membership>(member)
 }
 
-export async function members_MemberProfileUpdated(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [memberId] = new Members.MemberProfileUpdatedEvent(event_).params
-  const { metadata: metadataBytesOpt, handle } = new Members.UpdateProfileCall(event_).args
+export async function members_MemberProfileUpdated({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [memberId] = new Members.MemberProfileUpdatedEvent(event).params
+  const { metadata: metadataBytesOpt, handle } = new Members.UpdateProfileCall(event).args
   const metadata = metadataBytesOpt.isSome
     ? deserializeMetadata(MembershipMetadata, metadataBytesOpt.unwrap())
     : undefined
-  const member = await getMemberById(db, memberId)
-  const eventTime = new Date(event_.blockTimestamp)
+  const member = await getMemberById(store, memberId)
+  const eventTime = new Date(event.blockTimestamp)
 
   if (typeof metadata?.name === 'string') {
     member.metadata.name = metadata.name || undefined
@@ -162,11 +167,11 @@ export async function members_MemberProfileUpdated(db: DatabaseManager, event_:
     member.updatedAt = eventTime
   }
 
-  await db.save<MemberMetadata>(member.metadata)
-  await db.save<Membership>(member)
+  await store.save<MemberMetadata>(member.metadata)
+  await store.save<Membership>(member)
 
   const memberProfileUpdatedEvent = new MemberProfileUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     member: member,
     newHandle: member.handle,
     newMetadata: new MemberMetadata({
@@ -175,15 +180,15 @@ export async function members_MemberProfileUpdated(db: DatabaseManager, event_:
     }),
   })
 
-  await db.save<MemberMetadata>(memberProfileUpdatedEvent.newMetadata)
-  await db.save<MemberProfileUpdatedEvent>(memberProfileUpdatedEvent)
+  await store.save<MemberMetadata>(memberProfileUpdatedEvent.newMetadata)
+  await store.save<MemberProfileUpdatedEvent>(memberProfileUpdatedEvent)
 }
 
-export async function members_MemberAccountsUpdated(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [memberId] = new Members.MemberAccountsUpdatedEvent(event_).params
-  const { newRootAccount, newControllerAccount } = new Members.UpdateAccountsCall(event_).args
-  const member = await getMemberById(db, memberId)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function members_MemberAccountsUpdated({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [memberId] = new Members.MemberAccountsUpdatedEvent(event).params
+  const { newRootAccount, newControllerAccount } = new Members.UpdateAccountsCall(event).args
+  const member = await getMemberById(store, memberId)
+  const eventTime = new Date(event.blockTimestamp)
 
   if (newControllerAccount.isSome) {
     member.controllerAccount = newControllerAccount.unwrap().toString()
@@ -193,78 +198,78 @@ export async function members_MemberAccountsUpdated(db: DatabaseManager, event_:
   }
   member.updatedAt = eventTime
 
-  await db.save<Membership>(member)
+  await store.save<Membership>(member)
 
   const memberAccountsUpdatedEvent = new MemberAccountsUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     member: member,
     newRootAccount: member.rootAccount,
     newControllerAccount: member.controllerAccount,
   })
 
-  await db.save<MemberAccountsUpdatedEvent>(memberAccountsUpdatedEvent)
+  await store.save<MemberAccountsUpdatedEvent>(memberAccountsUpdatedEvent)
 }
 
 export async function members_MemberVerificationStatusUpdated(
-  db: DatabaseManager,
-  event_: SubstrateEvent
+  store: DatabaseManager,
+  event: SubstrateEvent
 ): Promise<void> {
-  const [memberId, verificationStatus] = new Members.MemberVerificationStatusUpdatedEvent(event_).params
-  const member = await getMemberById(db, memberId)
-  const eventTime = new Date(event_.blockTimestamp)
+  const [memberId, verificationStatus] = new Members.MemberVerificationStatusUpdatedEvent(event).params
+  const member = await getMemberById(store, memberId)
+  const eventTime = new Date(event.blockTimestamp)
 
   member.isVerified = verificationStatus.valueOf()
   member.updatedAt = eventTime
 
-  await db.save<Membership>(member)
+  await store.save<Membership>(member)
 
   const memberVerificationStatusUpdatedEvent = new MemberVerificationStatusUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     member: member,
     isVerified: member.isVerified,
   })
 
-  await db.save<MemberVerificationStatusUpdatedEvent>(memberVerificationStatusUpdatedEvent)
+  await store.save<MemberVerificationStatusUpdatedEvent>(memberVerificationStatusUpdatedEvent)
 }
 
-export async function members_InvitesTransferred(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [sourceMemberId, targetMemberId, numberOfInvites] = new Members.InvitesTransferredEvent(event_).params
-  const sourceMember = await getMemberById(db, sourceMemberId)
-  const targetMember = await getMemberById(db, targetMemberId)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function members_InvitesTransferred({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [sourceMemberId, targetMemberId, numberOfInvites] = new Members.InvitesTransferredEvent(event).params
+  const sourceMember = await getMemberById(store, sourceMemberId)
+  const targetMember = await getMemberById(store, targetMemberId)
+  const eventTime = new Date(event.blockTimestamp)
 
   sourceMember.inviteCount -= numberOfInvites.toNumber()
   sourceMember.updatedAt = eventTime
   targetMember.inviteCount += numberOfInvites.toNumber()
   targetMember.updatedAt = eventTime
 
-  await db.save<Membership>(sourceMember)
-  await db.save<Membership>(targetMember)
+  await store.save<Membership>(sourceMember)
+  await store.save<Membership>(targetMember)
 
   const invitesTransferredEvent = new InvitesTransferredEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     sourceMember,
     targetMember,
     numberOfInvites: numberOfInvites.toNumber(),
   })
 
-  await db.save<InvitesTransferredEvent>(invitesTransferredEvent)
+  await store.save<InvitesTransferredEvent>(invitesTransferredEvent)
 }
 
-export async function members_MemberInvited(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [memberId, inviteMembershipParameters] = new Members.MemberInvitedEvent(event_).params
-  const eventTime = new Date(event_.blockTimestamp)
+export async function members_MemberInvited({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [memberId, inviteMembershipParameters] = new Members.MemberInvitedEvent(event).params
+  const eventTime = new Date(event.blockTimestamp)
   const entryMethod = new MembershipEntryInvited()
-  const invitedMember = await createNewMemberFromParams(db, event_, memberId, entryMethod, inviteMembershipParameters)
+  const invitedMember = await createNewMemberFromParams(store, event, memberId, entryMethod, inviteMembershipParameters)
 
   // Decrease invite count of inviting member
-  const invitingMember = await getMemberById(db, inviteMembershipParameters.inviting_member_id)
+  const invitingMember = await getMemberById(store, inviteMembershipParameters.inviting_member_id)
   invitingMember.inviteCount -= 1
   invitingMember.updatedAt = eventTime
-  await db.save<Membership>(invitingMember)
+  await store.save<Membership>(invitingMember)
 
   const memberInvitedEvent = new MemberInvitedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     invitingMember,
     newMember: invitedMember,
     handle: invitedMember.handle,
@@ -276,48 +281,48 @@ export async function members_MemberInvited(db: DatabaseManager, event_: Substra
     }),
   })
 
-  await db.save<MemberMetadata>(memberInvitedEvent.metadata)
-  await db.save<MemberInvitedEvent>(memberInvitedEvent)
+  await store.save<MemberMetadata>(memberInvitedEvent.metadata)
+  await store.save<MemberInvitedEvent>(memberInvitedEvent)
   // Update the other side of event<->member relationship
   entryMethod.memberInvitedEventId = memberInvitedEvent.id
-  await db.save<Membership>(invitedMember)
+  await store.save<Membership>(invitedMember)
 }
 
-export async function members_StakingAccountAdded(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [accountId, memberId] = new Members.StakingAccountAddedEvent(event_).params
+export async function members_StakingAccountAdded({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [accountId, memberId] = new Members.StakingAccountAddedEvent(event).params
 
   const stakingAccountAddedEvent = new StakingAccountAddedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     member: new Membership({ id: memberId.toString() }),
     account: accountId.toString(),
   })
 
-  await db.save<StakingAccountAddedEvent>(stakingAccountAddedEvent)
+  await store.save<StakingAccountAddedEvent>(stakingAccountAddedEvent)
 }
 
-export async function members_StakingAccountConfirmed(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [accountId, memberId] = new Members.StakingAccountConfirmedEvent(event_).params
-  const member = await getMemberById(db, memberId)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function members_StakingAccountConfirmed({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [accountId, memberId] = new Members.StakingAccountConfirmedEvent(event).params
+  const member = await getMemberById(store, memberId)
+  const eventTime = new Date(event.blockTimestamp)
 
   member.boundAccounts.push(accountId.toString())
   member.updatedAt = eventTime
 
-  await db.save<Membership>(member)
+  await store.save<Membership>(member)
 
   const stakingAccountConfirmedEvent = new StakingAccountConfirmedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     member,
     account: accountId.toString(),
   })
 
-  await db.save<StakingAccountConfirmedEvent>(stakingAccountConfirmedEvent)
+  await store.save<StakingAccountConfirmedEvent>(stakingAccountConfirmedEvent)
 }
 
-export async function members_StakingAccountRemoved(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [accountId, memberId] = new Members.StakingAccountRemovedEvent(event_).params
-  const eventTime = new Date(event_.blockTimestamp)
-  const member = await getMemberById(db, memberId)
+export async function members_StakingAccountRemoved({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [accountId, memberId] = new Members.StakingAccountRemovedEvent(event).params
+  const eventTime = new Date(event.blockTimestamp)
+  const member = await getMemberById(store, memberId)
 
   member.boundAccounts.splice(
     member.boundAccounts.findIndex((a) => a === accountId.toString()),
@@ -325,94 +330,92 @@ export async function members_StakingAccountRemoved(db: DatabaseManager, event_:
   )
   member.updatedAt = eventTime
 
-  await db.save<Membership>(member)
+  await store.save<Membership>(member)
 
   const stakingAccountRemovedEvent = new StakingAccountRemovedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     member,
     account: accountId.toString(),
   })
 
-  await db.save<StakingAccountRemovedEvent>(stakingAccountRemovedEvent)
+  await store.save<StakingAccountRemovedEvent>(stakingAccountRemovedEvent)
 }
 
-export async function members_InitialInvitationCountUpdated(
-  db: DatabaseManager,
-  event_: SubstrateEvent
+export async function members_InitialInvitationCountUpdated(ctx: EventContext & StoreContext
 ): Promise<void> {
-  const [newDefaultInviteCount] = new Members.InitialInvitationCountUpdatedEvent(event_).params
-  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(db, event_)
+  const { event, store } = ctx
+  const [newDefaultInviteCount] = new Members.InitialInvitationCountUpdatedEvent(event).params
+  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(ctx)
 
   membershipSystemSnapshot.defaultInviteCount = newDefaultInviteCount.toNumber()
 
-  await db.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
+  await store.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
 
   const initialInvitationCountUpdatedEvent = new InitialInvitationCountUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     newInitialInvitationCount: newDefaultInviteCount.toNumber(),
   })
 
-  await db.save<InitialInvitationCountUpdatedEvent>(initialInvitationCountUpdatedEvent)
+  await store.save<InitialInvitationCountUpdatedEvent>(initialInvitationCountUpdatedEvent)
 }
 
-export async function members_MembershipPriceUpdated(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [newMembershipPrice] = new Members.MembershipPriceUpdatedEvent(event_).params
-  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(db, event_)
+export async function members_MembershipPriceUpdated(ctx: EventContext & StoreContext): Promise<void> {
+  const { event, store } = ctx
+  const [newMembershipPrice] = new Members.MembershipPriceUpdatedEvent(event).params
+  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(ctx)
 
   membershipSystemSnapshot.membershipPrice = newMembershipPrice
 
-  await db.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
+  await store.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
 
   const membershipPriceUpdatedEvent = new MembershipPriceUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     newPrice: newMembershipPrice,
   })
 
-  await db.save<MembershipPriceUpdatedEvent>(membershipPriceUpdatedEvent)
+  await store.save<MembershipPriceUpdatedEvent>(membershipPriceUpdatedEvent)
 }
 
-export async function members_ReferralCutUpdated(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [newReferralCut] = new Members.ReferralCutUpdatedEvent(event_).params
-  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(db, event_)
+export async function members_ReferralCutUpdated({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [newReferralCut] = new Members.ReferralCutUpdatedEvent(event).params
+  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(store, event)
 
   membershipSystemSnapshot.referralCut = newReferralCut.toNumber()
 
-  await db.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
+  await store.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
 
   const referralCutUpdatedEvent = new ReferralCutUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     newValue: newReferralCut.toNumber(),
   })
 
-  await db.save<ReferralCutUpdatedEvent>(referralCutUpdatedEvent)
+  await store.save<ReferralCutUpdatedEvent>(referralCutUpdatedEvent)
 }
 
-export async function members_InitialInvitationBalanceUpdated(
-  db: DatabaseManager,
-  event_: SubstrateEvent
-): Promise<void> {
-  const [newInvitedInitialBalance] = new Members.InitialInvitationBalanceUpdatedEvent(event_).params
-  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(db, event_)
+export async function members_InitialInvitationBalanceUpdated(ctx: EventContext & StoreContext): Promise<void> {
+  const { event, store } = ctx
+  const [newInvitedInitialBalance] = new Members.InitialInvitationBalanceUpdatedEvent(event).params
+  const membershipSystemSnapshot = await getOrCreateMembershipSnapshot(ctx)
 
   membershipSystemSnapshot.invitedInitialBalance = newInvitedInitialBalance
 
-  await db.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
+  await store.save<MembershipSystemSnapshot>(membershipSystemSnapshot)
 
   const initialInvitationBalanceUpdatedEvent = new InitialInvitationBalanceUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     newInitialBalance: newInvitedInitialBalance,
   })
 
-  await db.save<InitialInvitationBalanceUpdatedEvent>(initialInvitationBalanceUpdatedEvent)
+  await store.save<InitialInvitationBalanceUpdatedEvent>(initialInvitationBalanceUpdatedEvent)
 }
 
-export async function members_LeaderInvitationQuotaUpdated(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [newQuota] = new Members.LeaderInvitationQuotaUpdatedEvent(event_).params
+export async function members_LeaderInvitationQuotaUpdated({ store, event }: EventContext & StoreContext): Promise<void> {
+  const [newQuota] = new Members.LeaderInvitationQuotaUpdatedEvent(event).params
 
   const leaderInvitationQuotaUpdatedEvent = new LeaderInvitationQuotaUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     newInvitationQuota: newQuota.toNumber(),
   })
 
-  await db.save<LeaderInvitationQuotaUpdatedEvent>(leaderInvitationQuotaUpdatedEvent)
+  await store.save<LeaderInvitationQuotaUpdatedEvent>(leaderInvitationQuotaUpdatedEvent)
 }

query-node/mappings/workingGroups.ts

@@ -1,7 +1,13 @@
 /*
 eslint-disable @typescript-eslint/naming-convention
 */
-import { SubstrateEvent, DatabaseManager } from '@dzlzv/hydra-common'
+import {
+  EventContext,
+  StoreContext,
+  DatabaseManager,
+  SubstrateEvent
+} from '@dzlzv/hydra-common'
+
 import { StorageWorkingGroup as WorkingGroups } from './generated/types'
 import {
   ApplicationMetadata,
@@ -76,12 +82,12 @@ import { createType } from '@joystream/types'
 
 // Reusable functions
 async function getWorkingGroup(
-  db: DatabaseManager,
-  event_: SubstrateEvent,
+  store: DatabaseManager,
+  event: SubstrateEvent,
   relations: string[] = []
 ): Promise<WorkingGroup> {
-  const [groupName] = event_.name.split('.')
-  const group = await db.get(WorkingGroup, { where: { name: groupName }, relations })
+  const [groupName] = event.name.split('.')
+  const group = await store.get(WorkingGroup, { where: { name: groupName }, relations })
   if (!group) {
     throw new Error(`Working group ${groupName} not found!`)
   }
@@ -90,47 +96,47 @@ async function getWorkingGroup(
 }
 
 async function getOpening(
-  db: DatabaseManager,
-  openingDbId: string,
+  store: DatabaseManager,
+  openingstoreId: string,
   relations: string[] = []
 ): Promise<WorkingGroupOpening> {
-  const opening = await db.get(WorkingGroupOpening, { where: { id: openingDbId }, relations })
+  const opening = await store.get(WorkingGroupOpening, { where: { id: openingstoreId }, relations })
   if (!opening) {
-    throw new Error(`Opening not found by id ${openingDbId}`)
+    throw new Error(`Opening not found by id ${openingstoreId}`)
   }
 
   return opening
 }
 
-async function getApplication(db: DatabaseManager, applicationDbId: string): Promise<WorkingGroupApplication> {
-  const application = await db.get(WorkingGroupApplication, { where: { id: applicationDbId } })
+async function getApplication(store: DatabaseManager, applicationstoreId: string): Promise<WorkingGroupApplication> {
+  const application = await store.get(WorkingGroupApplication, { where: { id: applicationstoreId } })
   if (!application) {
-    throw new Error(`Application not found by id ${applicationDbId}`)
+    throw new Error(`Application not found by id ${applicationstoreId}`)
   }
 
   return application
 }
 
-async function getWorker(db: DatabaseManager, workerDbId: string): Promise<Worker> {
-  const worker = await db.get(Worker, { where: { id: workerDbId } })
+async function getWorker(store: DatabaseManager, workerstoreId: string): Promise<Worker> {
+  const worker = await store.get(Worker, { where: { id: workerstoreId } })
   if (!worker) {
-    throw new Error(`Worker not found by id ${workerDbId}`)
+    throw new Error(`Worker not found by id ${workerstoreId}`)
   }
 
   return worker
 }
 
 async function getApplicationFormQuestions(
-  db: DatabaseManager,
-  openingDbId: string
+  store: DatabaseManager,
+  openingstoreId: string
 ): Promise<ApplicationFormQuestion[]> {
-  const openingWithQuestions = await getOpening(db, openingDbId, ['metadata', 'metadata.applicationFormQuestions'])
+  const openingWithQuestions = await getOpening(store, openingstoreId, ['metadata', 'metadata.applicationFormQuestions'])
 
   if (!openingWithQuestions) {
-    throw new Error(`Opening not found by id: ${openingDbId}`)
+    throw new Error(`Opening not found by id: ${openingstoreId}`)
   }
   if (!openingWithQuestions.metadata.applicationFormQuestions) {
-    throw new Error(`Application form questions not found for opening: ${openingDbId}`)
+    throw new Error(`Application form questions not found for opening: ${openingstoreId}`)
   }
   return openingWithQuestions.metadata.applicationFormQuestions
 }
@@ -148,8 +154,8 @@ function parseQuestionInputType(
 }
 
 async function createOpeningMeta(
-  db: DatabaseManager,
-  event_: SubstrateEvent,
+  store: DatabaseManager,
+  event: SubstrateEvent,
   originalMeta: Bytes | IOpeningMetadata
 ): Promise<WorkingGroupOpeningMetadata> {
   let originallyValid: boolean
@@ -162,7 +168,7 @@ async function createOpeningMeta(
     metadata = originalMeta
     originallyValid = true
   }
-  const eventTime = new Date(event_.blockTimestamp)
+  const eventTime = new Date(event.blockTimestamp)
 
   const {
     applicationFormQuestions,
@@ -185,7 +191,7 @@ async function createOpeningMeta(
     applicationFormQuestions: [],
   })
 
-  await db.save<WorkingGroupOpeningMetadata>(openingMetadata)
+  await store.save<WorkingGroupOpeningMetadata>(openingMetadata)
 
   await Promise.all(
     (applicationFormQuestions || []).map(async ({ question, type }, index) => {
@@ -197,7 +203,7 @@ async function createOpeningMeta(
         index,
         openingMetadata,
       })
-      await db.save<ApplicationFormQuestion>(applicationFormQuestion)
+      await store.save<ApplicationFormQuestion>(applicationFormQuestion)
       return applicationFormQuestion
     })
   )
@@ -206,7 +212,7 @@ async function createOpeningMeta(
 }
 
 async function createApplicationQuestionAnswers(
-  db: DatabaseManager,
+  store: DatabaseManager,
   application: WorkingGroupApplication,
   metadataBytes: Bytes
 ) {
@@ -214,7 +220,7 @@ async function createApplicationQuestionAnswers(
   if (!metadata) {
     return
   }
-  const questions = await getApplicationFormQuestions(db, application.opening.id)
+  const questions = await getApplicationFormQuestions(store, application.opening.id)
   const { answers } = metadata
   await Promise.all(
     (answers || []).slice(0, questions.length).map(async (answer, index) => {
@@ -226,22 +232,22 @@ async function createApplicationQuestionAnswers(
         answer,
       })
 
-      await db.save<ApplicationFormQuestionAnswer>(applicationFormQuestionAnswer)
+      await store.save<ApplicationFormQuestionAnswer>(applicationFormQuestionAnswer)
       return applicationFormQuestionAnswer
     })
   )
 }
 
 async function handleAddUpcomingOpeningAction(
-  db: DatabaseManager,
-  event_: SubstrateEvent,
+  store: DatabaseManager,
+  event: SubstrateEvent,
   statusChangedEvent: StatusTextChangedEvent,
   action: IAddUpcomingOpening
 ): Promise<UpcomingOpeningAdded | InvalidActionMetadata> {
   const upcomingOpeningMeta = action.metadata || {}
-  const group = await getWorkingGroup(db, event_)
-  const eventTime = new Date(event_.blockTimestamp)
-  const openingMeta = await createOpeningMeta(db, event_, upcomingOpeningMeta.metadata || {})
+  const group = await getWorkingGroup(store, event)
+  const eventTime = new Date(event.blockTimestamp)
+  const openingMeta = await createOpeningMeta(store, event, upcomingOpeningMeta.metadata || {})
   const { rewardPerBlock, expectedStart, minApplicationStake } = upcomingOpeningMeta
   const upcomingOpening = new UpcomingWorkingGroupOpening({
     createdAt: eventTime,
@@ -253,7 +259,7 @@ async function handleAddUpcomingOpeningAction(
     stakeAmount: minApplicationStake?.toNumber() ? new BN(minApplicationStake.toString()) : undefined,
     createdInEvent: statusChangedEvent,
   })
-  await db.save<UpcomingWorkingGroupOpening>(upcomingOpening)
+  await store.save<UpcomingWorkingGroupOpening>(upcomingOpening)
 
   const result = new UpcomingOpeningAdded()
   result.upcomingOpeningId = upcomingOpening.id
@@ -262,16 +268,16 @@ async function handleAddUpcomingOpeningAction(
 }
 
 async function handleRemoveUpcomingOpeningAction(
-  db: DatabaseManager,
+  store: DatabaseManager,
   action: IRemoveUpcomingOpening
 ): Promise<UpcomingOpeningRemoved | InvalidActionMetadata> {
   const { id } = action
-  const upcomingOpening = await db.get(UpcomingWorkingGroupOpening, { where: { id } })
+  const upcomingOpening = await store.get(UpcomingWorkingGroupOpening, { where: { id } })
   let result: UpcomingOpeningRemoved | InvalidActionMetadata
   if (upcomingOpening) {
     result = new UpcomingOpeningRemoved()
     result.upcomingOpeningId = upcomingOpening.id
-    await db.remove<UpcomingWorkingGroupOpening>(upcomingOpening)
+    await store.remove<UpcomingWorkingGroupOpening>(upcomingOpening)
   } else {
     const error = `Cannot remove upcoming opening: Entity by id ${id} not found!`
     console.error(error)
@@ -282,15 +288,15 @@ async function handleRemoveUpcomingOpeningAction(
 }
 
 async function handleSetWorkingGroupMetadataAction(
-  db: DatabaseManager,
-  event_: SubstrateEvent,
+  store: DatabaseManager,
+  event: SubstrateEvent,
   statusChangedEvent: StatusTextChangedEvent,
   action: ISetGroupMetadata
 ): Promise<WorkingGroupMetadataSet> {
   const { newMetadata } = action
-  const group = await getWorkingGroup(db, event_, ['metadata'])
+  const group = await getWorkingGroup(store, event, ['metadata'])
   const oldMetadata = group.metadata
-  const eventTime = new Date(event_.blockTimestamp)
+  const eventTime = new Date(event.blockTimestamp)
   const setNewOptionalString = (field: keyof IWorkingGroupMetadata) =>
     typeof newMetadata?.[field] === 'string' ? newMetadata[field] || undefined : oldMetadata?.[field]
 
@@ -304,11 +310,11 @@ async function handleSetWorkingGroupMetadataAction(
     about: setNewOptionalString('about'),
     description: setNewOptionalString('description'),
   })
-  await db.save<WorkingGroupMetadata>(newGroupMetadata)
+  await store.save<WorkingGroupMetadata>(newGroupMetadata)
 
   group.metadata = newGroupMetadata
   group.updatedAt = eventTime
-  await db.save<WorkingGroup>(group)
+  await store.save<WorkingGroup>(group)
 
   const result = new WorkingGroupMetadataSet()
   result.metadataId = newGroupMetadata.id
@@ -317,17 +323,17 @@ async function handleSetWorkingGroupMetadataAction(
 }
 
 async function handleWorkingGroupMetadataAction(
-  db: DatabaseManager,
-  event_: SubstrateEvent,
+  store: DatabaseManager,
+  event: SubstrateEvent,
   statusChangedEvent: StatusTextChangedEvent,
   action: IWorkingGroupMetadataAction
 ): Promise<typeof WorkingGroupMetadataActionResult> {
   if (action.addUpcomingOpening) {
-    return handleAddUpcomingOpeningAction(db, event_, statusChangedEvent, action.addUpcomingOpening)
+    return handleAddUpcomingOpeningAction(store, event, statusChangedEvent, action.addUpcomingOpening)
   } else if (action.removeUpcomingOpening) {
-    return handleRemoveUpcomingOpeningAction(db, action.removeUpcomingOpening)
+    return handleRemoveUpcomingOpeningAction(store, action.removeUpcomingOpening)
   } else if (action.setGroupMetadata) {
-    return handleSetWorkingGroupMetadataAction(db, event_, statusChangedEvent, action.setGroupMetadata)
+    return handleSetWorkingGroupMetadataAction(store, event, statusChangedEvent, action.setGroupMetadata)
   } else {
     const result = new InvalidActionMetadata()
     result.reason = 'No known action was provided'
@@ -335,23 +341,23 @@ async function handleWorkingGroupMetadataAction(
   }
 }
 
-async function handleTerminatedWorker(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId, optPenalty, optRationale] = new WorkingGroups.TerminatedWorkerEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+async function handleTerminatedWorker({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId, optPenalty, optRationale] = new WorkingGroups.TerminatedWorkerEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const EventConstructor = worker.isLead ? TerminatedLeaderEvent : TerminatedWorkerEvent
 
   const terminatedEvent = new EventConstructor({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     penalty: optPenalty.unwrapOr(undefined),
     rationale: optRationale.isSome ? bytesToString(optRationale.unwrap()) : undefined,
   })
 
-  await db.save(terminatedEvent)
+  await store.save(terminatedEvent)
 
   const status = new WorkerStatusTerminated()
   status.terminatedWorkerEventId = terminatedEvent.id
@@ -360,11 +366,11 @@ async function handleTerminatedWorker(db: DatabaseManager, event_: SubstrateEven
   worker.rewardPerBlock = new BN(0)
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function findLeaderSetEventByTxHash(db: DatabaseManager, txHash?: string): Promise<LeaderSetEvent> {
-  const leaderSetEvent = await db.get(LeaderSetEvent, { where: { inExtrinsic: txHash } })
+export async function findLeaderSetEventByTxHash(store: DatabaseManager, txHash?: string): Promise<LeaderSetEvent> {
+  const leaderSetEvent = await store.get(LeaderSetEvent, { where: { inExtrinsic: txHash } })
 
   if (!leaderSetEvent) {
     throw new Error(`LeaderSet event not found by tx hash: ${txHash}`)
@@ -374,16 +380,16 @@ export async function findLeaderSetEventByTxHash(db: DatabaseManager, txHash?: s
 }
 
 // Mapping functions
-export async function workingGroups_OpeningAdded(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
+export async function workingGroups_OpeningAdded({ store, event }: EventContext & StoreContext ): Promise<void> {
   const [
     openingRuntimeId,
     metadataBytes,
     openingType,
     stakePolicy,
     optRewardPerBlock,
-  ] = new WorkingGroups.OpeningAddedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const eventTime = new Date(event_.blockTimestamp)
+  ] = new WorkingGroups.OpeningAddedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const eventTime = new Date(event.blockTimestamp)
 
   const opening = new WorkingGroupOpening({
     createdAt: eventTime,
@@ -399,22 +405,22 @@ export async function workingGroups_OpeningAdded(db: DatabaseManager, event_: Su
     type: openingType.isLeader ? WorkingGroupOpeningType.LEADER : WorkingGroupOpeningType.REGULAR,
   })
 
-  const metadata = await createOpeningMeta(db, event_, metadataBytes)
+  const metadata = await createOpeningMeta(store, event, metadataBytes)
   opening.metadata = metadata
 
-  await db.save<WorkingGroupOpening>(opening)
+  await store.save<WorkingGroupOpening>(opening)
 
   const openingAddedEvent = new OpeningAddedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     opening,
   })
 
-  await db.save<OpeningAddedEvent>(openingAddedEvent)
+  await store.save<OpeningAddedEvent>(openingAddedEvent)
 }
 
-export async function workingGroups_AppliedOnOpening(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_AppliedOnOpening({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const eventTime = new Date(event.blockTimestamp)
 
   const [
     {
@@ -426,17 +432,17 @@ export async function workingGroups_AppliedOnOpening(db: DatabaseManager, event_
       stake_parameters: { stake, staking_account_id: stakingAccount },
     },
     applicationRuntimeId,
-  ] = new WorkingGroups.AppliedOnOpeningEvent(event_).params
+  ] = new WorkingGroups.AppliedOnOpeningEvent(event).params
 
-  const group = await getWorkingGroup(db, event_)
-  const openingDbId = `${group.name}-${openingRuntimeId.toString()}`
+  const group = await getWorkingGroup(store, event)
+  const openingstoreId = `${group.name}-${openingRuntimeId.toString()}`
 
   const application = new WorkingGroupApplication({
     createdAt: eventTime,
     updatedAt: eventTime,
     id: `${group.name}-${applicationRuntimeId.toString()}`,
     runtimeId: applicationRuntimeId.toNumber(),
-    opening: new WorkingGroupOpening({ id: openingDbId }),
+    opening: new WorkingGroupOpening({ id: openingstoreId }),
     applicant: new Membership({ id: memberId.toString() }),
     rewardAccount: rewardAccount.toString(),
     roleAccount: roleAccout.toString(),
@@ -446,39 +452,39 @@ export async function workingGroups_AppliedOnOpening(db: DatabaseManager, event_
     stake,
   })
 
-  await db.save<WorkingGroupApplication>(application)
-  await createApplicationQuestionAnswers(db, application, metadataBytes)
+  await store.save<WorkingGroupApplication>(application)
+  await createApplicationQuestionAnswers(store, application, metadataBytes)
 
   const appliedOnOpeningEvent = new AppliedOnOpeningEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
-    opening: new WorkingGroupOpening({ id: openingDbId }),
+    opening: new WorkingGroupOpening({ id: openingstoreId }),
     application,
   })
 
-  await db.save<AppliedOnOpeningEvent>(appliedOnOpeningEvent)
+  await store.save<AppliedOnOpeningEvent>(appliedOnOpeningEvent)
 }
 
-export async function workingGroups_LeaderSet(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const group = await getWorkingGroup(db, event_)
+export async function workingGroups_LeaderSet({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const group = await getWorkingGroup(store, event)
 
   const leaderSetEvent = new LeaderSetEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
   })
 
-  await db.save<LeaderSetEvent>(leaderSetEvent)
+  await store.save<LeaderSetEvent>(leaderSetEvent)
 }
 
-export async function workingGroups_OpeningFilled(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_OpeningFilled({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const eventTime = new Date(event.blockTimestamp)
 
   const [openingRuntimeId, applicationIdToWorkerIdMap, applicationIdsSet] = new WorkingGroups.OpeningFilledEvent(
-    event_
+    event
   ).params
 
-  const group = await getWorkingGroup(db, event_)
-  const opening = await getOpening(db, `${group.name}-${openingRuntimeId.toString()}`, [
+  const group = await getWorkingGroup(store, event)
+  const opening = await getOpening(store, `${group.name}-${openingRuntimeId.toString()}`, [
     'applications',
     'applications.applicant',
   ])
@@ -486,12 +492,12 @@ export async function workingGroups_OpeningFilled(db: DatabaseManager, event_: S
 
   // Save the event
   const openingFilledEvent = new OpeningFilledEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     opening,
   })
 
-  await db.save<OpeningFilledEvent>(openingFilledEvent)
+  await store.save<OpeningFilledEvent>(openingFilledEvent)
 
   // Update applications and create new workers
   const hiredWorkers = (
@@ -505,7 +511,7 @@ export async function workingGroups_OpeningFilled(db: DatabaseManager, event_: S
           applicationStatus.openingFilledEventId = openingFilledEvent.id
           application.status = applicationStatus
           application.updatedAt = eventTime
-          await db.save<WorkingGroupApplication>(application)
+          await store.save<WorkingGroupApplication>(application)
           if (isAccepted) {
             // Cannot use "applicationIdToWorkerIdMap.get" here,
             // it only works if the passed instance is identical to BTreeMap key instance (=== instead of .eq)
@@ -536,7 +542,7 @@ export async function workingGroups_OpeningFilled(db: DatabaseManager, event_: S
               entry: openingFilledEvent,
               rewardPerBlock: opening.rewardPerBlock,
             })
-            await db.save<Worker>(worker)
+            await store.save<Worker>(worker)
             return worker
           }
         })
@@ -548,36 +554,36 @@ export async function workingGroups_OpeningFilled(db: DatabaseManager, event_: S
   openingFilled.openingFilledEventId = openingFilledEvent.id
   opening.status = openingFilled
   opening.updatedAt = eventTime
-  await db.save<WorkingGroupOpening>(opening)
+  await store.save<WorkingGroupOpening>(opening)
 
   // Update working group and LeaderSetEvent if necessary
   if (opening.type === WorkingGroupOpeningType.LEADER && hiredWorkers.length) {
     group.leader = hiredWorkers[0]
     group.updatedAt = eventTime
-    await db.save<WorkingGroup>(group)
+    await store.save<WorkingGroup>(group)
 
-    const leaderSetEvent = await findLeaderSetEventByTxHash(db, openingFilledEvent.inExtrinsic)
+    const leaderSetEvent = await findLeaderSetEventByTxHash(store, openingFilledEvent.inExtrinsic)
     leaderSetEvent.worker = hiredWorkers[0]
     leaderSetEvent.updatedAt = eventTime
-    await db.save<LeaderSetEvent>(leaderSetEvent)
+    await store.save<LeaderSetEvent>(leaderSetEvent)
   }
 }
 
-export async function workingGroups_OpeningCanceled(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [openingRuntimeId] = new WorkingGroups.OpeningCanceledEvent(event_).params
+export async function workingGroups_OpeningCanceled({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [openingRuntimeId] = new WorkingGroups.OpeningCanceledEvent(event).params
 
-  const group = await getWorkingGroup(db, event_)
-  const opening = await getOpening(db, `${group.name}-${openingRuntimeId.toString()}`, ['applications'])
-  const eventTime = new Date(event_.blockTimestamp)
+  const group = await getWorkingGroup(store, event)
+  const opening = await getOpening(store, `${group.name}-${openingRuntimeId.toString()}`, ['applications'])
+  const eventTime = new Date(event.blockTimestamp)
 
   // Create and save event
   const openingCanceledEvent = new OpeningCanceledEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     opening,
   })
 
-  await db.save<OpeningCanceledEvent>(openingCanceledEvent)
+  await store.save<OpeningCanceledEvent>(openingCanceledEvent)
 
   // Set opening status
   const openingCancelled = new OpeningStatusCancelled()
@@ -585,7 +591,7 @@ export async function workingGroups_OpeningCanceled(db: DatabaseManager, event_:
   opening.status = openingCancelled
   opening.updatedAt = eventTime
 
-  await db.save<WorkingGroupOpening>(opening)
+  await store.save<WorkingGroupOpening>(opening)
 
   // Set applications status
   const applicationCancelled = new ApplicationStatusCancelled()
@@ -597,26 +603,26 @@ export async function workingGroups_OpeningCanceled(db: DatabaseManager, event_:
       .map(async (application) => {
         application.status = applicationCancelled
         application.updatedAt = eventTime
-        await db.save<WorkingGroupApplication>(application)
+        await store.save<WorkingGroupApplication>(application)
       })
   )
 }
 
-export async function workingGroups_ApplicationWithdrawn(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [applicationRuntimeId] = new WorkingGroups.ApplicationWithdrawnEvent(event_).params
+export async function workingGroups_ApplicationWithdrawn({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [applicationRuntimeId] = new WorkingGroups.ApplicationWithdrawnEvent(event).params
 
-  const group = await getWorkingGroup(db, event_)
-  const application = await getApplication(db, `${group.name}-${applicationRuntimeId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+  const group = await getWorkingGroup(store, event)
+  const application = await getApplication(store, `${group.name}-${applicationRuntimeId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   // Create and save event
   const applicationWithdrawnEvent = new ApplicationWithdrawnEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     application,
   })
 
-  await db.save<ApplicationWithdrawnEvent>(applicationWithdrawnEvent)
+  await store.save<ApplicationWithdrawnEvent>(applicationWithdrawnEvent)
 
   // Set application status
   const statusWithdrawn = new ApplicationStatusWithdrawn()
@@ -624,32 +630,32 @@ export async function workingGroups_ApplicationWithdrawn(db: DatabaseManager, ev
   application.status = statusWithdrawn
   application.updatedAt = eventTime
 
-  await db.save<WorkingGroupApplication>(application)
+  await store.save<WorkingGroupApplication>(application)
 }
 
-export async function workingGroups_StatusTextChanged(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [, optBytes] = new WorkingGroups.StatusTextChangedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
+export async function workingGroups_StatusTextChanged({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [, optBytes] = new WorkingGroups.StatusTextChangedEvent(event).params
+  const group = await getWorkingGroup(store, event)
 
   // Since result cannot be empty at this point, but we already need to have an existing StatusTextChangedEvent
   // in order to be able to create UpcomingOpening.createdInEvent relation, we use a temporary "mock" result
   const mockResult = new InvalidActionMetadata()
   mockResult.reason = 'Metadata not yet processed'
   const statusTextChangedEvent = new StatusTextChangedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     metadata: optBytes.isSome ? optBytes.unwrap().toString() : undefined,
     result: mockResult,
   })
 
-  await db.save<StatusTextChangedEvent>(statusTextChangedEvent)
+  await store.save<StatusTextChangedEvent>(statusTextChangedEvent)
 
   let result: typeof WorkingGroupMetadataActionResult
 
   if (optBytes.isSome) {
     const metadata = deserializeMetadata(WorkingGroupMetadataAction, optBytes.unwrap())
     if (metadata) {
-      result = await handleWorkingGroupMetadataAction(db, event_, statusTextChangedEvent, metadata)
+      result = await handleWorkingGroupMetadataAction(store, event, statusTextChangedEvent, metadata)
     } else {
       result = new InvalidActionMetadata()
       result.reason = 'Invalid metadata: Cannot deserialize metadata binary'
@@ -663,86 +669,86 @@ export async function workingGroups_StatusTextChanged(db: DatabaseManager, event
 
   // Now we can set the "real" result
   statusTextChangedEvent.result = result
-  await db.save<StatusTextChangedEvent>(statusTextChangedEvent)
+  await store.save<StatusTextChangedEvent>(statusTextChangedEvent)
 }
 
 export async function workingGroups_WorkerRoleAccountUpdated(
-  db: DatabaseManager,
-  event_: SubstrateEvent
+  store: DatabaseManager,
+  event: SubstrateEvent
 ): Promise<void> {
-  const [workerId, accountId] = new WorkingGroups.WorkerRoleAccountUpdatedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+  const [workerId, accountId] = new WorkingGroups.WorkerRoleAccountUpdatedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerRoleAccountUpdatedEvent = new WorkerRoleAccountUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     newRoleAccount: accountId.toString(),
   })
 
-  await db.save<WorkerRoleAccountUpdatedEvent>(workerRoleAccountUpdatedEvent)
+  await store.save<WorkerRoleAccountUpdatedEvent>(workerRoleAccountUpdatedEvent)
 
   worker.roleAccount = accountId.toString()
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
 export async function workingGroups_WorkerRewardAccountUpdated(
-  db: DatabaseManager,
-  event_: SubstrateEvent
+  store: DatabaseManager,
+  event: SubstrateEvent
 ): Promise<void> {
-  const [workerId, accountId] = new WorkingGroups.WorkerRewardAccountUpdatedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+  const [workerId, accountId] = new WorkingGroups.WorkerRewardAccountUpdatedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerRewardAccountUpdatedEvent = new WorkerRewardAccountUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     newRewardAccount: accountId.toString(),
   })
 
-  await db.save<WorkerRoleAccountUpdatedEvent>(workerRewardAccountUpdatedEvent)
+  await store.save<WorkerRoleAccountUpdatedEvent>(workerRewardAccountUpdatedEvent)
 
   worker.rewardAccount = accountId.toString()
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_StakeIncreased(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId, increaseAmount] = new WorkingGroups.StakeIncreasedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_StakeIncreased({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId, increaseAmount] = new WorkingGroups.StakeIncreasedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const stakeIncreasedEvent = new StakeIncreasedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     amount: increaseAmount,
   })
 
-  await db.save<StakeIncreasedEvent>(stakeIncreasedEvent)
+  await store.save<StakeIncreasedEvent>(stakeIncreasedEvent)
 
   worker.stake = worker.stake.add(increaseAmount)
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_RewardPaid(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId, rewardAccountId, amount, rewardPaymentType] = new WorkingGroups.RewardPaidEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_RewardPaid({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId, rewardAccountId, amount, rewardPaymentType] = new WorkingGroups.RewardPaidEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const rewardPaidEvent = new RewardPaidEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     amount,
@@ -750,118 +756,118 @@ export async function workingGroups_RewardPaid(db: DatabaseManager, event_: Subs
     type: rewardPaymentType.isRegularReward ? RewardPaymentType.REGULAR : RewardPaymentType.MISSED,
   })
 
-  await db.save<RewardPaidEvent>(rewardPaidEvent)
+  await store.save<RewardPaidEvent>(rewardPaidEvent)
 
   // Update group budget
   group.budget = group.budget.sub(amount)
   group.updatedAt = eventTime
 
-  await db.save<WorkingGroup>(group)
+  await store.save<WorkingGroup>(group)
 }
 
 export async function workingGroups_NewMissedRewardLevelReached(
-  db: DatabaseManager,
-  event_: SubstrateEvent
+  store: DatabaseManager,
+  event: SubstrateEvent
 ): Promise<void> {
-  const [workerId, newMissedRewardAmountOpt] = new WorkingGroups.NewMissedRewardLevelReachedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+  const [workerId, newMissedRewardAmountOpt] = new WorkingGroups.NewMissedRewardLevelReachedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const newMissedRewardLevelReachedEvent = new NewMissedRewardLevelReachedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     newMissedRewardAmount: newMissedRewardAmountOpt.unwrapOr(new BN(0)),
   })
 
-  await db.save<NewMissedRewardLevelReachedEvent>(newMissedRewardLevelReachedEvent)
+  await store.save<NewMissedRewardLevelReachedEvent>(newMissedRewardLevelReachedEvent)
 
   // Update worker
   worker.missingRewardAmount = newMissedRewardAmountOpt.unwrapOr(undefined)
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_WorkerExited(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId] = new WorkingGroups.WorkerExitedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_WorkerExited({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId] = new WorkingGroups.WorkerExitedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerExitedEvent = new WorkerExitedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
   })
 
-  await db.save<WorkerExitedEvent>(workerExitedEvent)
+  await store.save<WorkerExitedEvent>(workerExitedEvent)
   ;(worker.status as WorkerStatusLeft).workerExitedEventId = workerExitedEvent.id
   worker.stake = new BN(0)
   worker.rewardPerBlock = new BN(0)
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_LeaderUnset(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const group = await getWorkingGroup(db, event_)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_LeaderUnset({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const group = await getWorkingGroup(store, event)
+  const eventTime = new Date(event.blockTimestamp)
 
   const leaderUnsetEvent = new LeaderUnsetEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     leader: group.leader,
   })
 
-  await db.save<LeaderUnsetEvent>(leaderUnsetEvent)
+  await store.save<LeaderUnsetEvent>(leaderUnsetEvent)
 
   group.leader = undefined
   group.updatedAt = eventTime
 
-  await db.save<WorkingGroup>(group)
+  await store.save<WorkingGroup>(group)
 }
 
-export async function workingGroups_TerminatedWorker(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  await handleTerminatedWorker(db, event_)
+export async function workingGroups_TerminatedWorker(ctx: EventContext & StoreContext ): Promise<void> {
+  await handleTerminatedWorker(ctx)
 }
-export async function workingGroups_TerminatedLeader(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  await handleTerminatedWorker(db, event_)
+export async function workingGroups_TerminatedLeader(ctx: EventContext & StoreContext ): Promise<void> {
+  await handleTerminatedWorker(ctx)
 }
 
 export async function workingGroups_WorkerRewardAmountUpdated(
-  db: DatabaseManager,
-  event_: SubstrateEvent
+  store: DatabaseManager,
+  event: SubstrateEvent
 ): Promise<void> {
-  const [workerId, newRewardPerBlockOpt] = new WorkingGroups.WorkerRewardAmountUpdatedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+  const [workerId, newRewardPerBlockOpt] = new WorkingGroups.WorkerRewardAmountUpdatedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerRewardAmountUpdatedEvent = new WorkerRewardAmountUpdatedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     newRewardPerBlock: newRewardPerBlockOpt.unwrapOr(new BN(0)),
   })
 
-  await db.save<WorkerRewardAmountUpdatedEvent>(workerRewardAmountUpdatedEvent)
+  await store.save<WorkerRewardAmountUpdatedEvent>(workerRewardAmountUpdatedEvent)
 
   worker.rewardPerBlock = newRewardPerBlockOpt.unwrapOr(new BN(0))
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_StakeSlashed(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId, slashedAmount, requestedAmount, optRationale] = new WorkingGroups.StakeSlashedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_StakeSlashed({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId, slashedAmount, requestedAmount, optRationale] = new WorkingGroups.StakeSlashedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerStakeSlashedEvent = new StakeSlashedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     requestedAmount,
@@ -869,94 +875,94 @@ export async function workingGroups_StakeSlashed(db: DatabaseManager, event_: Su
     rationale: optRationale.isSome ? bytesToString(optRationale.unwrap()) : undefined,
   })
 
-  await db.save<StakeSlashedEvent>(workerStakeSlashedEvent)
+  await store.save<StakeSlashedEvent>(workerStakeSlashedEvent)
 
   worker.stake = worker.stake.sub(slashedAmount)
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_StakeDecreased(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId, amount] = new WorkingGroups.StakeDecreasedEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_StakeDecreased({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId, amount] = new WorkingGroups.StakeDecreasedEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerStakeDecreasedEvent = new StakeDecreasedEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     amount,
   })
 
-  await db.save<StakeDecreasedEvent>(workerStakeDecreasedEvent)
+  await store.save<StakeDecreasedEvent>(workerStakeDecreasedEvent)
 
   worker.stake = worker.stake.sub(amount)
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_WorkerStartedLeaving(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [workerId, optRationale] = new WorkingGroups.WorkerStartedLeavingEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const worker = await getWorker(db, `${group.name}-${workerId.toString()}`)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_WorkerStartedLeaving({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [workerId, optRationale] = new WorkingGroups.WorkerStartedLeavingEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const worker = await getWorker(store, `${group.name}-${workerId.toString()}`)
+  const eventTime = new Date(event.blockTimestamp)
 
   const workerStartedLeavingEvent = new WorkerStartedLeavingEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     worker,
     rationale: optRationale.isSome ? bytesToString(optRationale.unwrap()) : undefined,
   })
 
-  await db.save<WorkerStartedLeavingEvent>(workerStartedLeavingEvent)
+  await store.save<WorkerStartedLeavingEvent>(workerStartedLeavingEvent)
 
   const status = new WorkerStatusLeft()
   status.workerStartedLeavingEventId = workerStartedLeavingEvent.id
   worker.status = status
   worker.updatedAt = eventTime
 
-  await db.save<Worker>(worker)
+  await store.save<Worker>(worker)
 }
 
-export async function workingGroups_BudgetSet(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [newBudget] = new WorkingGroups.BudgetSetEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_BudgetSet({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [newBudget] = new WorkingGroups.BudgetSetEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const eventTime = new Date(event.blockTimestamp)
 
   const budgetSetEvent = new BudgetSetEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     newBudget,
   })
 
-  await db.save<BudgetSetEvent>(budgetSetEvent)
+  await store.save<BudgetSetEvent>(budgetSetEvent)
 
   group.budget = newBudget
   group.updatedAt = eventTime
 
-  await db.save<WorkingGroup>(group)
+  await store.save<WorkingGroup>(group)
 }
 
-export async function workingGroups_BudgetSpending(db: DatabaseManager, event_: SubstrateEvent): Promise<void> {
-  const [reciever, amount, optRationale] = new WorkingGroups.BudgetSpendingEvent(event_).params
-  const group = await getWorkingGroup(db, event_)
-  const eventTime = new Date(event_.blockTimestamp)
+export async function workingGroups_BudgetSpending({ store, event }: EventContext & StoreContext ): Promise<void> {
+  const [reciever, amount, optRationale] = new WorkingGroups.BudgetSpendingEvent(event).params
+  const group = await getWorkingGroup(store, event)
+  const eventTime = new Date(event.blockTimestamp)
 
   const budgetSpendingEvent = new BudgetSpendingEvent({
-    ...genericEventFields(event_),
+    ...genericEventFields(event),
     group,
     amount,
     reciever: reciever.toString(),
     rationale: optRationale.isSome ? bytesToString(optRationale.unwrap()) : undefined,
   })
 
-  await db.save<BudgetSpendingEvent>(budgetSpendingEvent)
+  await store.save<BudgetSpendingEvent>(budgetSpendingEvent)
 
   group.budget = group.budget.sub(amount)
   group.updatedAt = eventTime
 
-  await db.save<WorkingGroup>(group)
+  await store.save<WorkingGroup>(group)
 }