improve type check, increase test coverage

Author: anukul

packages/core/src/build/factory.test.ts

@@ -73,7 +73,7 @@ test("buildLogFactory handles Morpho CreateMarket marketParams.oracle", () => {
 const testEventAbiItem = parseAbiItem([
   "struct SomeNestedStruct { uint256 c1; address[3] c2; }",
   "struct SomeStruct { address b1; SomeNestedStruct[42] b2; }",
-  "event SomeEvent(SomeStruct indexed a1, SomeStruct a2, address[] a3, (uint256[] x, address y) z, (string s, address t)[10] u)",
+  "event SomeEvent(SomeStruct indexed a1, SomeStruct a2, address[] a3, (uint256[] x, address y) z, (string s, address t)[10] u, uint256 indexed v, address indexed w)",
 ]);
 
 test("buildLogFactory handles fixed length arrays and tuples", () => {
@@ -91,11 +91,27 @@ test("buildLogFactory handles fixed length arrays and tuples", () => {
   });
 });
 
+test("buildLogFactory handles indexed address parameters", () => {
+  const criteria = buildLogFactory({
+    address: "0xa",
+    event: testEventAbiItem,
+    parameterPath: "w",
+    chainId: 1,
+  });
+
+  expect(criteria).toMatchObject({
+    address: "0xa",
+    eventSelector: getEventSelector(testEventAbiItem),
+    childAddressLocation: "topic3",
+  });
+});
+
 test("buildLogFactory throws if provided path is nested in an indexed parameter", () => {
   expect(() => {
     buildLogFactory({
       address: "0xa",
       event: testEventAbiItem,
+      // @ts-expect-error
       parameterPath: "a1.b2[10].c2[1]",
       chainId: 1,
     });
@@ -143,6 +159,18 @@ test("buildLogFactory throws if provided path is not an address", () => {
   }).toThrowError("Factory event parameter is not an address. Got 'uint256'.");
 });
 
+test("buildLogFactory throws if provided path is not an address (indexed)", () => {
+  expect(() => {
+    buildLogFactory({
+      address: "0xa",
+      event: testEventAbiItem,
+      // @ts-expect-error
+      parameterPath: "v",
+      chainId: 1,
+    });
+  }).toThrowError("Factory event parameter is not an address. Got 'uint256'.");
+});
+
 test("buildLogFactory throws if provided path is not in a static type", () => {
   expect(() => {
     buildLogFactory({

packages/core/src/build/factory.ts

@@ -30,31 +30,40 @@ export function buildLogFactory<event extends AbiEvent>({
     convertToDotNotation(parameterPath).split(".");
 
   // Check if the provided parameter is present in the list of indexed inputs.
-  const indexedInputPosition = event.inputs
-    .filter((x) => "indexed" in x && x.indexed)
-    .findIndex((input) => input.name === parameter);
+  const indexedInputPosition = event.inputs.findIndex(
+    (input) => input.indexed && input.name === parameter,
+  );
 
   if (indexedInputPosition > -1) {
-    // If the parameter is indexed, nested paths cannot be accessed.
+    // If the parameter is indexed, nested paths cannot be accessed (reference types are hashed).
     if (pathSegments.length > 0) {
       throw new Error(
         `Factory event parameter is indexed, so nested path '${parameterPath}' cannot be accessed.`,
       );
     }
 
+    // Type must be address
+    if (event.inputs[indexedInputPosition]!.type !== "address") {
+      throw new Error(
+        `Factory event parameter is not an address. Got '${event.inputs[indexedInputPosition]!.type}'.`,
+      );
+    }
+
+    const topicPosition = event.inputs
+      .filter((input) => input.indexed)
+      .findIndex((input) => input.name === parameter);
+
     return {
       type: "log",
       chainId,
       address,
       eventSelector,
       // Add 1 because inputs will not contain an element for topic0 (the signature).
-      childAddressLocation: `topic${(indexedInputPosition + 1) as 1 | 2 | 3}`,
+      childAddressLocation: `topic${(topicPosition + 1) as 1 | 2 | 3}`,
     };
   }
 
-  const nonIndexedInputs = event.inputs.filter(
-    (x) => !("indexed" in x && x.indexed),
-  );
+  const nonIndexedInputs = event.inputs.filter((input) => !input.indexed);
   const nonIndexedInputPosition = nonIndexedInputs.findIndex(
     (input) => input.name === parameter,
   );

packages/core/src/config/address.ts

@@ -1,4 +1,8 @@
-import type { SolidityArrayWithTuple, SolidityTuple } from "abitype";
+import type {
+  AbiEventParameter,
+  SolidityArrayWithTuple,
+  SolidityTuple,
+} from "abitype";
 import type { AbiEvent, AbiParameter } from "viem";
 
 type CommonFactoryParams<event extends AbiEvent = AbiEvent> = {
@@ -21,6 +25,7 @@ export type DeprecatedFactoryEventParameter<event extends AbiEvent = AbiEvent> =
 type ExtractValidPaths<T extends AbiParameter> = T extends {
   name: infer Name extends string;
   type: infer Type;
+  indexed?: false;
 }
   ? Type extends SolidityTuple
     ? // Case 1: Tuple types - must access nested fields with dot notation
@@ -39,7 +44,7 @@ type ExtractValidPaths<T extends AbiParameter> = T extends {
         ? `${Name}[${number}].${ExtractValidPaths<Components[number]>}`
         : never
       : Type extends `address[${number}]`
-        ? // Case 3: Simple arrays - must access with index
+        ? // Case 3: Fixed length address arrays - must access with index
           // Example: "myArray[0]"
           `${Name}[${number}]`
         : // Case 4: Primitive types - only address type can be accessed directly
@@ -51,8 +56,11 @@ type ExtractValidPaths<T extends AbiParameter> = T extends {
 type FactoryEventParameter<event extends AbiEvent = AbiEvent> = {
   /** Path to the field in factory event parameters that contains the new child contract address. */
   parameterPath: event["inputs"][number] extends infer Input extends
-    AbiParameter
-    ? ExtractValidPaths<Input>
+    AbiEventParameter
+    ? // Only allow indexed parameter if address type
+      Input extends { indexed: true; type: "address"; name: infer Name }
+      ? Name
+      : ExtractValidPaths<Input>
     : never;
   parameter?: never;
 };