From 30dda3398d35a019b97790524834f12489607f2b Mon Sep 17 00:00:00 2001
From: CJ42 <cavallerajean@gmail.com>
Date: Tue, 30 Apr 2024 08:14:44 +0100
Subject: [PATCH] feat: include also `dynamicKeyPart` in the schema return by
 `getSchema`

---
 src/lib/schemaParser.test.ts  | 14 ++++++++++----
 src/lib/schemaParser.ts       | 23 +++++++++++++++--------
 src/types/ERC725JSONSchema.ts |  1 +
 3 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/src/lib/schemaParser.test.ts b/src/lib/schemaParser.test.ts
index 3b90775b..9ad23144 100644
--- a/src/lib/schemaParser.test.ts
+++ b/src/lib/schemaParser.test.ts
@@ -101,6 +101,8 @@ describe('schemaParser getSchema', () => {
         '0xeafec4d89fa9619884b60000f4d7faed14a1ab658d46d385bc29fb1eeaa56d0b',
       );
 
+      console.log('schema ', schema);
+
       assert.deepStrictEqual(schema, {
         name: 'SupportedStandards:??????',
         key: '0xeafec4d89fa9619884b60000f4d7faed14a1ab658d46d385bc29fb1eeaa56d0b',
@@ -113,13 +115,14 @@ describe('schemaParser getSchema', () => {
     it('finds Known Mapping:<address> ', () => {
       const address = 'af3bf2ffb025098b79caddfbdd113b3681817744';
       const name = 'MyCoolAddress:<address>';
-      const dynamicName = `MyCoolAddress:${address}`;
+      const dynamicName = `MyCoolAddress:0x${address}`;
       const key = `0x22496f48a493035f00000000${address}`;
 
       const extraSchema: DynamicNameSchema = {
         name,
         dynamicName,
         key,
+        dynamicKeyPart: `0x${address}`,
         keyType: 'Mapping',
         valueContent: 'Address',
         valueType: 'address',
@@ -134,13 +137,14 @@ describe('schemaParser getSchema', () => {
       const bytes32Value =
         '1111222233334444555566667777888899990000aaaabbbbccccddddeeeeffff';
       const name = `SomeBytes32Mapping:<bytes32>`;
-      const dynamicName = `SomeBytes32Mapping:${bytes32Value}`;
+      const dynamicName = `SomeBytes32Mapping:0x${bytes32Value}`;
       const key = `0x0cfc51aec37c55a4d0b10000${bytes32Value.slice(0, 42)}`;
 
       const extraSchema: DynamicNameSchema = {
         name,
         dynamicName,
         key,
+        dynamicKeyPart: `0x${bytes32Value}`,
         keyType: 'Mapping',
         valueContent: 'Address',
         valueType: 'address',
@@ -154,13 +158,14 @@ describe('schemaParser getSchema', () => {
     it('finds known SomeSelectorMap:<bytes4>', () => {
       const bytes4Value = 'beefbeef';
       const name = `SomeSelectorMap:<bytes4>`;
-      const dynamicName = `SomeSelectorMap:${bytes4Value}`;
+      const dynamicName = `SomeSelectorMap:0x${bytes4Value}`;
       const key = `0x0cfc51aec37c55a4d0b10000${bytes4Value}00000000000000000000000000000000`;
 
       const extraSchema: DynamicNameSchema = {
         name,
         dynamicName,
         key,
+        dynamicKeyPart: `0x${bytes4Value}`,
         keyType: 'Mapping',
         valueContent: '(Address,bool)',
         valueType: '(address,bool)',
@@ -176,7 +181,7 @@ describe('schemaParser getSchema', () => {
     it('finds MappingWithGrouping', () => {
       const address = 'af3bf2ffb025098b79caddfbdd113b3681817744';
       const name = `AddressPermissions:Permissions:<address>`;
-      const dynamicName = `AddressPermissions:Permissions:${address}`;
+      const dynamicName = `AddressPermissions:Permissions:0x${address}`;
       const key = `0x4b80742de2bf82acb3630000${address}`;
       const schema = getSchema(key);
 
@@ -184,6 +189,7 @@ describe('schemaParser getSchema', () => {
         name,
         dynamicName,
         key,
+        dynamicKeyPart: `0x${address}`,
         keyType: 'MappingWithGrouping',
         valueContent: 'BitArray',
         valueType: 'bytes32',
diff --git a/src/lib/schemaParser.ts b/src/lib/schemaParser.ts
index d321440e..c8b2dff7 100644
--- a/src/lib/schemaParser.ts
+++ b/src/lib/schemaParser.ts
@@ -121,16 +121,18 @@ const findMappingSchemaForKey = (
     key,
   };
 
+  // 3. mappings with dynamic key part
   // replace dynamic placeholder in the map part (e.g: <address>, <bytes32>) with the hex value
   if (isDynamicKeyName(keySchema.name)) {
     dynamicPartName = secondWordHex;
-    result['dynamicName'] = `${keyNameParts[0]}:${dynamicPartName}`;
+    result['dynamicName'] = `${keyNameParts[0]}:0x${dynamicPartName}`;
+    result['dynamicKeyPart'] = `0x${secondWordHex}`;
   }
 
   // if first 20 bytes of the hash of second word in schema match,
   // display the map part as plain word
   if (keccak256(keyNameParts[1]).substring(0, 26) === secondWordHex) {
-    [, dynamicPartName] = keyNameParts;
+    [, dynamicPartName] = `0x${keyNameParts}`;
   }
 
   return result;
@@ -145,16 +147,21 @@ const findMappingWithGroupingSchemaForKey = (
       (schema) => schema.key.substring(0, 26) === key.substring(0, 26),
     ) || null;
 
-  const address = key.substring(26);
-
   if (keySchema) {
+    const keyNameParts = keySchema.name.split(':');
+
+    const dynamicKeyPart = key.substring(26);
+
+    if (isDynamicKeyName(keySchema.name)) {
+      keySchema[
+        'dynamicName'
+      ] = `${keyNameParts[0]}:${keyNameParts[1]}:0x${dynamicKeyPart}`;
+      keySchema['dynamicKeyPart'] = `0x${dynamicKeyPart}`;
+    }
+
     return {
       ...keySchema,
       key,
-      dynamicName: `${keySchema.name.substring(
-        0,
-        keySchema.name.lastIndexOf(':'),
-      )}:${address}`,
     };
   }
 
diff --git a/src/types/ERC725JSONSchema.ts b/src/types/ERC725JSONSchema.ts
index 79a40cb6..1aa64f08 100644
--- a/src/types/ERC725JSONSchema.ts
+++ b/src/types/ERC725JSONSchema.ts
@@ -168,4 +168,5 @@ export interface ERC725JSONSchema {
 // of a hex data key got retrieved via `getSchema(...)`.
 export interface DynamicNameSchema extends ERC725JSONSchema {
   dynamicName: string; // Describes the name of the key where the dynamic part (<address>, <bytes32) is replaced by the actual mapped value.
+  dynamicKeyPart: string;
 }