fix: check payee and payer identity format at the creation (#187)

RequestNetwork · Apr 6, 2020 · 661ce3c · 661ce3c
1 parent 5988865
commit 661ce3c
Show file tree

Hide file tree

Showing 3 changed files with 135 additions and 14 deletions.
diff --git a/packages/request-logic/src/actions/create.ts b/packages/request-logic/src/actions/create.ts
@@ -36,18 +36,12 @@ function format(
     throw new Error('expectedAmount must be a positive integer');
   }
 
-  if (
-    requestParameters.payee &&
-    requestParameters.payee.type !== IdentityTypes.TYPE.ETHEREUM_ADDRESS
-  ) {
-    throw new Error('payee.type not supported');
+  if (requestParameters.payee && Utils.identity.hasError(requestParameters.payee)) {
+    throw new Error(`payee: ${Utils.identity.hasError(requestParameters.payee)}̀`);
   }
 
-  if (
-    requestParameters.payer &&
-    requestParameters.payer.type !== IdentityTypes.TYPE.ETHEREUM_ADDRESS
-  ) {
-    throw new Error('payer.type not supported');
+  if (requestParameters.payer && Utils.identity.hasError(requestParameters.payer)) {
+    throw new Error(`payer: ${Utils.identity.hasError(requestParameters.payer)}̀`);
   }
 
   if (!requestParameters.timestamp) {
@@ -91,6 +85,14 @@ function createRequest(
     throw new Error('action.parameters.payee or action.parameters.payer must be given');
   }
 
+  if (action.data.parameters.payee && Utils.identity.hasError(action.data.parameters.payee)) {
+    throw new Error(`payee: ${Utils.identity.hasError(action.data.parameters.payee)}̀`);
+  }
+
+  if (action.data.parameters.payer && Utils.identity.hasError(action.data.parameters.payer)) {
+    throw new Error(`payer: ${Utils.identity.hasError(action.data.parameters.payer)}̀`);
+  }
+
   if (
     !Utils.isString(action.data.parameters.expectedAmount) ||
     !Utils.amount.isValid(action.data.parameters.expectedAmount)

diff --git a/packages/request-logic/test/unit/actions/create.test.ts b/packages/request-logic/test/unit/actions/create.test.ts
@@ -563,10 +563,11 @@ describe('CreateAction', () => {
           type: 'not_ethereumAddress',
           value: '0xAf083f77F1fFd54218d91491AFD06c9296EaC3ce',
         },
+        payer: TestData.payerRaw.identity,
       };
       expect(() =>
-        CreateAction.format(params, TestData.payeeRaw.identity, TestData.fakeSignatureProvider),
-      ).to.throw('payee.type not supported');
+        CreateAction.format(params, TestData.payerRaw.identity, TestData.fakeSignatureProvider),
+      ).to.throw('payee: identity type not supported');
     });
     it('does not support other identity type than "ethereumAddress" for Payer', () => {
       const params: any = {
@@ -575,14 +576,49 @@ describe('CreateAction', () => {
           value: 'ETH',
         },
         expectedAmount: '1000',
+        payee: TestData.payeeRaw.identity,
         payer: {
           type: 'not_ethereumAddress',
           value: '0xAf083f77F1fFd54218d91491AFD06c9296EaC3ce',
         },
       };
       expect(() =>
         CreateAction.format(params, TestData.payeeRaw.identity, TestData.fakeSignatureProvider),
-      ).to.throw('payer.type not supported');
+      ).to.throw('payer: identity type not supported');
+    });
+
+    it('does not support other identity value not ethereum for Payee', () => {
+      const params: any = {
+        currency: {
+          type: RequestLogicTypes.CURRENCY.ETH,
+          value: 'ETH',
+        },
+        expectedAmount: '1000',
+        payee: {
+          type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
+          value: 'not valid ethereum',
+        },
+      };
+      expect(() =>
+        CreateAction.format(params, TestData.payeeRaw.identity, TestData.fakeSignatureProvider),
+      ).to.throw('payee: identity value must be an ethereum address');
+    });
+
+    it('does not support other identity value not ethereum for Payer', () => {
+      const params: any = {
+        currency: {
+          type: RequestLogicTypes.CURRENCY.ETH,
+          value: 'ETH',
+        },
+        expectedAmount: '1000',
+        payer: {
+          type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
+          value: 'not valid ethereum',
+        },
+      };
+      expect(() =>
+        CreateAction.format(params, TestData.payeeRaw.identity, TestData.fakeSignatureProvider),
+      ).to.throw('payer: identity value must be an ethereum address');
     });
   });
 
@@ -1068,7 +1104,73 @@ describe('CreateAction', () => {
         signature: TestData.fakeSignature,
       };
       expect(() => CreateAction.createRequest(action, 2)).to.throw(
-        'Signer must be the payee or the payer',
+        'payee: identity type not supported',
+      );
+    });
+
+    it('does not support other identity type than "ethereumAddress" for Payer', () => {
+      const action = {
+        data: {
+          name: RequestLogicTypes.ACTION_NAME.CREATE,
+          parameters: {
+            currency: 'ETH',
+            expectedAmount: TestData.arbitraryExpectedAmount,
+            extensionsData: [{ id: 'extension1', value: 'whatever' }],
+            payer: {
+              type: 'not_ethereumAddress',
+              value: '0xAf083f77F1fFd54218d91491AFD06c9296EaC3ce',
+            },
+          },
+          version: CURRENT_VERSION,
+        },
+        signature: TestData.fakeSignature,
+      };
+      expect(() => CreateAction.createRequest(action, 2)).to.throw(
+        'payer: identity type not supported',
+      );
+    });
+
+    it('does not support identity value not being an "ethereumAddress" for Payee', () => {
+      const action = {
+        data: {
+          name: RequestLogicTypes.ACTION_NAME.CREATE,
+          parameters: {
+            currency: 'ETH',
+            expectedAmount: TestData.arbitraryExpectedAmount,
+            extensionsData: [{ id: 'extension1', value: 'whatever' }],
+            payee: {
+              type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
+              value: 'not an address',
+            },
+          },
+          version: CURRENT_VERSION,
+        },
+        signature: TestData.fakeSignature,
+      };
+      expect(() => CreateAction.createRequest(action, 2)).to.throw(
+        'payee: identity value must be an ethereum address',
+      );
+    });
+
+    it('does not support identity value not being an "ethereumAddress" for Payer', () => {
+      const action = {
+        data: {
+          name: RequestLogicTypes.ACTION_NAME.CREATE,
+          parameters: {
+            currency: 'ETH',
+            expectedAmount: TestData.arbitraryExpectedAmount,
+            extensionsData: [{ id: 'extension1', value: 'whatever' }],
+            payer: {
+              type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
+              value: 'not an address',
+            },
+          },
+          version: CURRENT_VERSION,
+        },
+        signature: TestData.fakeSignature,
+      };
+      expect(() => CreateAction.createRequest(action, 2)).to.throw(
+        'payer: identity value must be an ethereum address',
       );
     });
   });

diff --git a/packages/utils/src/identity.ts b/packages/utils/src/identity.ts
@@ -5,6 +5,7 @@ import { IdentityTypes } from '@requestnetwork/types';
  */
 export default {
   areEqual,
+  hasError,
   normalizeIdentityValue,
 };
 
@@ -30,3 +31,19 @@ function areEqual(id1: IdentityTypes.IIdentity, id2: IdentityTypes.IIdentity): b
 function normalizeIdentityValue(value: string): string {
   return value.toLowerCase();
 }
+
+/**
+ * Checks if the identity has an error
+ *
+ * @param id identity to check
+ * @returns the error or null if valid
+ */
+function hasError(id: IdentityTypes.IIdentity): string | null {
+  if (id.type !== IdentityTypes.TYPE.ETHEREUM_ADDRESS) {
+    return 'identity type not supported';
+  }
+  if (id.value.match(/^0x[a-fA-F0-9]{40}$/) === null) {
+    return 'identity value must be an ethereum address';
+  }
+  return null;
+}