feat: add support for new getData([])

ERC725Alliance · Oct 29, 2021 · 0ef7f27 · 0ef7f27
1 parent daadd0d
commit 0ef7f27
Show file tree

Hide file tree

Showing 8 changed files with 832 additions and 261 deletions.
diff --git a/src/index.test.ts b/src/index.test.ts
diff --git a/src/lib/constants.ts b/src/lib/constants.ts
@@ -3,14 +3,27 @@ import { numberToHex, keccak256 } from 'web3-utils';
 
 import { MethodData, Encoding, Method } from '../types/Method';
 
+// https://github.com/ERC725Alliance/ERC725/blob/develop/docs/ERC-725.md#specification
+export const INTERFACE_IDS = {
+  ERC725Y_LEGACY: '0x2bd57b73',
+  ERC725Y: '0x5a988c0f',
+};
+
 export const METHODS: Record<Method, MethodData> = {
-  [Method.GET_DATA]: {
+  [Method.GET_DATA_LEGACY]: {
     sig: '0x54f6127f',
     gas: numberToHex(2000000),
     gasPrice: numberToHex(100000000),
     value: numberToHex(0),
     returnEncoding: Encoding.BYTES,
   },
+  [Method.GET_DATA]: {
+    sig: '0x4e3e6e9c',
+    gas: numberToHex(2000000),
+    gasPrice: numberToHex(100000000),
+    value: numberToHex(0),
+    returnEncoding: Encoding.BYTES_ARRAY,
+  },
   [Method.DATA_COUNT]: {
     sig: '0x5da40c47',
     gas: numberToHex(2000000),
@@ -32,6 +45,13 @@ export const METHODS: Record<Method, MethodData> = {
     value: numberToHex(0),
     returnEncoding: Encoding.ADDRESS,
   },
+  [Method.SUPPORTS_INTERFACE]: {
+    sig: '0x01ffc9a7',
+    gas: numberToHex(2000000),
+    gasPrice: numberToHex(100000000),
+    value: numberToHex(0),
+    returnEncoding: Encoding.BOOL,
+  },
 };
 
 export enum SUPPORTED_HASH_FUNCTION_STRINGS {

diff --git a/src/providers/ethereumProviderWrapper.ts b/src/providers/ethereumProviderWrapper.ts
@@ -24,7 +24,7 @@
 
 import * as abi from 'web3-eth-abi';
 
-import { METHODS } from '../lib/constants';
+import { INTERFACE_IDS, METHODS } from '../lib/constants';
 import { Method } from '../types/Method';
 import { ProviderTypes } from '../types/provider';
 
@@ -49,11 +49,59 @@ export class EthereumProviderWrapper {
     return this.decodeResult(Method.OWNER, result);
   }
 
+  /**
+   * https://eips.ethereum.org/EIPS/eip-165
+   *
+   * @param address the smart contract address
+   * @param interfaceId ERC-165 identifier as described here: https://github.com/ERC725Alliance/ERC725/blob/develop/docs/ERC-725.md#specification
+   */
+  async supportsInterface(address: string, interfaceId: string) {
+    return this.decodeResult(
+      Method.SUPPORTS_INTERFACE,
+      await this.callContract([
+        this.constructJSONRPC(
+          address,
+          Method.SUPPORTS_INTERFACE,
+          `${interfaceId}${'00000000000000000000000000000000000000000000000000000000'}`,
+        ),
+      ]),
+    );
+  }
+
   async getData(address: string, keyHash: string) {
-    const result = await this.callContract([
-      this.constructJSONRPC(address, Method.GET_DATA, keyHash),
-    ]);
-    return this.decodeResult(Method.GET_DATA, result);
+    let isErc725Y = false;
+    let isErc725YLegacy = false;
+
+    isErc725Y = await this.supportsInterface(address, INTERFACE_IDS.ERC725Y);
+
+    if (!isErc725Y) {
+      isErc725YLegacy = await this.supportsInterface(
+        address,
+        INTERFACE_IDS.ERC725Y_LEGACY,
+      );
+    }
+
+    if (!isErc725Y && !isErc725YLegacy) {
+      throw new Error(
+        `Contract: ${address} does not support ERC725Y interface.`,
+      );
+    }
+
+    if (isErc725Y) {
+      return this.decodeResult(
+        Method.GET_DATA,
+        await this.callContract([
+          this.constructJSONRPC(address, Method.GET_DATA, keyHash),
+        ]),
+      )[0];
+    }
+
+    return this.decodeResult(
+      Method.GET_DATA_LEGACY,
+      await this.callContract([
+        this.constructJSONRPC(address, Method.GET_DATA_LEGACY, keyHash),
+      ]),
+    );
   }
 
   async getAllData(address: string, keys: string[]) {
@@ -63,9 +111,13 @@ export class EthereumProviderWrapper {
     }[] = [];
 
     for (let index = 0; index < keys.length; index++) {
+      // TODO: call getData with array instead of multiple calls with 1 element
+      const value = await this.getData(address, keys[index]);
+
       results.push({
         key: keys[index],
-        value: await this.getData(address, keys[index]),
+        // TODO: get the interface id here to prevent multiple calls in getData
+        value,
       });
     }
 

diff --git a/src/providers/web3ProviderWrapper.ts b/src/providers/web3ProviderWrapper.ts
@@ -22,10 +22,17 @@
   in accordance with implementation of smart contract interfaces of ERC725
 */
 
+import AbiCoder from 'web3-eth-abi';
+
 import { JsonRpc } from '../types/JsonRpc';
 import { Method } from '../types/Method';
 import { constructJSONRPC, decodeResult } from '../lib/provider-wrapper-utils';
 import { ProviderTypes } from '../types/provider';
+import { INTERFACE_IDS } from '../lib/constants';
+
+// TS can't get the types from the import...
+// @ts-ignore
+const abiCoder: AbiCoder.AbiCoder = AbiCoder;
 
 export class Web3ProviderWrapper {
   type: ProviderTypes;
@@ -46,19 +53,97 @@ export class Web3ProviderWrapper {
     return decodeResult(Method.OWNER, result);
   }
 
+  /**
+   * https://eips.ethereum.org/EIPS/eip-165
+   *
+   * @param address the smart contract address
+   * @param interfaceId ERC-165 identifier as described here: https://github.com/ERC725Alliance/ERC725/blob/develop/docs/ERC-725.md#specification
+   */
+  async supportsInterface(address: string, interfaceId: string) {
+    return decodeResult(
+      Method.SUPPORTS_INTERFACE,
+      await this.callContract(
+        constructJSONRPC(
+          address,
+          Method.SUPPORTS_INTERFACE,
+          `${interfaceId}${'00000000000000000000000000000000000000000000000000000000'}`,
+        ),
+      ),
+    );
+  }
+
   async getData(address: string, keyHash: string) {
+    let isErc725Y = false;
+    let isErc725YLegacy = false;
+
+    isErc725Y = await this.supportsInterface(address, INTERFACE_IDS.ERC725Y);
+
+    if (!isErc725Y) {
+      isErc725YLegacy = await this.supportsInterface(
+        address,
+        INTERFACE_IDS.ERC725Y_LEGACY,
+      );
+    }
+
+    if (!isErc725Y && !isErc725YLegacy) {
+      throw new Error(
+        `Contract: ${address} does not support ERC725Y interface.`,
+      );
+    }
+
+    if (isErc725Y) {
+      return decodeResult(
+        Method.GET_DATA,
+        await this.callContract(
+          constructJSONRPC(
+            address,
+            Method.GET_DATA,
+            abiCoder.encodeParameter('bytes32[]', [keyHash]),
+          ),
+        ),
+      )[0];
+    }
+
     return decodeResult(
-      Method.GET_DATA,
+      Method.GET_DATA_LEGACY,
       await this.callContract(
-        constructJSONRPC(address, Method.GET_DATA, keyHash),
+        constructJSONRPC(address, Method.GET_DATA_LEGACY, keyHash),
       ),
     );
   }
 
   async getAllData(address: string, keys: string[]) {
+    let isErc725Y = false;
+    let isErc725YLegacy = false;
+
+    isErc725Y = await this.supportsInterface(address, INTERFACE_IDS.ERC725Y);
+
+    if (!isErc725Y) {
+      isErc725YLegacy = await this.supportsInterface(
+        address,
+        INTERFACE_IDS.ERC725Y_LEGACY,
+      );
+    }
+
+    if (!isErc725Y && !isErc725YLegacy) {
+      throw new Error(
+        `Contract: ${address} does not support ERC725Y interface.`,
+      );
+    }
+
+    const method = isErc725Y ? Method.GET_DATA : Method.GET_DATA_LEGACY;
+
     const payload: JsonRpc[] = [];
     for (let index = 0; index < keys.length; index++) {
-      payload.push(constructJSONRPC(address, Method.GET_DATA, keys[index]));
+      payload.push(
+        constructJSONRPC(
+          address,
+          method,
+          isErc725Y
+            ? abiCoder.encodeParameter('bytes32[]', [keys[index]])
+            : keys[index],
+        ),
+      );
     }
 
     const results: any = await this.callContract(payload);
@@ -69,12 +154,14 @@ export class Web3ProviderWrapper {
       value: Record<string, any> | null;
     }[] = [];
     for (let index = 0; index < payload.length; index++) {
+      const decodedValue = decodeResult(
+        method,
+        results.find((element) => payload[index].id === element.id),
+      );
+
       returnValues.push({
         key: keys[index],
-        value: decodeResult(
-          Method.GET_DATA,
-          results.find((element) => payload[index].id === element.id),
-        ),
+        value: isErc725Y ? decodedValue[0] : decodedValue,
       });
     }
 

diff --git a/src/types/Method.ts b/src/types/Method.ts
@@ -1,14 +1,18 @@
 export enum Method {
-  GET_DATA = 'getData',
+  GET_DATA_LEGACY = 'getDataLegacy', // For legacy ERC725 with interface id: 0x2bd57b73 NOTE: I had to add Legacy at the end so the map keys stays unique
+  GET_DATA = 'getData', // For latest ERC725 with interface id: 0x5a988c0f
   DATA_COUNT = 'dataCount',
   ALL_DATA = 'allData',
   OWNER = 'owner',
+  SUPPORTS_INTERFACE = 'supportsInterface',
 }
 
 export enum Encoding {
   BYTES = 'bytes',
+  BOOL = 'bool',
   UINT256 = 'uint256',
   BYTES32_ARRAY = 'bytes32[]',
+  BYTES_ARRAY = 'bytes[]',
   ADDRESS = 'address',
 }