Add config file specifically in prettier command and fix files

5 files changed, 371 insertions, 371 deletions

diff --git a/packages/assert/package.json b/packages/assert/package.json
index 0e10b3384..a2d195728 100644
--- a/packages/assert/package.json
+++ b/packages/assert/package.json
@@ -1,45 +1,45 @@
 {
-	"name": "@0xproject/assert",
-	"version": "0.0.13",
-	"description": "Provides a standard way of performing type and schema validation across 0x projects",
-	"main": "lib/src/index.js",
-	"types": "lib/src/index.d.ts",
-	"scripts": {
-		"build": "tsc",
-		"clean": "shx rm -rf _bundles lib test_temp",
-		"lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
-		"run_mocha": "mocha lib/test/**/*_test.js",
-		"prepublishOnly": "run-p build",
-		"test": "run-s clean build run_mocha",
-		"test:circleci": "yarn test"
-	},
-	"license": "Apache-2.0",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/0xProject/0x.js.git"
-	},
-	"bugs": {
-		"url": "https://github.com/0xProject/0x.js/issues"
-	},
-	"homepage": "https://github.com/0xProject/0x.js/packages/assert/README.md",
-	"devDependencies": {
-		"@0xproject/tslint-config": "^0.4.4",
-		"@types/lodash": "^4.14.86",
-		"@types/mocha": "^2.2.42",
-		"@types/valid-url": "^1.0.2",
-		"chai": "^4.0.1",
-		"chai-typescript-typings": "^0.0.2",
-		"dirty-chai": "^2.0.1",
-		"mocha": "^4.0.1",
-		"npm-run-all": "^4.1.2",
-		"shx": "^0.2.2",
-		"tslint": "5.8.0",
-		"typescript": "~2.6.1"
-	},
-	"dependencies": {
-		"@0xproject/json-schemas": "^0.7.5",
-		"@0xproject/utils": "^0.2.2",
-		"lodash": "^4.17.4",
-		"valid-url": "^1.0.9"
-	}
+    "name": "@0xproject/assert",
+    "version": "0.0.13",
+    "description": "Provides a standard way of performing type and schema validation across 0x projects",
+    "main": "lib/src/index.js",
+    "types": "lib/src/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "clean": "shx rm -rf _bundles lib test_temp",
+        "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
+        "run_mocha": "mocha lib/test/**/*_test.js",
+        "prepublishOnly": "run-p build",
+        "test": "run-s clean build run_mocha",
+        "test:circleci": "yarn test"
+    },
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/0xProject/0x.js.git"
+    },
+    "bugs": {
+        "url": "https://github.com/0xProject/0x.js/issues"
+    },
+    "homepage": "https://github.com/0xProject/0x.js/packages/assert/README.md",
+    "devDependencies": {
+        "@0xproject/tslint-config": "^0.4.4",
+        "@types/lodash": "^4.14.86",
+        "@types/mocha": "^2.2.42",
+        "@types/valid-url": "^1.0.2",
+        "chai": "^4.0.1",
+        "chai-typescript-typings": "^0.0.2",
+        "dirty-chai": "^2.0.1",
+        "mocha": "^4.0.1",
+        "npm-run-all": "^4.1.2",
+        "shx": "^0.2.2",
+        "tslint": "5.8.0",
+        "typescript": "~2.6.1"
+    },
+    "dependencies": {
+        "@0xproject/json-schemas": "^0.7.5",
+        "@0xproject/utils": "^0.2.2",
+        "lodash": "^4.17.4",
+        "valid-url": "^1.0.9"
+    }
 }
diff --git a/packages/assert/src/index.ts b/packages/assert/src/index.ts
index 0578bd303..7ad574ec7 100644
--- a/packages/assert/src/index.ts
+++ b/packages/assert/src/index.ts
@@ -6,89 +6,89 @@ import * as validUrl from 'valid-url';
 const HEX_REGEX = /^0x[0-9A-F]*$/i;
 
 export const assert = {
-	isBigNumber(variableName: string, value: BigNumber): void {
-		const isBigNumber = _.isObject(value) && (value as any).isBigNumber;
-		this.assert(isBigNumber, this.typeAssertionMessage(variableName, 'BigNumber', value));
-	},
-	isValidBaseUnitAmount(variableName: string, value: BigNumber) {
-		assert.isBigNumber(variableName, value);
-		const isNegative = value.lessThan(0);
-		this.assert(!isNegative, `${variableName} cannot be a negative number, found value: ${value.toNumber()}`);
-		const hasDecimals = value.decimalPlaces() !== 0;
-		this.assert(
-			!hasDecimals,
-			`${variableName} should be in baseUnits (no decimals), found value: ${value.toNumber()}`,
-		);
-	},
-	isString(variableName: string, value: string): void {
-		this.assert(_.isString(value), this.typeAssertionMessage(variableName, 'string', value));
-	},
-	isFunction(variableName: string, value: any): void {
-		this.assert(_.isFunction(value), this.typeAssertionMessage(variableName, 'function', value));
-	},
-	isHexString(variableName: string, value: string): void {
-		this.assert(
-			_.isString(value) && HEX_REGEX.test(value),
-			this.typeAssertionMessage(variableName, 'HexString', value),
-		);
-	},
-	isETHAddressHex(variableName: string, value: string): void {
-		this.assert(addressUtils.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
-		this.assert(
-			addressUtils.isAddress(value) && value.toLowerCase() === value,
-			`Checksummed addresses are not supported. Convert ${variableName} to lower case before passing`,
-		);
-	},
-	doesBelongToStringEnum(
-		variableName: string,
-		value: string,
-		stringEnum: any /* There is no base type for every string enum */,
-	): void {
-		const doesBelongToStringEnum = !_.isUndefined(stringEnum[value]);
-		const enumValues = _.keys(stringEnum);
-		const enumValuesAsStrings = _.map(enumValues, enumValue => `'${enumValue}'`);
-		const enumValuesAsString = enumValuesAsStrings.join(', ');
-		assert.assert(
-			doesBelongToStringEnum,
-			`Expected ${variableName} to be one of: ${enumValuesAsString}, encountered: ${value}`,
-		);
-	},
-	hasAtMostOneUniqueValue(value: any[], errMsg: string): void {
-		this.assert(_.uniq(value).length <= 1, errMsg);
-	},
-	isNumber(variableName: string, value: number): void {
-		this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
-	},
-	isBoolean(variableName: string, value: boolean): void {
-		this.assert(_.isBoolean(value), this.typeAssertionMessage(variableName, 'boolean', value));
-	},
-	isWeb3Provider(variableName: string, value: any): void {
-		const isWeb3Provider = _.isFunction(value.send) || _.isFunction(value.sendAsync);
-		this.assert(isWeb3Provider, this.typeAssertionMessage(variableName, 'Web3.Provider', value));
-	},
-	doesConformToSchema(variableName: string, value: any, schema: Schema): void {
-		const schemaValidator = new SchemaValidator();
-		const validationResult = schemaValidator.validate(value, schema);
-		const hasValidationErrors = validationResult.errors.length > 0;
-		const msg = `Expected ${variableName} to conform to schema ${schema.id}
+    isBigNumber(variableName: string, value: BigNumber): void {
+        const isBigNumber = _.isObject(value) && (value as any).isBigNumber;
+        this.assert(isBigNumber, this.typeAssertionMessage(variableName, 'BigNumber', value));
+    },
+    isValidBaseUnitAmount(variableName: string, value: BigNumber) {
+        assert.isBigNumber(variableName, value);
+        const isNegative = value.lessThan(0);
+        this.assert(!isNegative, `${variableName} cannot be a negative number, found value: ${value.toNumber()}`);
+        const hasDecimals = value.decimalPlaces() !== 0;
+        this.assert(
+            !hasDecimals,
+            `${variableName} should be in baseUnits (no decimals), found value: ${value.toNumber()}`,
+        );
+    },
+    isString(variableName: string, value: string): void {
+        this.assert(_.isString(value), this.typeAssertionMessage(variableName, 'string', value));
+    },
+    isFunction(variableName: string, value: any): void {
+        this.assert(_.isFunction(value), this.typeAssertionMessage(variableName, 'function', value));
+    },
+    isHexString(variableName: string, value: string): void {
+        this.assert(
+            _.isString(value) && HEX_REGEX.test(value),
+            this.typeAssertionMessage(variableName, 'HexString', value),
+        );
+    },
+    isETHAddressHex(variableName: string, value: string): void {
+        this.assert(addressUtils.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
+        this.assert(
+            addressUtils.isAddress(value) && value.toLowerCase() === value,
+            `Checksummed addresses are not supported. Convert ${variableName} to lower case before passing`,
+        );
+    },
+    doesBelongToStringEnum(
+        variableName: string,
+        value: string,
+        stringEnum: any /* There is no base type for every string enum */,
+    ): void {
+        const doesBelongToStringEnum = !_.isUndefined(stringEnum[value]);
+        const enumValues = _.keys(stringEnum);
+        const enumValuesAsStrings = _.map(enumValues, enumValue => `'${enumValue}'`);
+        const enumValuesAsString = enumValuesAsStrings.join(', ');
+        assert.assert(
+            doesBelongToStringEnum,
+            `Expected ${variableName} to be one of: ${enumValuesAsString}, encountered: ${value}`,
+        );
+    },
+    hasAtMostOneUniqueValue(value: any[], errMsg: string): void {
+        this.assert(_.uniq(value).length <= 1, errMsg);
+    },
+    isNumber(variableName: string, value: number): void {
+        this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
+    },
+    isBoolean(variableName: string, value: boolean): void {
+        this.assert(_.isBoolean(value), this.typeAssertionMessage(variableName, 'boolean', value));
+    },
+    isWeb3Provider(variableName: string, value: any): void {
+        const isWeb3Provider = _.isFunction(value.send) || _.isFunction(value.sendAsync);
+        this.assert(isWeb3Provider, this.typeAssertionMessage(variableName, 'Web3.Provider', value));
+    },
+    doesConformToSchema(variableName: string, value: any, schema: Schema): void {
+        const schemaValidator = new SchemaValidator();
+        const validationResult = schemaValidator.validate(value, schema);
+        const hasValidationErrors = validationResult.errors.length > 0;
+        const msg = `Expected ${variableName} to conform to schema ${schema.id}
 Encountered: ${JSON.stringify(value, null, '\t')}
 Validation errors: ${validationResult.errors.join(', ')}`;
-		this.assert(!hasValidationErrors, msg);
-	},
-	isHttpUrl(variableName: string, value: any): void {
-		const isValidUrl = !_.isUndefined(validUrl.isWebUri(value));
-		this.assert(isValidUrl, this.typeAssertionMessage(variableName, 'http url', value));
-	},
-	isUri(variableName: string, value: any): void {
-		const isValidUri = !_.isUndefined(validUrl.isUri(value));
-		this.assert(isValidUri, this.typeAssertionMessage(variableName, 'uri', value));
-	},
-	assert(condition: boolean, message: string): void {
-		if (!condition) {
-			throw new Error(message);
-		}
-	},
-	typeAssertionMessage(variableName: string, type: string, value: any): string {
-		return `Expected ${variableName} to be of type ${type}, encountered: ${value}`;
-	},
+        this.assert(!hasValidationErrors, msg);
+    },
+    isHttpUrl(variableName: string, value: any): void {
+        const isValidUrl = !_.isUndefined(validUrl.isWebUri(value));
+        this.assert(isValidUrl, this.typeAssertionMessage(variableName, 'http url', value));
+    },
+    isUri(variableName: string, value: any): void {
+        const isValidUri = !_.isUndefined(validUrl.isUri(value));
+        this.assert(isValidUri, this.typeAssertionMessage(variableName, 'uri', value));
+    },
+    assert(condition: boolean, message: string): void {
+        if (!condition) {
+            throw new Error(message);
+        }
+    },
+    typeAssertionMessage(variableName: string, type: string, value: any): string {
+        return `Expected ${variableName} to be of type ${type}, encountered: ${value}`;
+    },
 };
diff --git a/packages/assert/test/assert_test.ts b/packages/assert/test/assert_test.ts
index 0af493bda..b0fa398d6 100644
--- a/packages/assert/test/assert_test.ts
+++ b/packages/assert/test/assert_test.ts
@@ -11,243 +11,243 @@ chai.use(dirtyChai);
 const expect = chai.expect;
 
 describe('Assertions', () => {
-	const variableName = 'variable';
-	describe('#isBigNumber', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [new BigNumber(23), new BigNumber('45')];
-			validInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = ['test', 42, false, { random: 'test' }, undefined];
-			invalidInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isValidBaseUnitAmount', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [new BigNumber(23), new BigNumber('45000000')];
-			validInputs.forEach(input =>
-				expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).to.not.throw(),
-			);
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [0, undefined, new BigNumber(3.145), 3.145, new BigNumber(-400)];
-			invalidInputs.forEach(input =>
-				expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).to.throw(),
-			);
-		});
-	});
-	describe('#isString', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = ['hello', 'goodbye'];
-			validInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [42, false, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isFunction', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [BigNumber, assert.isString];
-			validInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [42, false, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isHexString', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [
-				'0x61a3ed31B43c8780e905a260a35faefEc527be7516aa11c0256729b5b351bc33',
-				'0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-			];
-			validInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [
-				42,
-				false,
-				{ random: 'test' },
-				undefined,
-				new BigNumber(45),
-				'0x61a3ed31B43c8780e905a260a35faYfEc527be7516aa11c0256729b5b351bc33',
-			];
-			invalidInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isETHAddressHex', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [
-				'0x0000000000000000000000000000000000000000',
-				'0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
-				'0x12459c951127e0c374ff9105dda097662a027093',
-			];
-			validInputs.forEach(input =>
-				expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.not.throw(),
-			);
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [
-				42,
-				false,
-				{ random: 'test' },
-				undefined,
-				new BigNumber(45),
-				'0x6FFFd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
-				'0x6FFFd0ae3f7d88c9b4925323f54c6e4',
-			];
-			invalidInputs.forEach(input => expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#doesBelongToStringEnum', () => {
-		enum TestEnums {
-			Test1 = 'Test1',
-			Test2 = 'Test2',
-		}
-		it('should not throw for valid input', () => {
-			const validInputs = [TestEnums.Test1, TestEnums.Test2];
-			validInputs.forEach(input =>
-				expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.not.throw(),
-			);
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [42, false, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input =>
-				expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.throw(),
-			);
-		});
-	});
-	describe('#hasAtMostOneUniqueValue', () => {
-		const errorMsg = 'more than one unique value';
-		it('should not throw for valid input', () => {
-			const validInputs = [['hello'], ['goodbye', 'goodbye', 'goodbye']];
-			validInputs.forEach(input =>
-				expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.not.throw(),
-			);
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [['hello', 'goodbye'], ['goodbye', 42, false, false]];
-			invalidInputs.forEach(input =>
-				expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.throw(),
-			);
-		});
-	});
-	describe('#isNumber', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [42, 0, 21e42];
-			validInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [false, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isBoolean', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [true, false];
-			validInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [42, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isWeb3Provider', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [{ send: () => 45 }, { sendAsync: () => 45 }];
-			validInputs.forEach(input =>
-				expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.not.throw(),
-			);
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [42, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input => expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#doesConformToSchema', () => {
-		const schema = schemas.addressSchema;
-		it('should not throw for valid input', () => {
-			const validInputs = [
-				'0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
-				'0x12459c951127e0c374ff9105dda097662a027093',
-			];
-			validInputs.forEach(input =>
-				expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.not.throw(),
-			);
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [42, { random: 'test' }, undefined, new BigNumber(45)];
-			invalidInputs.forEach(input =>
-				expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.throw(),
-			);
-		});
-	});
-	describe('#isHttpUrl', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [
-				'http://www.google.com',
-				'https://api.example-relayer.net',
-				'https://api.radarrelay.com/0x/v0/',
-				'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
-			];
-			validInputs.forEach(input => expect(assert.isHttpUrl.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [
-				42,
-				{ random: 'test' },
-				undefined,
-				new BigNumber(45),
-				'ws://www.api.example-relayer.net',
-				'www.google.com',
-				'api.example-relayer.net',
-				'user:password@api.example-relayer.net',
-				'//api.example-relayer.net',
-			];
-			invalidInputs.forEach(input => expect(assert.isHttpUrl.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#isUri', () => {
-		it('should not throw for valid input', () => {
-			const validInputs = [
-				'http://www.google.com',
-				'https://api.example-relayer.net',
-				'https://api.radarrelay.com/0x/v0/',
-				'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
-				'ws://www.api.example-relayer.net',
-				'wss://www.api.example-relayer.net',
-				'user:password@api.example-relayer.net',
-			];
-			validInputs.forEach(input => expect(assert.isUri.bind(assert, variableName, input)).to.not.throw());
-		});
-		it('should throw for invalid input', () => {
-			const invalidInputs = [
-				42,
-				{ random: 'test' },
-				undefined,
-				new BigNumber(45),
-				'www.google.com',
-				'api.example-relayer.net',
-				'//api.example-relayer.net',
-			];
-			invalidInputs.forEach(input => expect(assert.isUri.bind(assert, variableName, input)).to.throw());
-		});
-	});
-	describe('#assert', () => {
-		const assertMessage = 'assert not satisfied';
-		it('should not throw for valid input', () => {
-			expect(assert.assert.bind(assert, true, assertMessage)).to.not.throw();
-		});
-		it('should throw for invalid input', () => {
-			expect(assert.assert.bind(assert, false, assertMessage)).to.throw();
-		});
-	});
-	describe('#typeAssertionMessage', () => {
-		it('should render correct message', () => {
-			expect(assert.typeAssertionMessage('variable', 'string', 'number')).to.equal(
-				`Expected variable to be of type string, encountered: number`,
-			);
-		});
-	});
+    const variableName = 'variable';
+    describe('#isBigNumber', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [new BigNumber(23), new BigNumber('45')];
+            validInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = ['test', 42, false, { random: 'test' }, undefined];
+            invalidInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isValidBaseUnitAmount', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [new BigNumber(23), new BigNumber('45000000')];
+            validInputs.forEach(input =>
+                expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [0, undefined, new BigNumber(3.145), 3.145, new BigNumber(-400)];
+            invalidInputs.forEach(input =>
+                expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#isString', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = ['hello', 'goodbye'];
+            validInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [42, false, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isFunction', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [BigNumber, assert.isString];
+            validInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [42, false, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isHexString', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x61a3ed31B43c8780e905a260a35faefEc527be7516aa11c0256729b5b351bc33',
+                '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
+            ];
+            validInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                '0x61a3ed31B43c8780e905a260a35faYfEc527be7516aa11c0256729b5b351bc33',
+            ];
+            invalidInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isETHAddressHex', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x0000000000000000000000000000000000000000',
+                '0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x12459c951127e0c374ff9105dda097662a027093',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                '0x6FFFd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x6FFFd0ae3f7d88c9b4925323f54c6e4',
+            ];
+            invalidInputs.forEach(input => expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#doesBelongToStringEnum', () => {
+        enum TestEnums {
+            Test1 = 'Test1',
+            Test2 = 'Test2',
+        }
+        it('should not throw for valid input', () => {
+            const validInputs = [TestEnums.Test1, TestEnums.Test2];
+            validInputs.forEach(input =>
+                expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [42, false, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input =>
+                expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.throw(),
+            );
+        });
+    });
+    describe('#hasAtMostOneUniqueValue', () => {
+        const errorMsg = 'more than one unique value';
+        it('should not throw for valid input', () => {
+            const validInputs = [['hello'], ['goodbye', 'goodbye', 'goodbye']];
+            validInputs.forEach(input =>
+                expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [['hello', 'goodbye'], ['goodbye', 42, false, false]];
+            invalidInputs.forEach(input =>
+                expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.throw(),
+            );
+        });
+    });
+    describe('#isNumber', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [42, 0, 21e42];
+            validInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [false, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isBoolean', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [true, false];
+            validInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [42, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isWeb3Provider', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [{ send: () => 45 }, { sendAsync: () => 45 }];
+            validInputs.forEach(input =>
+                expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [42, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input => expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#doesConformToSchema', () => {
+        const schema = schemas.addressSchema;
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x12459c951127e0c374ff9105dda097662a027093',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [42, { random: 'test' }, undefined, new BigNumber(45)];
+            invalidInputs.forEach(input =>
+                expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.throw(),
+            );
+        });
+    });
+    describe('#isHttpUrl', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'http://www.google.com',
+                'https://api.example-relayer.net',
+                'https://api.radarrelay.com/0x/v0/',
+                'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
+            ];
+            validInputs.forEach(input => expect(assert.isHttpUrl.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                'ws://www.api.example-relayer.net',
+                'www.google.com',
+                'api.example-relayer.net',
+                'user:password@api.example-relayer.net',
+                '//api.example-relayer.net',
+            ];
+            invalidInputs.forEach(input => expect(assert.isHttpUrl.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isUri', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'http://www.google.com',
+                'https://api.example-relayer.net',
+                'https://api.radarrelay.com/0x/v0/',
+                'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
+                'ws://www.api.example-relayer.net',
+                'wss://www.api.example-relayer.net',
+                'user:password@api.example-relayer.net',
+            ];
+            validInputs.forEach(input => expect(assert.isUri.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                'www.google.com',
+                'api.example-relayer.net',
+                '//api.example-relayer.net',
+            ];
+            invalidInputs.forEach(input => expect(assert.isUri.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#assert', () => {
+        const assertMessage = 'assert not satisfied';
+        it('should not throw for valid input', () => {
+            expect(assert.assert.bind(assert, true, assertMessage)).to.not.throw();
+        });
+        it('should throw for invalid input', () => {
+            expect(assert.assert.bind(assert, false, assertMessage)).to.throw();
+        });
+    });
+    describe('#typeAssertionMessage', () => {
+        it('should render correct message', () => {
+            expect(assert.typeAssertionMessage('variable', 'string', 'number')).to.equal(
+                `Expected variable to be of type string, encountered: number`,
+            );
+        });
+    });
 });
diff --git a/packages/assert/tsconfig.json b/packages/assert/tsconfig.json
index 8314a9459..88a467ccb 100644
--- a/packages/assert/tsconfig.json
+++ b/packages/assert/tsconfig.json
@@ -1,7 +1,7 @@
 {
-	"extends": "../../tsconfig",
-	"compilerOptions": {
-		"outDir": "lib"
-	},
-	"include": ["./src/**/*", "./test/**/*", "../../node_modules/chai-typescript-typings/index.d.ts"]
+    "extends": "../../tsconfig",
+    "compilerOptions": {
+        "outDir": "lib"
+    },
+    "include": ["./src/**/*", "./test/**/*", "../../node_modules/chai-typescript-typings/index.d.ts"]
 }
diff --git a/packages/assert/tslint.json b/packages/assert/tslint.json
index e63054bfc..ffaefe83a 100644
--- a/packages/assert/tslint.json
+++ b/packages/assert/tslint.json
@@ -1,3 +1,3 @@
 {
-	"extends": ["@0xproject/tslint-config"]
+    "extends": ["@0xproject/tslint-config"]
 }