fix: repair snip-12 enum type nested dependency (#1289)

* fix: missing snip-12 enum type dependency

* test: add nested enum tests

---------

Co-authored-by: Petar Penovic <pp@spaceshard.io>

Author: xJonathanLEI

__mocks__/typedData/example_enumNested.json

@@ -0,0 +1,33 @@
+{
+  "types": {
+    "StarknetDomain": [
+      { "name": "name", "type": "shortstring" },
+      { "name": "version", "type": "shortstring" },
+      { "name": "chainId", "type": "shortstring" },
+      { "name": "revision", "type": "shortstring" }
+    ],
+    "Example": [{ "name": "someEnum", "type": "enum", "contains": "EnumA" }],
+    "EnumA": [
+      { "name": "Variant 1", "type": "()" },
+      { "name": "Variant 2", "type": "(u128,StructA)" }
+    ],
+    "StructA": [{ "name": "nestedEnum", "type": "enum", "contains": "EnumB" }],
+    "EnumB": [
+      { "name": "Variant A", "type": "()" },
+      { "name": "Variant B", "type": "(StructB*)" }
+    ],
+    "StructB": [{ "name": "flag", "type": "bool" }]
+  },
+  "primaryType": "Example",
+  "domain": {
+    "name": "StarkNet Mail",
+    "version": "1",
+    "chainId": "1",
+    "revision": "1"
+  },
+  "message": {
+    "someEnum": {
+      "Variant 2": [2, { "nestedEnum": { "Variant B": [[{ "flag": true }, { "flag": false }]] } }]
+    }
+  }
+}

__tests__/utils/typedData.test.ts

@@ -3,6 +3,7 @@ import * as starkCurve from '@scure/starknet';
 import typedDataExample from '../../__mocks__/typedData/baseExample.json';
 import exampleBaseTypes from '../../__mocks__/typedData/example_baseTypes.json';
 import exampleEnum from '../../__mocks__/typedData/example_enum.json';
+import exampleEnumNested from '../../__mocks__/typedData/example_enumNested.json';
 import examplePresetTypes from '../../__mocks__/typedData/example_presetTypes.json';
 import typedDataStructArrayExample from '../../__mocks__/typedData/mail_StructArray.json';
 import typedDataSessionExample from '../../__mocks__/typedData/session_MerkleTree.json';
@@ -66,6 +67,10 @@ describe('typedData', () => {
     expect(encoded).toMatchInlineSnapshot(
       `"\\"Example\\"(\\"someEnum1\\":\\"EnumA\\",\\"someEnum2\\":\\"EnumB\\")\\"EnumA\\"(\\"Variant 1\\":(),\\"Variant 2\\":(\\"u128\\",\\"u128*\\"),\\"Variant 3\\":(\\"u128\\"))\\"EnumB\\"(\\"Variant 1\\":(),\\"Variant 2\\":(\\"u128\\"))"`
     );
+    encoded = encodeType(exampleEnumNested.types, 'Example', TypedDataRevision.ACTIVE);
+    expect(encoded).toMatchInlineSnapshot(
+      `"\\"Example\\"(\\"someEnum\\":\\"EnumA\\")\\"EnumA\\"(\\"Variant 1\\":(),\\"Variant 2\\":(\\"u128\\",\\"StructA\\"))\\"EnumB\\"(\\"Variant A\\":(),\\"Variant B\\":(\\"StructB*\\"))\\"StructA\\"(\\"nestedEnum\\":\\"EnumB\\")\\"StructB\\"(\\"flag\\":\\"bool\\")"`
+    );
   });
 
   test('should get right type hash', () => {
@@ -106,6 +111,10 @@ describe('typedData', () => {
     expect(typeHash).toMatchInlineSnapshot(
       `"0x8eb4aeac64b707f3e843284c4258df6df1f0f7fd38dcffdd8a153a495cd351"`
     );
+    typeHash = getTypeHash(exampleEnumNested.types, 'Example', TypedDataRevision.ACTIVE);
+    expect(typeHash).toMatchInlineSnapshot(
+      `"0x2143bb787fabace39d62e9acf8b6e97d9a369000516c3e6ffd963dc1370fc1a"`
+    );
   });
 
   test('should transform type selector', () => {
@@ -329,6 +338,11 @@ describe('typedData', () => {
       `"0x6e61abaf480b1370bbf231f54e298c5f4872f40a6d2dd409ff30accee5bbd1e"`
     );
 
+    messageHash = getMessageHash(exampleEnumNested, exampleAddress);
+    expect(messageHash).toMatchInlineSnapshot(
+      `"0x691fc54567306a8ea5431130f1b98299e74a748ac391540a86736f20ef5f2b7"`
+    );
+
     expect(spyPedersen).not.toHaveBeenCalled();
     expect(spyPoseidon).toHaveBeenCalled();
     spyPedersen.mockRestore();

src/utils/typedData.ts

@@ -167,36 +167,46 @@ export function getDependencies(
   contains: string = '',
   revision: Revision = Revision.LEGACY
 ): string[] {
+  let dependencyTypes: string[] = [type];
+
   // Include pointers (struct arrays)
   if (type[type.length - 1] === '*') {
-    type = type.slice(0, -1);
+    dependencyTypes = [type.slice(0, -1)];
   } else if (revision === Revision.ACTIVE) {
     // enum base
     if (type === 'enum') {
-      type = contains;
+      dependencyTypes = [contains];
     }
     // enum element types
     else if (type.match(/^\(.*\)$/)) {
-      type = type.slice(1, -1);
+      dependencyTypes = type
+        .slice(1, -1)
+        .split(',')
+        .map((depType) => (depType[depType.length - 1] === '*' ? depType.slice(0, -1) : depType));
     }
   }
 
-  if (dependencies.includes(type) || !types[type]) {
-    return dependencies;
-  }
-
-  return [
-    type,
-    ...(types[type] as StarknetEnumType[]).reduce<string[]>(
-      (previous, t) => [
-        ...previous,
-        ...getDependencies(types, t.type, previous, t.contains, revision).filter(
-          (dependency) => !previous.includes(dependency)
-        ),
+  return dependencyTypes
+    .filter((t) => !dependencies.includes(t) && types[t])
+    .reduce<string[]>(
+      // This comment prevents prettier from rolling everything here into a single line.
+      (p, depType) => [
+        ...p,
+        ...[
+          depType,
+          ...(types[depType] as StarknetEnumType[]).reduce<string[]>(
+            (previous, t) => [
+              ...previous,
+              ...getDependencies(types, t.type, previous, t.contains, revision).filter(
+                (dependency) => !previous.includes(dependency)
+              ),
+            ],
+            []
+          ),
+        ].filter((dependency) => !p.includes(dependency)),
       ],
       []
-    ),
-  ];
+    );
 }
 
 function getMerkleTreeType(types: TypedData['types'], ctx: Context) {