feat: add ALL_PERMISSIONS flag to encoding

CHANGELOG.md

@@ -2,6 +2,52 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [0.23.0](https://github.com/ERC725Alliance/erc725.js/compare/v0.22.0...v0.23.0) (2024-01-22)
+
+
+### Features
+
+* add permission related to 4337 ([e7fd19b](https://github.com/ERC725Alliance/erc725.js/commit/e7fd19bc27aa89fae410b9633ef5ccdf13f33f0e))
+* allow to load typed schemas from `schemas/` folder ([c54a370](https://github.com/ERC725Alliance/erc725.js/commit/c54a370c1e4f8d71ba6bb7e62122b89069f521e6))
+
+
+### Bug Fixes
+
+* Add workaround to read (bytes4,URI), repair none vs unknown signature. ([204409d](https://github.com/ERC725Alliance/erc725.js/commit/204409df544825041a586865cfb6bb124288e48f))
+* Additional PR repair ([2a18f2b](https://github.com/ERC725Alliance/erc725.js/commit/2a18f2bf1a24547e71cad6953f5144761aa2cc9a))
+* BodyInit should be just string or buffer and not already Uint8Array ([08e0177](https://github.com/ERC725Alliance/erc725.js/commit/08e017778fa42ade5386b8d9e85255225a7f3195))
+* Cleanup ([038d975](https://github.com/ERC725Alliance/erc725.js/commit/038d97584075c89f93f51227666074cf11973a29))
+* Cleanup a bit with comments. ([3d6a5a6](https://github.com/ERC725Alliance/erc725.js/commit/3d6a5a65db5049b678d0d54149e9b11ea2479999))
+* Cleanup and handle situation where one of many keys fails. Return null. ([cdf4583](https://github.com/ERC725Alliance/erc725.js/commit/cdf4583c159d8c8e52a832bfe5af6b650d8945fa))
+* Cleanup error handler inside of getDataFromExternalSources ([fde2e0f](https://github.com/ERC725Alliance/erc725.js/commit/fde2e0f41df3ecee90a4dfd8248dd9c2a7a72965))
+* Debug and repair test scripts. Implement detecting of JSON inside of Uint8Array ([74c0526](https://github.com/ERC725Alliance/erc725.js/commit/74c0526e3f544400ced78f02ff4fed64bd048bfa))
+* Missing commit ([a3dd604](https://github.com/ERC725Alliance/erc725.js/commit/a3dd604964c9c9221ff421fe668faa8fd363101a))
+* More fixes ([620b606](https://github.com/ERC725Alliance/erc725.js/commit/620b60632e50ca59abedae9935f8b75d188278e0))
+* Remove .only call for testing. ([d5ef3c9](https://github.com/ERC725Alliance/erc725.js/commit/d5ef3c9965e2c5ad343f88a9c30a6281e9fa169b))
+* Remove console debugging. ([e349d57](https://github.com/ERC725Alliance/erc725.js/commit/e349d5715c7779c1eeb8d6e08c3ae3bf17eedd9e))
+* Remove unnecessary special case for 0x00000000 ([cd6152a](https://github.com/ERC725Alliance/erc725.js/commit/cd6152a88ca7a1c98184799b6fdc6982ff8a1cd6))
+* Repair and enhance test scripts ([224eb9e](https://github.com/ERC725Alliance/erc725.js/commit/224eb9ecb1b16f373f2ad17ee9d3efab08dda53b))
+* Repair as per PR review ([0a52452](https://github.com/ERC725Alliance/erc725.js/commit/0a5245230455324e9911e4e14992c50e6f645ba2))
+* Repair console.log and expand types of URLs (ar://, ipfs://, https\?://, data:) ([5c8f228](https://github.com/ERC725Alliance/erc725.js/commit/5c8f2285d2d23c59ef9707a54e419b55d25e4136))
+* Repair problems with IPFS, fetch and VerifiableURI ([44834b8](https://github.com/ERC725Alliance/erc725.js/commit/44834b8ed517e869ad99920b2853e30213a8d7b5))
+* Repair to not throw errors when data is not authentica or not accessible withing getDataFromExternalSources. ([25756d0](https://github.com/ERC725Alliance/erc725.js/commit/25756d09cecfec5d13d6e4fb6ed842c4e3d77734))
+* Repair tuples containing numeric types uintX/intX, add Number to output data type. ([01cceea](https://github.com/ERC725Alliance/erc725.js/commit/01cceeac03f719df6eb8be8c238aca4483e7a3e8))
+* Simplify buffer to string conversion. ([0bd1349](https://github.com/ERC725Alliance/erc725.js/commit/0bd1349f863283cf16cc6808bef48990ec118361))
+* Simplify creation of key to detect JSON. ([df2580d](https://github.com/ERC725Alliance/erc725.js/commit/df2580d9434dc386480f7eec2cd6e94a5b4ca7c1))
+* Use a single keccak function since ethereumjs converts it to a Buffer no matter what. ([cdc6c0a](https://github.com/ERC725Alliance/erc725.js/commit/cdc6c0a0f749209352d620db6d60865a276e072c))
+
+## [0.22.0](https://github.com/ERC725Alliance/erc725.js/compare/v0.21.3...v0.22.0) (2023-12-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* update new LSP7/8 interface IDs ([#367](https://github.com/ERC725Alliance/erc725.js/issues/367))
+* `JSONURL` and `AssetURL` are now deprecated and have been replaced by `VerifiableURI`. The decoding is backward compatible but if you try to encode `JSONURL` and `AssetURL` value, they will be encoded as [`VerifiableURI`](https://github.com/lukso-network/LIPs/blob/main/LSPs/LSP-2-ERC725YJSONSchema.md#verifiableuri). ([9aa87e5](https://github.com/ERC725Alliance/erc725.js/commit/9aa87e5ccc0fb1caac1f3291387370b3a980324b))
+
+### Bug Fixes
+
+* Rename JSONURLDataToEncode ([808f1b3](https://github.com/ERC725Alliance/erc725.js/commit/808f1b362bd2275424cf93ac6333049cde90216e))
+
 ## [0.21.3](https://github.com/ERC725Alliance/erc725.js/compare/v0.21.2...v0.21.3) (2023-11-29)
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erc725/erc725.js",
-  "version": "0.21.3",
+  "version": "0.23.0",
   "description": "Library to interact with ERC725 smart contracts",
   "main": "build/main/src/index.js",
   "typings": "build/main/src/index.d.ts",

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';
@@ -1192,6 +1193,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: true,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x00000000000000000000000000000000000000000000000000000000003f3f7f',
       },
@@ -1221,6 +1223,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000000000',
       },
@@ -1250,6 +1253,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: true,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000200a00',
       },
@@ -1279,6 +1283,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000040800',
       },
@@ -1308,6 +1313,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000040004',
       },
@@ -1337,6 +1343,7 @@ describe('Running @erc725/erc725.js tests...', () => {
           SIGN: false,
           EXECUTE_RELAY_CALL: false,
           ERC4337_PERMISSION: false,
+          ALL_PERMISSIONS: false,
         },
         hex: '0x0000000000000000000000000000000000000000000000000000000000000a00',
       },
@@ -1376,13 +1383,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 +1533,7 @@ describe('Running @erc725/erc725.js tests...', () => {
             SIGN: true,
             EXECUTE_RELAY_CALL: true,
             ERC4337_PERMISSION: true,
+            ALL_PERMISSIONS: true,
           },
         );
         assert.deepStrictEqual(
@@ -1450,6 +1565,7 @@ describe('Running @erc725/erc725.js tests...', () => {
             SIGN: true,
             EXECUTE_RELAY_CALL: true,
             ERC4337_PERMISSION: true,
+            ALL_PERMISSIONS: true,
           },
         );
       });

src/index.ts

@@ -450,13 +450,53 @@ export class ERC725 {
    * @returns {*} The permissions encoded as a hexadecimal string as defined by the LSP6 Standard.
    */
   static encodePermissions(permissions: Permissions): string {
-    const result = Object.keys(permissions).reduce((previous, key) => {
-      return permissions[key]
-        ? previous | Number(hexToNumber(LSP6_DEFAULT_PERMISSIONS[key]))
-        : previous;
-    }, 0);
+    let basePermissions = BigInt(0);
 
-    return leftPad(toHex(result), 64);
+    // If ALL_PERMISSIONS is requested, start with that as the base
+    if (permissions.ALL_PERMISSIONS) {
+      basePermissions = BigInt(
+        hexToNumber(LSP6_DEFAULT_PERMISSIONS.ALL_PERMISSIONS),
+      );
+    }
+
+    // Explicitly add REENTRANCY, DELEGATECALL, and SUPER_DELEGATECALL if requested (they are not included in ALL_PERMISSIONS)
+    const additionalPermissions = [
+      LSP6_DEFAULT_PERMISSIONS.REENTRANCY,
+      LSP6_DEFAULT_PERMISSIONS.DELEGATECALL,
+      LSP6_DEFAULT_PERMISSIONS.SUPER_DELEGATECALL,
+    ];
+    additionalPermissions.forEach((permission) => {
+      if (permissions[permission]) {
+        basePermissions |= BigInt(
+          hexToNumber(LSP6_DEFAULT_PERMISSIONS[permission]),
+        );
+      }
+    });
+
+    // Process each permission to potentially switch off permissions included in ALL_PERMISSIONS
+    Object.keys(permissions).forEach((key) => {
+      const permissionValue = BigInt(
+        hexToNumber(LSP6_DEFAULT_PERMISSIONS[key]),
+      );
+
+      if (permissions[key]) {
+        // If not dealing with ALL_PERMISSIONS or additional permissions, ensure they are added
+        if (
+          !additionalPermissions.includes(key) &&
+          key !== LSP6_DEFAULT_PERMISSIONS.ALL_PERMISSIONS
+        ) {
+          basePermissions |= permissionValue;
+        }
+      } else if (
+        LSP6_DEFAULT_PERMISSIONS[key] !==
+        LSP6_DEFAULT_PERMISSIONS.ALL_PERMISSIONS
+      ) {
+        // If permission is set to false, remove it from the basePermissions
+        basePermissions &= ~permissionValue;
+      }
+    });
+    // Convert the final BigInt permission value back to a hex string, properly padded
+    return leftPad(toHex(basePermissions.toString()), 64);
   }
 
   /**
@@ -503,6 +543,7 @@ export class ERC725 {
       SIGN: false,
       EXECUTE_RELAY_CALL: false,
       ERC4337_PERMISSION: false,
+      ALL_PERMISSIONS: false,
     };
 
     const permissionsToTest = Object.keys(LSP6_DEFAULT_PERMISSIONS);

src/types/Method.ts

@@ -48,4 +48,5 @@ export interface Permissions {
   SIGN?: boolean;
   EXECUTE_RELAY_CALL?: boolean;
   ERC4337_PERMISSION?: boolean;
+  ALL_PERMISSIONS?: boolean;
 }

test/testHelpers.ts

@@ -111,3 +111,21 @@ export function generateAllResults(schemas) {
       };
     });
 }
+
+export function hexToBitPositions(hexString) {
+  const binaryString = BigInt(hexString).toString(2);
+
+  const bitPositions: number[] = [];
+
+  for (let i = binaryString.length - 1; i >= 0; i--) {
+    // The current bit is set to 1
+    if (binaryString[i] === '1') {
+      // Calculate the bit position. We subtract from the string's length to start counting from 0
+      const bitPosition = binaryString.length - 1 - i;
+      bitPositions.push(bitPosition);
+    }
+  }
+
+  // Return the array of bit positions
+  return bitPositions;
+}