Add public method `getTokenMetadataIfExistsAsync` to TokenRegistry wrapper, refactor `getTokensAsync` to use `getTokenMetadataIfExistsAsync` under the hood and added unit tests

2 files changed, 39 insertions, 12 deletions

diff --git a/src/contract_wrappers/token_registry_wrapper.ts b/src/contract_wrappers/token_registry_wrapper.ts
index eaaea150d..c78b86a88 100644
--- a/src/contract_wrappers/token_registry_wrapper.ts
+++ b/src/contract_wrappers/token_registry_wrapper.ts
@@ -1,6 +1,7 @@
 import * as _ from 'lodash';
 import {Web3Wrapper} from '../web3_wrapper';
 import {Token, TokenRegistryContract, TokenMetadata} from '../types';
+import {constants} from '../utils/constants';
 import {ContractWrapper} from './contract_wrapper';
 import * as TokenRegistryArtifacts from '../artifacts/TokenRegistry.json';
 
@@ -20,20 +21,30 @@ export class TokenRegistryWrapper extends ContractWrapper {
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
 
         const addresses = await tokenRegistryContract.getTokenAddresses.call();
-        const tokenMetadataPromises: Array<Promise<TokenMetadata>> = _.map(
+        const tokenPromises: Array<Promise<Token|undefined>> = _.map(
             addresses,
-            (address: string) => (tokenRegistryContract.getTokenMetaData.call(address)),
+            (address: string) => (this.getTokenMetadataIfExistsAsync(address)),
         );
-        const tokensMetadata = await Promise.all(tokenMetadataPromises);
-        const tokens = _.map(tokensMetadata, metadata => {
-            return {
-                address: metadata[0],
-                name: metadata[1],
-                symbol: metadata[2],
-                decimals: metadata[3].toNumber(),
-            };
-        });
-        return tokens;
+        const tokens = await Promise.all(tokenPromises);
+        return tokens as Token[];
+    }
+    /**
+     * Retrieves a token by address currently listed in the Token Registry smart contract
+     * @return  An object that conforms to the Token interface or undefined if token not found.
+     */
+    public async getTokenMetadataIfExistsAsync(address: string): Promise<Token|undefined> {
+        const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+        const metadata = await tokenRegistryContract.getTokenMetaData.call(address);
+        if (metadata[0] === constants.NULL_ADDRESS) {
+            return undefined;
+        }
+        const token = {
+            address: metadata[0],
+            name: metadata[1],
+            symbol: metadata[2],
+            decimals: metadata[3].toNumber(),
+        };
+        return token;
     }
     private _invalidateContractInstance(): void {
         delete this._tokenRegistryContractIfExists;
diff --git a/test/token_registry_wrapper_test.ts b/test/token_registry_wrapper_test.ts
index da436161c..a3e5adf6c 100644
--- a/test/token_registry_wrapper_test.ts
+++ b/test/token_registry_wrapper_test.ts
@@ -38,4 +38,20 @@ describe('TokenRegistryWrapper', () => {
             });
         });
     });
+    describe('#getTokenMetadataIfExistsAsync', () => {
+        it('should return the token added to the tokenRegistry during the migration', async () => {
+            const tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            const aToken = tokens[0];
+
+            const token = await zeroEx.tokenRegistry.getTokenMetadataIfExistsAsync(aToken.address);
+            const schemaValidator = new SchemaValidator();
+            const validationResult = schemaValidator.validate(token, tokenSchema);
+            expect(validationResult.errors).to.have.lengthOf(0);
+        });
+        it('should return return undefined when passed a token address not in the tokenRegistry', async () => {
+            const unregisteredTokenAddress = '0x5409ED021D9299bf6814279A6A1411A7e866A631';
+            const tokenIfExists = await zeroEx.tokenRegistry.getTokenMetadataIfExistsAsync(unregisteredTokenAddress);
+            expect(tokenIfExists).to.be.undefined();
+        });
+    });
 });