feat: registry processor

apps/indexer/config.yaml

@@ -15,17 +15,20 @@ contracts:
       handler: src/handlers/Allo.ts
       events:
           - event: PoolCreated(uint256 indexed poolId, bytes32 indexed profileId, address strategy, address token, uint256 amount, (uint256,string) metadata)
-          - event: RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember)
           - event: PoolMetadataUpdated(uint256 indexed poolId, (uint256,string) metadata)
           - event: PoolFunded(uint256 indexed poolId, uint256 amount, uint256 fee)
-          - event: RoleRevoked(uint64 indexed roleId, address indexed account)
+          - event: RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
+          - event: RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
     - name: Registry
       handler: src/handlers/Registry.ts
       events:
           - event: ProfileCreated(bytes32 indexed profileId, uint256 nonce, string name, (uint256,string) metadata, address owner, address anchor)
           - event: ProfileMetadataUpdated(bytes32 indexed profileId, (uint256,string) metadata)
           - event: ProfileNameUpdated(bytes32 indexed profileId, string name, address anchor)
           - event: ProfileOwnerUpdated(bytes32 indexed profileId, address owner)
+          - event: RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
+          - event: RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
+
     - name: Strategy
       handler: src/handlers/Strategy.ts
       events:

apps/indexer/src/handlers/Registry.ts

@@ -1,6 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { Registry } from "../../generated";
 
+// Handler for RoleGranted event
+Registry.RoleGranted.handler(async ({}) => {});
+
+// Handler for RoleRevoked event
+Registry.RoleRevoked.handler(async ({}) => {});
+
 // Handler for ProfileCreated event
 Registry.ProfileCreated.handler(async ({}) => {});
 

packages/indexer-client/test/unit/envioIndexerClient.spec.ts

@@ -52,6 +52,10 @@ describe("EnvioIndexerClient", () => {
                 srcAddress: "0x1234567890123456789012345678901234567890",
                 logIndex: 0,
                 params: { contractAddress: "0x1234" },
+                transactionFields: {
+                    hash: "0x123",
+                    transactionIndex: 1,
+                },
             },
         ];
 

packages/indexer-client/tsconfig.json

@@ -1,4 +1,4 @@
 {
     "extends": "../../tsconfig.json",
-    "include": ["src/**/*"]
+    "include": ["src/**/*", "test/**/*"]
 }

packages/processors/src/allo/handlers/poolCreated.handler.ts

@@ -7,10 +7,10 @@ import { getToken } from "@grants-stack-indexer/shared/dist/src/internal.js";
 
 import type { IEventHandler, ProcessorDependencies, StrategyTimings } from "../../internal.js";
 import { getRoundRoles } from "../../helpers/roles.js";
-import { RoundMetadataSchema } from "../../helpers/schemas.js";
 import { extractStrategyFromId, getStrategyTimings } from "../../helpers/strategy.js";
 import { calculateAmountInUsd } from "../../helpers/tokenMath.js";
 import { TokenPriceNotFoundError } from "../../internal.js";
+import { RoundMetadataSchema } from "../../schemas/index.js";
 
 type Dependencies = Pick<
     ProcessorDependencies,

packages/processors/src/interfaces/factory.interface.ts

@@ -0,0 +1,17 @@
+import {
+    ChainId,
+    ContractName,
+    ContractToEventName,
+    ProtocolEvent,
+} from "@grants-stack-indexer/shared";
+
+import { ProcessorDependencies } from "../types/processor.types.js";
+import { IEventHandler } from "./index.js";
+
+export interface IEventHandlerFactory<C extends ContractName, E extends ContractToEventName<C>> {
+    createHandler(
+        event: ProtocolEvent<C, E>,
+        chainId: ChainId,
+        dependencies: ProcessorDependencies,
+    ): IEventHandler<C, E>;
+}

packages/processors/src/interfaces/index.ts

@@ -1,2 +1,3 @@
 export * from "./processor.interface.js";
+export * from "./factory.interface.js";
 export * from "./eventHandler.interface.js";

packages/processors/src/registry/handlers/index.ts

@@ -0,0 +1,2 @@
+export * from "./profileCreated.handler.js";
+export * from "./roleGranted.handler.js";

packages/processors/src/registry/handlers/profileCreated.handler.ts

@@ -0,0 +1,127 @@
+import { getAddress } from "viem";
+
+import { Changeset, ProjectType } from "@grants-stack-indexer/repository";
+import { ChainId, ProtocolEvent } from "@grants-stack-indexer/shared";
+
+import { IEventHandler, ProcessorDependencies } from "../../internal.js";
+import { ProjectMetadata, ProjectMetadataSchema } from "../../schemas/projectMetadata.js";
+
+type Dependencies = Pick<
+    ProcessorDependencies,
+    "projectRepository" | "evmProvider" | "metadataProvider"
+>;
+/**
+ * Handles the ProfileCreated event for the Registry contract from Allo protocol.
+ */
+export class ProfileCreatedHandler implements IEventHandler<"Registry", "ProfileCreated"> {
+    constructor(
+        readonly event: ProtocolEvent<"Registry", "ProfileCreated">,
+        readonly chainId: ChainId,
+        private dependencies: Dependencies,
+    ) {}
+    async handle(): Promise<Changeset[]> {
+        const { metadataProvider, evmProvider, projectRepository } = this.dependencies;
+        const profileId = this.event.params.profileId;
+        const metadataCid = this.event.params.metadata[1];
+        const metadata = await metadataProvider.getMetadata(metadataCid);
+
+        const parsedMetadata = ProjectMetadataSchema.safeParse(metadata);
+
+        let projectType: ProjectType = "canonical";
+        let isProgram = false;
+        let metadataValue = null;
+
+        if (parsedMetadata.success) {
+            projectType = this.getProjectTypeFromMetadata(parsedMetadata.data);
+            isProgram = parsedMetadata.data.type === "program";
+            metadataValue = parsedMetadata.data;
+        } else {
+            //TODO: Replace with logger
+            console.warn({
+                msg: `ProfileCreated: Failed to parse metadata for profile ${profileId}`,
+                event: this.event,
+                metadataCid,
+                metadata,
+            });
+        }
+
+        const createdBy =
+            this.event.transactionFields.from ??
+            (await evmProvider.getTransaction(this.event.transactionFields.hash)).from;
+        const programTags = isProgram ? ["program"] : [];
+
+        const changes: Changeset[] = [
+            {
+                type: "InsertProject",
+                args: {
+                    project: {
+                        tags: ["allo-v2", ...programTags],
+                        chainId: this.chainId,
+                        registryAddress: getAddress(this.event.srcAddress),
+                        id: profileId,
+                        name: this.event.params.name,
+                        nonce: this.event.params.nonce,
+                        anchorAddress: getAddress(this.event.params.anchor),
+                        projectNumber: null,
+                        metadataCid: metadataCid,
+                        metadata: metadataValue,
+                        createdByAddress: getAddress(createdBy),
+                        createdAtBlock: BigInt(this.event.blockNumber),
+                        updatedAtBlock: BigInt(this.event.blockNumber),
+                        projectType,
+                    },
+                },
+            },
+            {
+                type: "InsertProjectRole",
+                args: {
+                    projectRole: {
+                        chainId: this.chainId,
+                        projectId: this.event.params.profileId,
+                        address: getAddress(this.event.params.owner),
+                        role: "owner",
+                        createdAtBlock: BigInt(this.event.blockNumber),
+                    },
+                },
+            },
+        ];
+
+        const pendingProjectRoles = await projectRepository.getPendingProjectRolesByRole(
+            this.chainId,
+            profileId,
+        );
+
+        if (pendingProjectRoles.length !== 0) {
+            for (const role of pendingProjectRoles) {
+                changes.push({
+                    type: "InsertProjectRole",
+                    args: {
+                        projectRole: {
+                            chainId: this.chainId,
+                            projectId: profileId,
+                            address: getAddress(role.address),
+                            role: "member",
+                            createdAtBlock: BigInt(this.event.blockNumber),
+                        },
+                    },
+                });
+            }
+
+            changes.push({
+                type: "DeletePendingProjectRoles",
+                args: { ids: pendingProjectRoles.map((r) => r.id!) },
+            });
+        }
+
+        return changes;
+    }
+
+    private getProjectTypeFromMetadata(metadata: ProjectMetadata): ProjectType {
+        // if the metadata contains a canonical reference, it's a linked project
+        if ("canonical" in metadata) {
+            return "linked";
+        }
+
+        return "canonical";
+    }
+}

packages/processors/src/registry/handlers/roleGranted.handler.ts

@@ -0,0 +1,64 @@
+import { getAddress } from "viem";
+
+import { Changeset } from "@grants-stack-indexer/repository";
+import { ALLO_OWNER_ROLE, ChainId, ProtocolEvent } from "@grants-stack-indexer/shared";
+
+import { IEventHandler } from "../../internal.js";
+import { ProcessorDependencies } from "../../types/processor.types.js";
+
+/**
+ * Handles the RoleGranted event for the Registry contract from Allo protocol.
+ */
+export class RoleGrantedHandler implements IEventHandler<"Registry", "RoleGranted"> {
+    constructor(
+        readonly event: ProtocolEvent<"Registry", "RoleGranted">,
+        readonly chainId: ChainId,
+        private readonly dependencies: ProcessorDependencies,
+    ) {}
+    async handle(): Promise<Changeset[]> {
+        const { projectRepository } = this.dependencies;
+        const role = this.event.params.role.toLocaleLowerCase();
+        if (role === ALLO_OWNER_ROLE) {
+            return [];
+        }
+
+        const account = getAddress(this.event.params.account);
+        const project = await projectRepository.getProjectById(this.chainId, role);
+
+        // The member role for an Allo V2 profile, is the profileId itself.
+        // If a project exists with that id, we create the member role
+        // If it doesn't exists we create a pending project role. This can happens
+        // when a new project is created, since in Allo V2 the RoleGranted event for a member is
+        // emitted before the ProfileCreated event.
+        if (project) {
+            return [
+                {
+                    type: "InsertProjectRole",
+                    args: {
+                        projectRole: {
+                            chainId: this.chainId,
+                            projectId: project.id,
+                            address: account,
+                            role: "member",
+                            createdAtBlock: BigInt(this.event.blockNumber),
+                        },
+                    },
+                },
+            ];
+        }
+
+        return [
+            {
+                type: "InsertPendingProjectRole",
+                args: {
+                    pendingProjectRole: {
+                        chainId: this.chainId,
+                        role: role,
+                        address: account,
+                        createdAtBlock: BigInt(this.event.blockNumber),
+                    },
+                },
+            },
+        ];
+    }
+}

packages/processors/src/registry/index.ts

@@ -0,0 +1 @@
+export * from "./registry.processor.js";

packages/processors/src/registry/registry.processor.ts

@@ -0,0 +1,34 @@
+import { Changeset } from "@grants-stack-indexer/repository";
+import { ChainId, ProtocolEvent, RegistryEvent } from "@grants-stack-indexer/shared";
+
+import type { IProcessor } from "../internal.js";
+import { UnsupportedEventException } from "../internal.js";
+import { ProcessorDependencies } from "../types/processor.types.js";
+import { ProfileCreatedHandler, RoleGrantedHandler } from "./handlers/index.js";
+
+export class RegistryProcessor implements IProcessor<"Registry", RegistryEvent> {
+    constructor(
+        private readonly chainId: ChainId,
+        private readonly dependencies: ProcessorDependencies,
+    ) {}
+
+    async process(event: ProtocolEvent<"Registry", RegistryEvent>): Promise<Changeset[]> {
+        //TODO: Implement robust error handling and retry logic
+        switch (event.eventName) {
+            case "RoleGranted":
+                return new RoleGrantedHandler(
+                    event as ProtocolEvent<"Registry", "RoleGranted">,
+                    this.chainId,
+                    this.dependencies,
+                ).handle();
+            case "ProfileCreated":
+                return new ProfileCreatedHandler(
+                    event as ProtocolEvent<"Registry", "ProfileCreated">,
+                    this.chainId,
+                    this.dependencies,
+                ).handle();
+            default:
+                throw new UnsupportedEventException("Registry", event.eventName);
+        }
+    }
+}

packages/processors/src/schemas/index.ts

@@ -0,0 +1,2 @@
+export * from "./projectMetadata.js";
+export * from "./roundMetadata.js";

packages/processors/src/schemas/projectMetadata.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+export const ProjectMetadataSchema = z.union([
+    z
+        .object({
+            title: z.string(),
+            description: z.string(),
+        })
+        .passthrough()
+        .transform((data) => ({ type: "project" as const, ...data })),
+    z
+        .object({
+            canonical: z.object({
+                registryAddress: z.string(),
+                chainId: z.coerce.number(),
+            }),
+        })
+        .transform((data) => ({ type: "project" as const, ...data })),
+    z.object({
+        type: z.literal("program"),
+        name: z.string(),
+    }),
+    z
+        .object({
+            name: z.string(),
+        })
+        .transform((data) => ({ type: "program" as const, ...data })),
+]);
+
+export type ProjectMetadata = z.infer<typeof ProjectMetadataSchema>;