fix(sdk-coin-hash): add utils based on network type

TICKET: COIN-5235

Author: MohammedRyaan786

modules/sdk-coin-hash/src/hashToken.ts

@@ -1,14 +1,17 @@
 import { BitGoBase, CoinConstructor, NamedCoinConstructor } from '@bitgo/sdk-core';
 import { CosmosTokenConfig, coins, tokens } from '@bitgo/statics';
 import { Hash } from './hash';
+import { HashUtils } from './lib/utils';
 
 export class HashToken extends Hash {
   public readonly tokenConfig: CosmosTokenConfig;
+  protected readonly _utils: HashUtils;
 
   constructor(bitgo: BitGoBase, tokenConfig: CosmosTokenConfig) {
     const staticsCoin = coins.get(tokenConfig.coin);
     super(bitgo, staticsCoin);
     this.tokenConfig = tokenConfig;
+    this._utils = new HashUtils(staticsCoin.network.type);
   }
 
   static createTokenConstructor(config: CosmosTokenConfig): CoinConstructor {

modules/sdk-coin-hash/test/unit/hashToken.ts

@@ -1,9 +1,10 @@
-import 'should';
+import should = require('should');
 
 import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
 import { BitGoAPI } from '@bitgo/sdk-api';
 import { HashToken } from '../../src';
 import HashUtils from '../../src/lib/utils';
+import { mainnetAddress, testnetAddress } from '../resources/hash';
 
 describe('Hash Tokens', function () {
   let bitgo: TestBitGoAPI;
@@ -51,4 +52,87 @@ describe('Hash Tokens', function () {
   it('should return denomination for YLDS token on hash using hash as coinFamily', function () {
     HashUtils.getTokenDenomsUsingCoinFamily('hash').should.deepEqual(['uylds.fcc']);
   });
+
+  describe('Address Validation', () => {
+    it('should get address details without memoId', function () {
+      const mainnetAddressDetails = mainnetHashToken.getAddressDetails(mainnetAddress.noMemoIdAddress);
+      mainnetAddressDetails.address.should.equal(mainnetAddress.noMemoIdAddress);
+      should.not.exist(mainnetAddressDetails.memoId);
+
+      const testnetAddressDetails = testnetHashToken.getAddressDetails(testnetAddress.noMemoIdAddress);
+      testnetAddressDetails.address.should.equal(testnetAddress.noMemoIdAddress);
+      should.not.exist(testnetAddressDetails.memoId);
+    });
+
+    it('should get address details with memoId', function () {
+      const mainnetAddressDetails = mainnetHashToken.getAddressDetails(mainnetAddress.validMemoIdAddress);
+      mainnetAddressDetails.address.should.equal(mainnetAddress.validMemoIdAddress.split('?')[0]);
+      mainnetAddressDetails.memoId.should.equal('2');
+
+      const testnetAddressDetails = testnetHashToken.getAddressDetails(testnetAddress.validMemoIdAddress);
+      testnetAddressDetails.address.should.equal(testnetAddress.validMemoIdAddress.split('?')[0]);
+      testnetAddressDetails.memoId.should.equal('2');
+    });
+
+    it('should throw on multiple memo id address', () => {
+      (() => {
+        mainnetHashToken.getAddressDetails(mainnetAddress.multipleMemoIdAddress);
+      }).should.throw();
+      (() => {
+        testnetHashToken.getAddressDetails(testnetAddress.multipleMemoIdAddress);
+      }).should.throw();
+    });
+
+    it('should validate wallet receive address', async function () {
+      const receiveAddress = {
+        address: 'tp1496r8u4a48k6khknrhzd6c8cm3c64ewxy5p2rj?memoId=7',
+        coinSpecific: {
+          rootAddress: 'tp1496r8u4a48k6khknrhzd6c8cm3c64ewxy5p2rj',
+          memoID: '7',
+        },
+      };
+      const isValid = await testnetHashToken.isWalletAddress(receiveAddress);
+      isValid.should.equal(true);
+    });
+
+    it('should validate account addresses correctly', () => {
+      should.equal(mainnetHashToken._utils.isValidAddress(mainnetAddress.address1), true);
+      should.equal(mainnetHashToken._utils.isValidAddress(mainnetAddress.address2), true);
+      should.equal(mainnetHashToken._utils.isValidAddress(mainnetAddress.address3), false);
+      should.equal(mainnetHashToken._utils.isValidAddress(mainnetAddress.address4), false);
+      should.equal(mainnetHashToken._utils.isValidAddress('dfjk35y'), false);
+      should.equal(mainnetHashToken._utils.isValidAddress(undefined as unknown as string), false);
+      should.equal(mainnetHashToken._utils.isValidAddress(''), false);
+      should.equal(mainnetHashToken._utils.isValidAddress(mainnetAddress.validMemoIdAddress), true);
+      should.equal(mainnetHashToken._utils.isValidAddress(mainnetAddress.multipleMemoIdAddress), false);
+
+      should.equal(testnetHashToken._utils.isValidAddress(testnetAddress.address1), true);
+      should.equal(testnetHashToken._utils.isValidAddress(testnetAddress.address2), true);
+      should.equal(testnetHashToken._utils.isValidAddress(testnetAddress.address3), false);
+      should.equal(testnetHashToken._utils.isValidAddress(testnetAddress.address4), false);
+      should.equal(testnetHashToken._utils.isValidAddress('dfjk35y'), false);
+      should.equal(testnetHashToken._utils.isValidAddress(undefined as unknown as string), false);
+      should.equal(testnetHashToken._utils.isValidAddress(''), false);
+      should.equal(testnetHashToken._utils.isValidAddress(testnetAddress.validMemoIdAddress), true);
+      should.equal(testnetHashToken._utils.isValidAddress(testnetAddress.multipleMemoIdAddress), false);
+    });
+
+    it('should validate validator addresses correctly', () => {
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress(mainnetAddress.validatorAddress1), true);
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress(mainnetAddress.validatorAddress2), true);
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress(mainnetAddress.validatorAddress3), false);
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress(mainnetAddress.validatorAddress4), false);
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress('dfjk35y'), false);
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress(undefined as unknown as string), false);
+      should.equal(mainnetHashToken._utils.isValidValidatorAddress(''), false);
+
+      should.equal(testnetHashToken._utils.isValidValidatorAddress(testnetAddress.validatorAddress1), true);
+      should.equal(testnetHashToken._utils.isValidValidatorAddress(testnetAddress.validatorAddress2), true);
+      should.equal(testnetHashToken._utils.isValidValidatorAddress(testnetAddress.validatorAddress3), false);
+      should.equal(testnetHashToken._utils.isValidValidatorAddress(testnetAddress.validatorAddress4), false);
+      should.equal(testnetHashToken._utils.isValidValidatorAddress('dfjk35y'), false);
+      should.equal(testnetHashToken._utils.isValidValidatorAddress(undefined as unknown as string), false);
+      should.equal(testnetHashToken._utils.isValidValidatorAddress(''), false);
+    });
+  });
 });