identity

enjin · Apr 20, 2024 · dc09123 · dc09123
1 parent 600d8a6
commit dc09123
Show file tree

Hide file tree

Showing 7 changed files with 104 additions and 171 deletions.
diff --git a/src/mappings/claims/common.ts b/src/mappings/claims/common.ts
@@ -1,56 +1,41 @@
-import { SubstrateBlock } from '@subsquid/substrate-processor'
-import { CommonContext } from '../types/contexts'
+import { CommonContext, BlockHeader } from '../types/contexts'
 import { UnknownVersionError } from '../../common/errors'
-import {
-    ClaimsDelayClaimsPeriodStorage,
-    ClaimsExchangeRateStorage,
-    ClaimsTotalUnclaimedAmountStorage,
-} from '../../types/generated/storage'
+import { claims } from '../../types/generated/storage'
 import { ClaimDetails } from '../../model'
 
-export async function getTotalUnclaimedAmount(ctx: CommonContext, block: SubstrateBlock) {
-    const data = new ClaimsTotalUnclaimedAmountStorage(ctx, block)
-
-    if (!data.isExists) {
-        return 0n
-    }
-
-    if (data.isMatrixEnjinV603) {
-        return data.asMatrixEnjinV603.get()
+export async function getTotalUnclaimedAmount(ctx: CommonContext, block: BlockHeader) {
+    if (claims.totalUnclaimedAmount.matrixEnjinV603.is(block)) {
+        return claims.totalUnclaimedAmount.matrixEnjinV603.get(block)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    return BigInt(0)
 }
 
-async function getDelayPeriod(ctx: CommonContext, block: SubstrateBlock) {
-    const data = new ClaimsDelayClaimsPeriodStorage(ctx, block)
-
-    if (data.isMatrixEnjinV603) {
-        return data.asMatrixEnjinV603.get()
+async function getDelayPeriod(ctx: CommonContext, block: BlockHeader) {
+    if (claims.delayClaimsPeriod.matrixEnjinV603.is(block)) {
+        return claims.delayClaimsPeriod.matrixEnjinV603.get(block)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError('Claims.TotalUnclaimedAmount')
 }
 
-async function getExchangeRate(ctx: CommonContext, block: SubstrateBlock) {
-    const data = new ClaimsExchangeRateStorage(ctx, block)
-
-    if (data.isMatrixEnjinV603) {
-        return data.asMatrixEnjinV603.get()
+async function getExchangeRate(ctx: CommonContext, block: BlockHeader) {
+    if (claims.exchangeRate.matrixEnjinV603.is(block)) {
+        return claims.exchangeRate.matrixEnjinV603.get(block)
     }
 
-    if (data.isV604) {
-        return data.asV604.get()
+    if (claims.exchangeRate.v604.is(block)) {
+        return claims.exchangeRate.v604.get(block)
     }
 
-    if (data.isV500) {
-        return data.asV500.get()
+    if (claims.exchangeRate.v500.is(block)) {
+        return claims.exchangeRate.v500.get(block)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError('Claims.ExchangeRate')
 }
 
-export async function updateClaimDetails(ctx: CommonContext, block: SubstrateBlock) {
+export async function updateClaimDetails(ctx: CommonContext, block: BlockHeader) {
     const rate = await getExchangeRate(ctx, block)
     const claimDetails = new ClaimDetails({
         id: '0',
@@ -59,5 +44,5 @@ export async function updateClaimDetails(ctx: CommonContext, block: SubstrateBlo
         exchangeRate: typeof rate === 'bigint' ? null : rate,
     })
 
-    await ctx.store.save(ClaimDetails, claimDetails as any)
+    await ctx.store.save(claimDetails)
 }
diff --git a/src/mappings/identity/events/identityKilled.ts b/src/mappings/identity/events/identityKilled.ts
@@ -1,28 +1,18 @@
-import { SubstrateBlock } from '@subsquid/substrate-processor'
-import { EventItem } from '@subsquid/substrate-processor/lib/interfaces/dataSelection'
-import { u8aToHex } from '@polkadot/util'
 import { UnknownVersionError } from '../../../common/errors'
-import { IdentityIdentityKilledEvent } from '../../../types/generated/events'
+import { events } from '../../../types/generated'
 import { Event as EventModel, Identity, Registration } from '../../../model'
-import { Event } from '../../../types/generated/support'
-import { CommonContext } from '../../types/contexts'
+import { CommonContext, EventItem, BlockHeader } from '../../types/contexts'
 
-function getEventData(ctx: CommonContext, event: Event) {
-    const data = new IdentityIdentityKilledEvent(ctx, event)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getEventData(event: EventItem) {
+    if (events.identity.identityKilled.matrixEnjinV1000.is(event)) {
+        return events.identity.identityKilled.matrixEnjinV1000.decode(event)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(events.identity.identityKilled.name)
 }
 
-export async function identityKilled(
-    ctx: CommonContext,
-    block: SubstrateBlock,
-    item: EventItem<'Identity.IdentityKilled', { event: { args: true; extrinsic: true } }>
-): Promise<EventModel | undefined> {
-    const eventData = getEventData(ctx, item.event)
+export async function identityKilled(ctx: CommonContext, block: BlockHeader, item: EventItem): Promise<EventModel | undefined> {
+    const eventData = getEventData(item)
 
     const identity = await ctx.store.findOneOrFail(Identity, {
         relations: {
@@ -31,9 +21,9 @@ export async function identityKilled(
                 info: true,
             },
         },
-        where: { id: u8aToHex(eventData.who) },
+        where: { id: eventData.who },
     })
-    await ctx.store.delete(Registration, { id: u8aToHex(eventData.who) })
+    await ctx.store.delete(Registration, { id: eventData.who })
 
     await Promise.all(
         identity.sub.map(async (sub) => {
@@ -50,10 +40,10 @@ export async function identityKilled(
 
         await ctx.store.save(identity)
     } else {
-        await ctx.store.remove(Identity, identity)
+        await ctx.store.remove(identity)
     }
 
-    await ctx.store.delete(Registration, { id: u8aToHex(eventData.who) })
+    await ctx.store.delete(Registration, { id: eventData.who })
 
     return undefined
 }
diff --git a/src/mappings/identity/events/identitySet.ts b/src/mappings/identity/events/identitySet.ts
@@ -1,52 +1,40 @@
-import { SubstrateBlock } from '@subsquid/substrate-processor'
-import { EventItem } from '@subsquid/substrate-processor/lib/interfaces/dataSelection'
-import { u8aToHex, u8aToString } from '@polkadot/util'
+import { hexToString } from '@polkadot/util'
 import { CallNotDefinedError, UnknownVersionError } from '../../../common/errors'
-import { IdentityIdentitySetEvent } from '../../../types/generated/events'
+import { calls, events } from '../../../types/generated'
 import { Event as EventModel, Identity, JudgementType, Registration } from '../../../model'
-import { Call, Event } from '../../../types/generated/support'
-import { CommonContext } from '../../types/contexts'
+import { CommonContext, BlockHeader, CallItem, EventItem } from '../../types/contexts'
 import { getOrCreateAccount } from '../../util/entities'
-import { IdentitySetIdentityCall } from '../../../types/generated/calls'
 import { Data } from '../../../types/generated/v1003'
 
-function getEventData(ctx: CommonContext, event: Event) {
-    const data = new IdentityIdentitySetEvent(ctx, event)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getEventData(event: EventItem) {
+    if (events.identity.identitySet.matrixEnjinV1000.is(event)) {
+        return events.identity.identitySet.matrixEnjinV1000.decode(event)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(events.identity.identitySet.name)
 }
 
-function getCallData(ctx: CommonContext, call: Call) {
-    const data = new IdentitySetIdentityCall(ctx, call)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getCallData(call: CallItem) {
+    if (calls.identity.setIdentity.matrixEnjinV1000.is(call)) {
+        return calls.identity.setIdentity.matrixEnjinV1000.decode(call)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(calls.identity.setIdentity.name)
 }
 
 const dataToValue = (raw: Data) => {
     if (raw.__kind !== 'None') {
-        return u8aToString(raw.value)
+        return hexToString(raw.value)
     }
 
     return null
 }
 
-export async function identitySet(
-    ctx: CommonContext,
-    block: SubstrateBlock,
-    item: EventItem<'Identity.IdentitySet', { event: { args: true; call: true; extrinsic: true } }>
-): Promise<EventModel | undefined> {
-    if (!item.event.call) throw new CallNotDefinedError()
+export async function identitySet(ctx: CommonContext, block: BlockHeader, item: EventItem): Promise<EventModel | undefined> {
+    if (!item.call) throw new CallNotDefinedError()
 
-    const eventData = getEventData(ctx, item.event)
-    const callData = getCallData(ctx, item.event.call)
+    const eventData = getEventData(item)
+    const callData = getCallData(item.call)
 
     const account = await getOrCreateAccount(ctx, eventData.who)
     let additional: { key: string | null; value: string | null }[] = []
@@ -70,11 +58,11 @@ export async function identitySet(
         email: dataToValue(callData.info.email),
         twitter: dataToValue(callData.info.twitter),
         image: dataToValue(callData.info.image),
-        pgpFingerprint: u8aToHex(callData.info.pgpFingerprint),
+        pgpFingerprint: callData.info.pgpFingerprint,
         currentJudgement: JudgementType.Unknown,
         judgements: [],
         deposit: 0n,
-        createdAt: new Date(block.timestamp),
+        createdAt: new Date(block.timestamp ?? 0),
     })
 
     const identity = new Identity({
@@ -83,7 +71,7 @@ export async function identitySet(
         isSub: false,
         name: dataToValue(callData.info.display) || dataToValue(callData.info.legal),
         info: registeration,
-        createdAt: new Date(block.timestamp),
+        createdAt: new Date(block.timestamp ?? 0),
     })
 
     await ctx.store.save(registeration)

diff --git a/src/mappings/identity/events/judgementGiven.ts b/src/mappings/identity/events/judgementGiven.ts
@@ -1,42 +1,30 @@
-import { SubstrateBlock } from '@subsquid/substrate-processor'
-import { EventItem } from '@subsquid/substrate-processor/lib/interfaces/dataSelection'
 import { CallNotDefinedError, UnknownVersionError } from '../../../common/errors'
-import { IdentityJudgementGivenEvent } from '../../../types/generated/events'
+import { events, calls } from '../../../types/generated'
 import { Event as EventModel, Judgement, JudgementType, Registration } from '../../../model'
-import { Call, Event } from '../../../types/generated/support'
-import { CommonContext } from '../../types/contexts'
+import { CommonContext, BlockHeader, EventItem, CallItem } from '../../types/contexts'
 import { getOrCreateAccount } from '../../util/entities'
-import { IdentityProvideJudgementCall } from '../../../types/generated/calls'
 
-function getEventData(ctx: CommonContext, event: Event) {
-    const data = new IdentityJudgementGivenEvent(ctx, event)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getEventData(event: EventItem) {
+    if (events.identity.judgementGiven.matrixEnjinV1000.is(event)) {
+        return events.identity.judgementGiven.matrixEnjinV1000.decode(event)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(events.identity.judgementGiven.name)
 }
 
-function getCallData(ctx: CommonContext, call: Call) {
-    const data = new IdentityProvideJudgementCall(ctx, call)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getCallData(call: CallItem) {
+    if (calls.identity.provideJudgement.matrixEnjinV1000.is(call)) {
+        return calls.identity.provideJudgement.matrixEnjinV1000.decode(call)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(calls.identity.provideJudgement.name)
 }
 
-export async function judgementGiven(
-    ctx: CommonContext,
-    block: SubstrateBlock,
-    item: EventItem<'Identity.JudgementGiven', { event: { args: true; call: true; extrinsic: true } }>
-): Promise<EventModel | undefined> {
-    if (!item.event.call) throw new CallNotDefinedError()
+export async function judgementGiven(ctx: CommonContext, block: BlockHeader, item: EventItem): Promise<EventModel | undefined> {
+    if (!item.call) throw new CallNotDefinedError()
 
-    const eventData = getEventData(ctx, item.event)
-    const callData = getCallData(ctx, item.event.call)
+    const eventData = getEventData(item)
+    const callData = getCallData(item.call)
 
     const account = await getOrCreateAccount(ctx, eventData.target)
 
@@ -46,13 +34,13 @@ export async function judgementGiven(
     const existing = registeration.judgements?.find((i) => i.index === eventData.registrarIndex)
     if (existing) {
         existing.value = JudgementType[callData.judgement.__kind]
-        existing.createdAt = new Date(block.timestamp)
+        existing.createdAt = new Date(block.timestamp ?? 0)
     } else {
         registeration.judgements?.push(
             new Judgement({
                 index: eventData.registrarIndex,
                 value: JudgementType[callData.judgement.__kind],
-                createdAt: new Date(block.timestamp),
+                createdAt: new Date(block.timestamp ?? 0),
             })
         )
     }

diff --git a/src/mappings/identity/events/judgementRequested.ts b/src/mappings/identity/events/judgementRequested.ts
@@ -1,28 +1,23 @@
-import { SubstrateBlock } from '@subsquid/substrate-processor'
-import { EventItem } from '@subsquid/substrate-processor/lib/interfaces/dataSelection'
 import { UnknownVersionError } from '../../../common/errors'
-import { IdentityJudgementRequestedEvent } from '../../../types/generated/events'
+import { identity } from '../../../types/generated/events'
 import { Event as EventModel, Judgement, JudgementType, Registration } from '../../../model'
-import { Event } from '../../../types/generated/support'
-import { CommonContext } from '../../types/contexts'
+import { CommonContext, BlockHeader, EventItem } from '../../types/contexts'
 import { getOrCreateAccount } from '../../util/entities'
 
-function getEventData(ctx: CommonContext, event: Event) {
-    const data = new IdentityJudgementRequestedEvent(ctx, event)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getEventData(event: EventItem) {
+    if (identity.judgementRequested.matrixEnjinV1000.is(event)) {
+        return identity.judgementRequested.matrixEnjinV1000.decode(event)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(identity.judgementRequested.name)
 }
 
 export async function judgementRequested(
     ctx: CommonContext,
-    block: SubstrateBlock,
-    item: EventItem<'Identity.JudgementRequested', { event: { args: true; extrinsic: true } }>
+    block: BlockHeader,
+    item: EventItem
 ): Promise<EventModel | undefined> {
-    const eventData = getEventData(ctx, item.event)
+    const eventData = getEventData(item)
 
     const account = await getOrCreateAccount(ctx, eventData.who)
 
@@ -37,7 +32,7 @@ export async function judgementRequested(
             new Judgement({
                 index: eventData.registrarIndex,
                 value: JudgementType.FeePaid,
-                createdAt: new Date(block.timestamp),
+                createdAt: new Date(block.timestamp ?? 0),
             })
         )
     }

diff --git a/src/mappings/identity/events/judgementUnrequested.ts b/src/mappings/identity/events/judgementUnrequested.ts
@@ -1,28 +1,23 @@
-import { SubstrateBlock } from '@subsquid/substrate-processor'
-import { EventItem } from '@subsquid/substrate-processor/lib/interfaces/dataSelection'
 import { UnknownVersionError } from '../../../common/errors'
-import { IdentityJudgementUnrequestedEvent } from '../../../types/generated/events'
+import { identity } from '../../../types/generated/events'
 import { Event as EventModel, JudgementType, Registration } from '../../../model'
-import { Event } from '../../../types/generated/support'
-import { CommonContext } from '../../types/contexts'
+import { CommonContext, BlockHeader, EventItem } from '../../types/contexts'
 import { getOrCreateAccount } from '../../util/entities'
 
-function getEventData(ctx: CommonContext, event: Event) {
-    const data = new IdentityJudgementUnrequestedEvent(ctx, event)
-
-    if (data.isMatrixEnjinV1000) {
-        return data.asMatrixEnjinV1000
+function getEventData(event: EventItem) {
+    if (identity.judgementUnrequested.matrixEnjinV1000.is(event)) {
+        return identity.judgementUnrequested.matrixEnjinV1000.decode(event)
     }
 
-    throw new UnknownVersionError(data.constructor.name)
+    throw new UnknownVersionError(identity.judgementUnrequested.name)
 }
 
 export async function judgementUnrequested(
     ctx: CommonContext,
-    block: SubstrateBlock,
-    item: EventItem<'Identity.JudgementUnrequested', { event: { args: true; extrinsic: true } }>
+    block: BlockHeader,
+    item: EventItem
 ): Promise<EventModel | undefined> {
-    const eventData = getEventData(ctx, item.event)
+    const eventData = getEventData(item)
 
     const account = await getOrCreateAccount(ctx, eventData.who)