fix: Merge latest changes to main

docs/classes/ERC725.md

@@ -444,16 +444,36 @@ _Example 2: input `1122334455` encoded as `bytes4` --> will encode as `0x42e576f
 
 An array of objects containing the following properties:
 
-| Name                         | Type                                           | Description                                                                                                                                                      |
-| :--------------------------- | :--------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `keyName`                    | string                                         | Can be either the named key (i.e. `LSP3Profile`, `LSP12IssuedAssetsMap:<address>`) or the hashed key (with or without `0x` prefix, i.e. `0x5ef...` or `5ef...`). |
-| `dynamicKeyParts` (optional) | string or <br/> string[&nbsp;]                 | The dynamic parts of the `keyName` that will be used for encoding the key.                                                                                       |
-| `value`                      | string or <br/> string[&nbsp;] <br/> JSON todo | The value that should be encoded. Can be a string, an array of string or a JSON...                                                                               |
+| Name                          | Type                                           | Description                                                                                                                                                      |
+| :---------------------------- | :--------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `keyName`                     | string                                         | Can be either the named key (i.e. `LSP3Profile`, `LSP12IssuedAssetsMap:<address>`) or the hashed key (with or without `0x` prefix, i.e. `0x5ef...` or `5ef...`). |
+| `dynamicKeyParts` (optional)  | string or <br/> string[&nbsp;]                 | The dynamic parts of the `keyName` that will be used for encoding the key.                                                                                       |
+| `value`                       | string or <br/> string[&nbsp;] <br/> JSON todo | The value that should be encoded. Can be a string, an array of string or a JSON...                                                                               |
+| `startingIndex` (optional)    | number                                         | Starting index for `Array` types to encode a subset of elements. Defaults t `0`.                                                                                 |
+| `totalArrayLength` (optional) | number                                         | Parameter for `Array` types, specifying the total length when encoding a subset of elements. Defaults to the number of elements in the `value` field.            |
 
 The `keyName` also supports dynamic keys for [`Mapping`](https://github.com/lukso-network/LIPs/blob/main/LSPs/LSP-2-ERC725YJSONSchema.md#mapping) and [`MappingWithGrouping`](https://github.com/lukso-network/LIPs/blob/main/LSPs/LSP-2-ERC725YJSONSchema.md#mapping). Therefore, you can use variables in the key name such as `LSP12IssuedAssetsMap:<address>`. In that case, the value should also set the `dynamicKeyParts` property:
 
 - `dynamicKeyParts`: string or string[&nbsp;] which holds the variables that needs to be encoded.
 
+:::info Handling array subsets
+
+The `totalArrayLength` parameter must be explicitly provided to ensure integrity when encoding subsets or modifying existing array elements. Its value specifies the total length of the array **after the operation is completed**, not just the size of the encoded subset.
+
+**When to Use `totalArrayLength`**
+
+- **Adding Elements:** When adding new elements to an array, `totalArrayLength` should equal the sum of the current array's length plus the number of new elements added.
+- **Modifying Elements:** If modifying elements within an existing array without changing the total number of elements, `totalArrayLength` should match the previous length of the array.
+- **Removing Elements:** In cases where elements are removed, `totalArrayLength` should reflect the number of elements left.
+
+:::
+
+:::caution Encoding array lengths
+
+Please be careful when updating existing contract data. Incorrect usage of `startingIndex` and `totalArrayLength` can lead to improperly encoded data that changes the intended structure of the data field.
+
+:::
+
 ##### 2. `schemas` - Array of Objects (optional)
 
 An array of extra [LSP-2 ERC725YJSONSchema] objects that can be used to find the schema. If called on an instance, it is optional and it will be concatenated with the schema provided on instantiation.
@@ -700,6 +720,52 @@ myErc725.encodeData([
 
 </details>
 
+<details>
+    <summary>Encode a subset of array elements</summary>
+
+```javascript title="Encode a subset of array elements"
+const schemas = [
+  {
+    name: 'AddressPermissions[]',
+    key: '0xdf30dba06db6a30e65354d9a64c609861f089545ca58c6b4dbe31a5f338cb0e3',
+    keyType: 'Array',
+    valueType: 'address',
+    valueContent: 'Address',
+  },
+];
+
+myErc725.encodeData(
+  [
+    {
+      keyName: 'AddressPermissions[]',
+      value: [
+        '0x983abc616f2442bab7a917e6bb8660df8b01f3bf',
+        '0x56ecbc104136d00eb37aa0dce60e075f10292d81',
+      ],
+      totalArrayLength: 23,
+      startingIndex: 21,
+    },
+  ],
+  schemas,
+);
+/**
+{
+  keys: [
+    '0xdf30dba06db6a30e65354d9a64c609861f089545ca58c6b4dbe31a5f338cb0e3',
+    '0xdf30dba06db6a30e65354d9a64c6098600000000000000000000000000000015', 
+    '0xdf30dba06db6a30e65354d9a64c6098600000000000000000000000000000016',
+  ],
+  values: [
+    '0x00000000000000000000000000000017',
+    '0x983abc616f2442bab7a917e6bb8660df8b01f3bf',
+    '0x56ecbc104136d00eb37aa0dce60e075f10292d81',
+  ],
+}
+*/
+```
+
+</details>
+
 ---
 
 ## encodePermissions
@@ -1611,7 +1677,7 @@ Either a string of the hexadecimal `interfaceID` as defined by [ERC165](https://
 
 The `interfaceName` will only check for the latest version of the standard's `interfaceID`, which can be found in `src/constants/interfaces`. For LSPs, the `interfaceIDs` are taken from the latest release of the [@lukso/lsp-smart-contracts](https://github.com/lukso-network/lsp-smart-contracts) library.
 
-:::info
+:::
 
 ##### 2. `options` - Object (optional)
 

src/constants/constants.ts

@@ -179,7 +179,8 @@ export const LSP6_DEFAULT_PERMISSIONS = {
   DECRYPT                          : "0x0000000000000000000000000000000000000000000000000000000000100000",
   SIGN                             : "0x0000000000000000000000000000000000000000000000000000000000200000",
   EXECUTE_RELAY_CALL               : "0x0000000000000000000000000000000000000000000000000000000000400000",
-  ERC4337_PERMISSION               : "0x0000000000000000000000000000000000000000000000000000000000800000"
+  ERC4337_PERMISSION               : "0x0000000000000000000000000000000000000000000000000000000000800000",
+  ALL_PERMISSIONS                  : "0x00000000000000000000000000000000000000000000000000000000007f3f7f" // lsp6 v0.14.0
 };
 
 export const LSP6_ALL_PERMISSIONS =

src/index.test.ts

@@ -47,6 +47,7 @@ import 'isomorphic-fetch';
 
 import {
   ERC725Y_INTERFACE_IDS,
+  LSP6_DEFAULT_PERMISSIONS,
   SUPPORTED_VERIFICATION_METHOD_STRINGS,
 } from './constants/constants';
 import { decodeKey } from './lib/decodeData';
@@ -1003,6 +1004,45 @@ describe('Running @erc725/erc725.js tests...', () => {
           assert.deepStrictEqual(results, intendedResult);
         });
 
+        it('encodes subset of elements for keyType "Array" in naked class instance', () => {
+          const schemas: ERC725JSONSchema[] = [
+            {
+              name: 'AddressPermissions[]',
+              key: '0xdf30dba06db6a30e65354d9a64c609861f089545ca58c6b4dbe31a5f338cb0e3',
+              keyType: 'Array',
+              valueType: 'address',
+              valueContent: 'Address',
+            },
+          ];
+          const erc725 = new ERC725(schemas);
+          const encodedArraySection = erc725.encodeData([
+            {
+              keyName: 'AddressPermissions[]',
+              value: [
+                '0x983abc616f2442bab7a917e6bb8660df8b01f3bf',
+                '0x56ecbc104136d00eb37aa0dce60e075f10292d81',
+              ],
+              totalArrayLength: 23,
+              startingIndex: 21,
+            },
+          ]);
+
+          // Expected result with custom startingIndex and totalArrayLength
+          const expectedResult = {
+            keys: [
+              '0xdf30dba06db6a30e65354d9a64c609861f089545ca58c6b4dbe31a5f338cb0e3',
+              '0xdf30dba06db6a30e65354d9a64c6098600000000000000000000000000000015', // 21
+              '0xdf30dba06db6a30e65354d9a64c6098600000000000000000000000000000016', // 22
+            ],
+            values: [
+              '0x00000000000000000000000000000017', // 23
+              '0x983abc616f2442bab7a917e6bb8660df8b01f3bf',
+              '0x56ecbc104136d00eb37aa0dce60e075f10292d81',
+            ],
+          };
+          assert.deepStrictEqual(encodedArraySection, expectedResult);
+        });
+
         it(`decode all data values for keyType "Array" in naked class instance: ${schemaElement.name}`, async () => {
           const values = allGraphData.filter(
             (e) => e.key.slice(0, 34) === schemaElement.key.slice(0, 34),
@@ -1192,6 +1232,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: true,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x00000000000000000000000000000000000000000000000000000000003f3f7f',
       },
@@ -1221,6 +1262,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000000000',
       },
@@ -1250,6 +1292,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: true,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000200a00',
       },
@@ -1279,6 +1322,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000040800',
       },
@@ -1308,6 +1352,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000040004',
       },
@@ -1337,6 +1382,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000000a00',
       },
@@ -1376,13 +1422,120 @@ describe('Running @erc725/erc725.js tests...', () => {
       });
     });
 
+    describe('Randomized Permissions Encoding', () => {
+      function convertToPermissionBits(permissions: { [key: string]: string }) {
+        const permissionBits = {};
+        Object.entries(permissions).forEach(([key, hexValue]) => {
+          // Convert hex to binary, then find the position of the '1' bit
+          const bitPosition = BigInt(hexValue).toString(2).length - 1;
+          permissionBits[key] = bitPosition;
+        });
+        return permissionBits;
+      }
+
+      // remove LSP6_DEFAULT_PERMISSIONS.ALL_PERMISSIONS from LSP6_DEFAULT_PERMISSIONS
+      const ALL_PERMISSIONS_WITHOUT_ALL_PERMISSIONS = Object.keys(
+        LSP6_DEFAULT_PERMISSIONS,
+      ).reduce((acc, key) => {
+        if (key !== 'ALL_PERMISSIONS') {
+          acc[key] = LSP6_DEFAULT_PERMISSIONS[key];
+        }
+        return acc;
+      }, {});
+
+      // Use the function to generate permissionBits
+      const permissionBits = convertToPermissionBits(
+        ALL_PERMISSIONS_WITHOUT_ALL_PERMISSIONS,
+      );
+
+      // Function to generate a random permissions object
+      const generateRandomPermissions = () => {
+        return Object.keys(permissionBits).reduce((acc, key) => {
+          // Randomly assign true or false
+          acc[key] = Math.random() < 0.5;
+          return acc;
+        }, {});
+      };
+
+      // Function to calculate expected hex based on permissions
+      const calculateExpectedHex = (permissions) => {
+        let basePermissions = BigInt(0);
+        Object.entries(permissions).forEach(([key, value]) => {
+          if (value) {
+            const bitPosition = permissionBits[key];
+            basePermissions |= BigInt(1) << BigInt(bitPosition);
+          }
+        });
+        // Convert to hex string, properly padded
+        return `0x${basePermissions.toString(16).padStart(64, '0')}`;
+      };
+
+      // Run the randomized test multiple times
+      const numberOfTests = 100; // Number of random tests
+      for (let i = 0; i < numberOfTests; i++) {
+        it(`Randomized test #${i + 1}`, () => {
+          const randomPermissions = generateRandomPermissions();
+          const encoded = ERC725.encodePermissions(randomPermissions);
+          const expectedHex = calculateExpectedHex(randomPermissions);
+          assert.strictEqual(
+            encoded,
+            expectedHex,
+            `Failed at randomized test #${i + 1}`,
+          );
+        });
+      }
+    });
+
+    describe('all permissions', () => {
+      it('should encode ALL_PERMISSIONS correctly', () => {
+        const permissions = { ALL_PERMISSIONS: true };
+        const encoded = ERC725.encodePermissions(permissions);
+
+        assert.strictEqual(
+          encoded,
+          LSP6_DEFAULT_PERMISSIONS.ALL_PERMISSIONS,
+          'Encoded permissions do not match expected value for ALL_PERMISSIONS',
+        );
+      });
+
+      it('should ignore individual permissions when ALL_PERMISSIONS is set', () => {
+        const permissions = {
+          ALL_PERMISSIONS: true,
+          CHANGEOWNER: true,
+        };
+        const encoded = ERC725.encodePermissions(permissions);
+        assert.strictEqual(
+          encoded,
+          LSP6_DEFAULT_PERMISSIONS.ALL_PERMISSIONS,
+          'ALL_PERMISSIONS did not correctly encode with additional permissions',
+        );
+      });
+      it('should be able to disable permissions that are part of ALL_PERMISSIONS', () => {
+        const permissions = {
+          ALL_PERMISSIONS: true,
+          CHANGEOWNER: false, // Explicitly disable CHANGEOWNER
+        };
+
+        const encoded = ERC725.encodePermissions(permissions);
+        const decodedPermissions = ERC725.decodePermissions(encoded);
+
+        // check that the permission is disabled
+        assert.strictEqual(
+          decodedPermissions.CHANGEOWNER,
+          false,
+          'CHANGEOWNER permission was not correctly disabled',
+        );
+      });
+    });
+
     describe('decodePermissions', () => {
       testCases.forEach((testCase) => {
         it(`Decodes ${testCase.hex} permission correctly`, () => {
           assert.deepStrictEqual(
             ERC725.decodePermissions(testCase.hex),
             testCase.permissions,
           );
+
           assert.deepStrictEqual(
             erc725Instance.decodePermissions(testCase.hex),
             testCase.permissions,
@@ -1419,6 +1572,7 @@ describe('Running @erc725/erc725.js tests...', () => {
             SIGN: true,
             EXECUTE_RELAY_CALL: true,
             ERC4337_PERMISSION: true,
+            ALL_PERMISSIONS: true,
           },
         );
         assert.deepStrictEqual(
@@ -1450,6 +1604,7 @@ describe('Running @erc725/erc725.js tests...', () => {
             SIGN: true,
             EXECUTE_RELAY_CALL: true,
             ERC4337_PERMISSION: true,
+            ALL_PERMISSIONS: true,
           },
         );
       });