Use orderHashSchema to validate order hash

src/0x.ts

@@ -17,7 +17,8 @@ import {ecSignatureSchema} from './schemas/ec_signature_schema';
 import {TokenWrapper} from './contract_wrappers/token_wrapper';
 import {ProxyWrapper} from './contract_wrappers/proxy_wrapper';
 import {ECSignature, ZeroExError, Order, SignedOrder, Web3Provider} from './types';
-import {orderSchema} from './schemas/order_schemas';
+import {orderSchema, orderHashSchema} from './schemas/order_schemas';
+import {SchemaValidator} from './utils/schema_validator';
 
 // Customize our BigNumber instances
 bigNumberConfigs.configure();
@@ -110,7 +111,8 @@ export class ZeroEx {
         // Since this method can be called to check if any arbitrary string conforms to an orderHash's
         // format, we only assert that we were indeed passed a string.
         assert.isString('orderHash', orderHash);
-        const isValidOrderHash = utils.isValidOrderHash(orderHash);
+        const schemaValidator = new SchemaValidator();
+        const isValidOrderHash = schemaValidator.validate(orderHash, orderHashSchema).valid;
         return isValidOrderHash;
     }
     /**

src/contract_wrappers/exchange_wrapper.ts

@@ -43,7 +43,7 @@ import {signedOrdersSchema} from '../schemas/signed_orders_schema';
 import {orderFillRequestsSchema} from '../schemas/order_fill_requests_schema';
 import {orderCancellationRequestsSchema} from '../schemas/order_cancel_schema';
 import {orderFillOrKillRequestsSchema} from '../schemas/order_fill_or_kill_requests_schema';
-import {signedOrderSchema, orderSchema} from '../schemas/order_schemas';
+import {signedOrderSchema, orderSchema, orderHashSchema} from '../schemas/order_schemas';
 import {constants} from '../utils/constants';
 import {TokenWrapper} from './token_wrapper';
 import {decorators} from '../utils/decorators';
@@ -105,7 +105,7 @@ export class ExchangeWrapper extends ContractWrapper {
      */
     public async getUnavailableTakerAmountAsync(orderHash: string,
                                                 exchangeContractAddress: string): Promise<BigNumber.BigNumber> {
-        assert.isValidOrderHash('orderHash', orderHash);
+        assert.doesConformToSchema('orderHash', orderHash, orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync(exchangeContractAddress);
         let unavailableAmountInBaseUnits = await exchangeContract.getUnavailableValueT.call(orderHash);
@@ -121,7 +121,7 @@ export class ExchangeWrapper extends ContractWrapper {
      */
     public async getFilledTakerAmountAsync(orderHash: string,
                                            exchangeContractAddress: string): Promise<BigNumber.BigNumber> {
-        assert.isValidOrderHash('orderHash', orderHash);
+        assert.doesConformToSchema('orderHash', orderHash, orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync(exchangeContractAddress);
         let fillAmountInBaseUnits = await exchangeContract.filled.call(orderHash);
@@ -138,7 +138,7 @@ export class ExchangeWrapper extends ContractWrapper {
      */
     public async getCanceledTakerAmountAsync(orderHash: string,
                                              exchangeContractAddress: string): Promise<BigNumber.BigNumber> {
-        assert.isValidOrderHash('orderHash', orderHash);
+        assert.doesConformToSchema('orderHash', orderHash, orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync(exchangeContractAddress);
         let cancelledAmountInBaseUnits = await exchangeContract.cancelled.call(orderHash);

src/utils/assert.ts

@@ -45,13 +45,10 @@ export const assert = {
     isNumber(variableName: string, value: number): void {
         this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
     },
-    isValidOrderHash(variableName: string, value: string): void {
-        this.assert(utils.isValidOrderHash(value), this.typeAssertionMessage(variableName, 'orderHash', value));
-    },
     isBoolean(variableName: string, value: boolean): void {
         this.assert(_.isBoolean(value), this.typeAssertionMessage(variableName, 'boolean', value));
     },
-    doesConformToSchema(variableName: string, value: object, schema: Schema): void {
+    doesConformToSchema(variableName: string, value: any, schema: Schema): void {
         const schemaValidator = new SchemaValidator();
         const validationResult = schemaValidator.validate(value, schema);
         const hasValidationErrors = validationResult.errors.length > 0;

src/utils/utils.ts

@@ -25,10 +25,6 @@ export const utils = {
     isTestRpc(nodeVersion: string): boolean {
         return _.includes(nodeVersion, 'TestRPC');
     },
-    isValidOrderHash(orderHashHex: string): boolean {
-        const isValid = /^0x[0-9A-F]{64}$/i.test(orderHashHex);
-        return isValid;
-    },
     spawnSwitchErr(name: string, value: any): Error {
         return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
     },