feat(transaction-manager): decrypt channels (#516)

**Transaction-manager**:
* Decrypt encrypted channel
* add CleatTransaction class
* add EncryptedTransaction class
* parse persistedTransaction with TransactionParser

**Epk-decryption**:
- add isIdentityRegistered()

Author: vrolland

.eslintrc

@@ -72,6 +72,7 @@
           "metadata",
           "mul",
           "namespace",
+          "parallelize",
           "param",
           "params",
           "parsable",

packages/epk-decryption/src/ethereum-private-key-decryption-provider.ts

@@ -55,6 +55,19 @@ export default class EthereumPrivateKeyDecryptionProvider
     return Utils.encryption.decrypt(data, decryptionParameters);
   }
 
+  /**
+   * Check if an identity is registered in the provider
+   *
+   * @param identity identity to check
+   *
+   * @returns true if the identity is registered, false otherwise
+   */
+  public async isIdentityRegistered(identity: IdentityTypes.IIdentity): Promise<boolean> {
+    return Array.from(this.decryptionParametersDictionary.keys()).some(
+      address => identity.value.toLowerCase() === address.toLowerCase(),
+    );
+  }
+
   /**
    * Adds a new private key in the provider
    *

packages/epk-decryption/test/ethereum-private-key-decryption-provider-test.ts

@@ -224,4 +224,22 @@ describe('ethereum-private-key-decryption-provider', () => {
       ).to.eventually.be.rejectedWith('private key unknown for the identity: 0x000');
     });
   });
+  describe('isIdentityRegistered', () => {
+    it('can check if an identity is registered', async () => {
+      const decryptionProvider = new EthereumPrivateKeyDecryptionProvider(id1Raw.decryptionParams);
+
+      expect(
+        await decryptionProvider.isIdentityRegistered(id1Raw.identity),
+        'id1Raw must be registered',
+      ).to.be.true;
+    });
+
+    it('can check if an identity is NOT registered', async () => {
+      const decryptionProvider = new EthereumPrivateKeyDecryptionProvider(id1Raw.decryptionParams);
+      expect(
+        await decryptionProvider.isIdentityRegistered(id2Raw.identity),
+        'id2Raw must not be registered',
+      ).to.be.false;
+    });
+  });
 });

packages/request-logic/src/request-logic.ts

@@ -282,9 +282,8 @@ export default class RequestLogic implements RequestLogicTypes.IRequestLogic {
     requestId: string,
   ): Promise<RequestLogicTypes.IReturnGetRequestFromId> {
     const resultGetTx = await this.transactionManager.getTransactionsByChannelId(requestId);
-
     const actions = resultGetTx.result.transactions
-      // remove the actions ignored by the under layer
+      // filter the actions ignored by the previous layers
       .filter(action => action !== null);
     let ignoredTransactions: any[] = [];
 

packages/transaction-manager/specs/decryption-provider.md

@@ -26,6 +26,16 @@ This read-only property lists in an array all the identity types the decryption
 
 Possible values: `'ethereumAddress'`
 
+### `isIdentityRegistered()`
+
+This function checks if it is possible to decrypt from a specific identity.
+
+| Parameters   | Type     | Description       |
+| ------------ | -------- | ----------------- |
+| **identity** | Identity | Identity to check |
+
+Returns: `true` if the identity is registered in the provider, `false` otherwise.
+
 ### `decrypt()`
 
 This function is able to decrypt encrypted data with the methods listed in `supportedMethods` and for the identity types listed in `supportedIdentityTypes`

packages/transaction-manager/src/clear-transaction.ts

@@ -0,0 +1,45 @@
+import { TransactionTypes } from '@requestnetwork/types';
+import Utils from '@requestnetwork/utils';
+
+/**
+ * Class representing a clear transaction
+ */
+export default class ClearTransaction implements TransactionTypes.ITransaction {
+  private data: TransactionTypes.ITransactionData;
+
+  constructor(data: TransactionTypes.ITransactionData) {
+    this.data = data;
+  }
+
+  /**
+   * Gets the data of the transaction
+   *
+   * @returns a promise resolving the transaction data
+   */
+  public async getData(): Promise<TransactionTypes.ITransactionData> {
+    return this.data;
+  }
+
+  /**
+   * Gets the transaction data hash
+   *
+   * @returns a promise resolving the transaction data hash
+   */
+  public async getHash(): Promise<string> {
+    return Utils.crypto.normalizeKeccak256Hash(JSON.parse(this.data));
+  }
+
+  /**
+   * Gets the transaction error
+   *
+   * @returns a promise resolving a string of the error if any, otherwise an empty string
+   */
+  public async getError(): Promise<string> {
+    try {
+      JSON.parse(this.data);
+      return '';
+    } catch (e) {
+      return 'Impossible to JSON parse the transaction';
+    }
+  }
+}

packages/transaction-manager/src/encrypted-transaction.ts

@@ -0,0 +1,87 @@
+import { EncryptionTypes, TransactionTypes } from '@requestnetwork/types';
+import Utils from '@requestnetwork/utils';
+
+/**
+ * Class representing an encrypted transaction
+ */
+export default class EncryptedTransaction implements TransactionTypes.ITransaction {
+  /** Decrypted data - start empty then filled by getData() */
+  private data: TransactionTypes.ITransactionData = '';
+
+  /** Hash computed from the decrypted data - start empty then filled by getHash() */
+  private dataHash: string = '';
+
+  /** Encrypted data */
+  private encryptedData: TransactionTypes.ITransactionData;
+
+  /** hash given by the persisted transaction */
+  private hashFromPersistedTransaction: string;
+
+  /** channel key to decrypt the encrypted data */
+  private channelKey: EncryptionTypes.IDecryptionParameters;
+
+  /**
+   * Creates an instance of EncryptedTransaction.
+   * @param encryptedData the encrypted data of the transaction
+   * @param hashFromPersistedTransaction the hash of the decrypted data (not checked)
+   * @param channelKey decryption parameters to decrypted the encrypted data
+   */
+  constructor(
+    encryptedData: TransactionTypes.ITransactionData,
+    hashFromPersistedTransaction: string,
+    channelKey: EncryptionTypes.IDecryptionParameters,
+  ) {
+    this.encryptedData = encryptedData;
+    this.channelKey = channelKey;
+    this.hashFromPersistedTransaction = hashFromPersistedTransaction;
+  }
+
+  /**
+   * Gets the data of the transaction
+   *
+   * @returns a promise resolving the transaction data
+   */
+  public async getData(): Promise<TransactionTypes.ITransactionData> {
+    if (this.data === '') {
+      try {
+        this.data = await Utils.encryption.decrypt(this.encryptedData, this.channelKey);
+      } catch {
+        throw new Error('Impossible to decrypt the transaction');
+      }
+    }
+    return this.data;
+  }
+
+  /**
+   * Gets the transaction data hash
+   *
+   * @returns a promise resolving the transaction data hash
+   */
+  public async getHash(): Promise<string> {
+    if (this.dataHash === '') {
+      const data = await this.getData();
+      try {
+        this.dataHash = await Utils.crypto.normalizeKeccak256Hash(JSON.parse(data));
+      } catch (e) {
+        throw new Error('Impossible to JSON parse the decrypted transaction data');
+      }
+    }
+    return this.dataHash;
+  }
+
+  /**
+   * Gets the transaction error
+   *
+   * @returns a promise resolving a string of the error if any, otherwise an empty string
+   */
+  public async getError(): Promise<string> {
+    try {
+      if ((await this.getHash()) !== this.hashFromPersistedTransaction) {
+        throw Error('The given hash does not match the hash of the decrypted data');
+      }
+      return '';
+    } catch (error) {
+      return error.message;
+    }
+  }
+}