Merge pull request #271 from hypercerts-org/feature/index-operator-as-creator

feat(parsing): enhance parseClaimStoredEvent to extract operator from…

Author: Jipperism

src/parsing/parseClaimStoredEvent.ts

@@ -1,9 +1,10 @@
-import { isAddress, isHex } from "viem";
+import { isAddress, isHex, parseEventLogs } from "viem";
 import { z } from "zod";
 import { Claim, ClaimSchema } from "@/storage/storeClaimStored.js";
 import { ParserMethod } from "@/indexer/LogParser.js";
 import { ZERO_ADDRESS } from "@/utils/constants.js";
 import { getEvmClient } from "@/clients/evmClient.js";
+import { HypercertMinterAbi } from "@hypercerts-org/contracts";
 
 export const ClaimStoredEventSchema = z.object({
   address: z.string().refine(isAddress, {
@@ -32,18 +33,33 @@ export const parseClaimStoredEvent: ParserMethod<Claim> = async ({
   context: { chain_id, contracts_id },
 }) => {
   const { params, transactionHash } = ClaimStoredEventSchema.parse(event);
-  const client = getEvmClient(chain_id);
+  const client = getEvmClient(Number(chain_id));
 
   try {
-    const transaction = await client.getTransaction({
+    // get the operator from the transferSingle event, this is necessary for safe support
+    // otherwise transaction.from is the address of the last signer in safe
+    const receipt = await client.getTransactionReceipt({
       hash: transactionHash,
     });
+    const parsedLogs = parseEventLogs({
+      abi: HypercertMinterAbi,
+      logs: receipt.logs,
+    });
+    const transferSingleEvent = parsedLogs.find(
+      // @ts-expect-error eventName is missing in the type
+      (log) => log.eventName === "TransferSingle",
+    );
+    if (!transferSingleEvent) {
+      throw new Error("TransferSingle event not found");
+    }
+    // @ts-expect-error args is missing in the type
+    const operator = transferSingleEvent.args.operator;
 
     return [
       ClaimSchema.parse({
         contracts_id: contracts_id,
         owner_address: ZERO_ADDRESS,
-        creator_address: transaction.from,
+        creator_address: operator,
         token_id: params.claimID,
         uri: params.uri,
         units: params.totalUnits,

test/parsing/claimStoredEvent.test.ts

@@ -8,12 +8,34 @@ vi.mock("../../src/clients/evmClient.js", () => ({
       Promise.resolve({
         from: "0x1234567890123456789012345678901234567890",
       }),
+    getTransactionReceipt: () =>
+      Promise.resolve({
+        logs: [],
+      }),
   }),
 }));
 
-import { faker } from "@faker-js/faker";
+vi.mock("viem", async (importOriginal) => {
+  const original = await importOriginal();
+  return {
+    // @ts-expect-error - spread types may only be created from object types
+    ...original,
+    parseEventLogs: vi.fn(),
+    // parseEventLogs: vi.fn().mockReturnValue([
+    //   {
+    //     eventName: "TransferSingle",
+    //     args: {
+    //       operator: "0x1234567890123456789012345678901234567891",
+    //     },
+    //   },
+    // ]),
+  };
+});
+
+import { fa, faker } from "@faker-js/faker";
 import { Block } from "@hypercerts-org/chainsauce";
 import { getAddress } from "viem";
+import * as viem from "viem";
 import { parseClaimStoredEvent } from "../../src/parsing/parseClaimStoredEvent.js";
 import { generateClaimStoredEvent } from "../helpers/factories.js";
 
@@ -36,6 +58,16 @@ describe("claimStoredEvent", {}, () => {
   };
 
   it("parses a claim stored event", {}, async () => {
+    const operator = getAddress(faker.finance.ethereumAddress());
+    vi.spyOn(viem, "parseEventLogs").mockImplementationOnce(() => [
+      // @ts-expect-error - mock implementation
+      {
+        eventName: "TransferSingle",
+        args: {
+          operator,
+        },
+      },
+    ]);
     const from = "0x1234567890123456789012345678901234567890";
     const event = {
       event: "ClaimStored",
@@ -53,7 +85,7 @@ describe("claimStoredEvent", {}, () => {
 
     expect(claim).toEqual({
       contracts_id: context.contracts_id,
-      creator_address: from,
+      creator_address: operator,
       owner_address: "0x0000000000000000000000000000000000000000",
       uri: event.params.uri,
       units: event.params.totalUnits,