Fix prettier

9 files changed, 372 insertions, 372 deletions

diff --git a/packages/0x.js/test/utils/chai_setup.ts b/packages/0x.js/test/utils/chai_setup.ts
index 078edd309..e156b5f7c 100644
--- a/packages/0x.js/test/utils/chai_setup.ts
+++ b/packages/0x.js/test/utils/chai_setup.ts
@@ -4,10 +4,10 @@ import ChaiBigNumber = require('chai-bignumber');
 import * as dirtyChai from 'dirty-chai';
 
 export const chaiSetup = {
-    configure() {
-        chai.config.includeStack = true;
-        chai.use(ChaiBigNumber());
-        chai.use(dirtyChai);
-        chai.use(chaiAsPromised);
-    },
+	configure() {
+		chai.config.includeStack = true;
+		chai.use(ChaiBigNumber());
+		chai.use(dirtyChai);
+		chai.use(chaiAsPromised);
+	},
 };
diff --git a/packages/0x.js/test/utils/constants.ts b/packages/0x.js/test/utils/constants.ts
index a9e665c25..b7161e9ab 100644
--- a/packages/0x.js/test/utils/constants.ts
+++ b/packages/0x.js/test/utils/constants.ts
@@ -1,11 +1,11 @@
 export const constants = {
-    NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
-    RPC_URL: 'http://localhost:8545',
-    ROPSTEN_NETWORK_ID: 3,
-    KOVAN_NETWORK_ID: 42,
-    TESTRPC_NETWORK_ID: 50,
-    KOVAN_RPC_URL: 'https://kovan.infura.io/',
-    ROPSTEN_RPC_URL: 'https://ropsten.infura.io/',
-    ZRX_DECIMALS: 18,
-    GAS_ESTIMATE: 500000,
+	NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
+	RPC_URL: 'http://localhost:8545',
+	ROPSTEN_NETWORK_ID: 3,
+	KOVAN_NETWORK_ID: 42,
+	TESTRPC_NETWORK_ID: 50,
+	KOVAN_RPC_URL: 'https://kovan.infura.io/',
+	ROPSTEN_RPC_URL: 'https://ropsten.infura.io/',
+	ZRX_DECIMALS: 18,
+	GAS_ESTIMATE: 500000,
 };
diff --git a/packages/0x.js/test/utils/fill_scenarios.ts b/packages/0x.js/test/utils/fill_scenarios.ts
index 1a61487f4..1d4b8b6f4 100644
--- a/packages/0x.js/test/utils/fill_scenarios.ts
+++ b/packages/0x.js/test/utils/fill_scenarios.ts
@@ -11,192 +11,192 @@ import { constants } from './constants';
 const INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS = new BigNumber(100);
 
 export class FillScenarios {
-    private _zeroEx: ZeroEx;
-    private _userAddresses: string[];
-    private _tokens: Token[];
-    private _coinbase: string;
-    private _zrxTokenAddress: string;
-    private _exchangeContractAddress: string;
-    constructor(
-        zeroEx: ZeroEx,
-        userAddresses: string[],
-        tokens: Token[],
-        zrxTokenAddress: string,
-        exchangeContractAddress: string,
-    ) {
-        this._zeroEx = zeroEx;
-        this._userAddresses = userAddresses;
-        this._tokens = tokens;
-        this._coinbase = userAddresses[0];
-        this._zrxTokenAddress = zrxTokenAddress;
-        this._exchangeContractAddress = exchangeContractAddress;
-    }
-    public async initTokenBalancesAsync() {
-        const web3Wrapper = (this._zeroEx as any)._web3Wrapper as Web3Wrapper;
-        for (const token of this._tokens) {
-            if (token.symbol !== 'ZRX' && token.symbol !== 'WETH') {
-                const contractInstance = web3Wrapper.getContractInstance(
-                    artifacts.DummyTokenArtifact.abi,
-                    token.address,
-                );
-                const defaults = {};
-                const dummyToken = new DummyTokenContract(contractInstance, defaults);
-                const tokenSupply = ZeroEx.toBaseUnitAmount(INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS, token.decimals);
-                const txHash = await dummyToken.setBalance.sendTransactionAsync(this._coinbase, tokenSupply, {
-                    from: this._coinbase,
-                });
-                await this._zeroEx.awaitTransactionMinedAsync(txHash);
-            }
-        }
-    }
-    public async createFillableSignedOrderAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
-        return this.createAsymmetricFillableSignedOrderAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-            expirationUnixTimestampSec,
-        );
-    }
-    public async createFillableSignedOrderWithFeesAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        feeRecepient: string,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
-        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerFee,
-            takerFee,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-            feeRecepient,
-            expirationUnixTimestampSec,
-        );
-    }
-    public async createAsymmetricFillableSignedOrderAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerAddress: string,
-        takerAddress: string,
-        makerFillableAmount: BigNumber,
-        takerFillableAmount: BigNumber,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
-        const makerFee = new BigNumber(0);
-        const takerFee = new BigNumber(0);
-        const feeRecepient = constants.NULL_ADDRESS;
-        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerFee,
-            takerFee,
-            makerAddress,
-            takerAddress,
-            makerFillableAmount,
-            takerFillableAmount,
-            feeRecepient,
-            expirationUnixTimestampSec,
-        );
-    }
-    public async createPartiallyFilledSignedOrderAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        partialFillAmount: BigNumber,
-    ) {
-        const [makerAddress] = this._userAddresses;
-        const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-        );
-        const shouldThrowOnInsufficientBalanceOrAllowance = false;
-        await this._zeroEx.exchange.fillOrderAsync(
-            signedOrder,
-            partialFillAmount,
-            shouldThrowOnInsufficientBalanceOrAllowance,
-            takerAddress,
-        );
-        return signedOrder;
-    }
-    private async _createAsymmetricFillableSignedOrderWithFeesAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerAddress: string,
-        takerAddress: string,
-        makerFillableAmount: BigNumber,
-        takerFillableAmount: BigNumber,
-        feeRecepient: string,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
-        await Promise.all([
-            this._increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
-            this._increaseBalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
-        ]);
-        await Promise.all([
-            this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
-            this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
-        ]);
+	private _zeroEx: ZeroEx;
+	private _userAddresses: string[];
+	private _tokens: Token[];
+	private _coinbase: string;
+	private _zrxTokenAddress: string;
+	private _exchangeContractAddress: string;
+	constructor(
+		zeroEx: ZeroEx,
+		userAddresses: string[],
+		tokens: Token[],
+		zrxTokenAddress: string,
+		exchangeContractAddress: string,
+	) {
+		this._zeroEx = zeroEx;
+		this._userAddresses = userAddresses;
+		this._tokens = tokens;
+		this._coinbase = userAddresses[0];
+		this._zrxTokenAddress = zrxTokenAddress;
+		this._exchangeContractAddress = exchangeContractAddress;
+	}
+	public async initTokenBalancesAsync() {
+		const web3Wrapper = (this._zeroEx as any)._web3Wrapper as Web3Wrapper;
+		for (const token of this._tokens) {
+			if (token.symbol !== 'ZRX' && token.symbol !== 'WETH') {
+				const contractInstance = web3Wrapper.getContractInstance(
+					artifacts.DummyTokenArtifact.abi,
+					token.address,
+				);
+				const defaults = {};
+				const dummyToken = new DummyTokenContract(contractInstance, defaults);
+				const tokenSupply = ZeroEx.toBaseUnitAmount(INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS, token.decimals);
+				const txHash = await dummyToken.setBalance.sendTransactionAsync(this._coinbase, tokenSupply, {
+					from: this._coinbase,
+				});
+				await this._zeroEx.awaitTransactionMinedAsync(txHash);
+			}
+		}
+	}
+	public async createFillableSignedOrderAsync(
+		makerTokenAddress: string,
+		takerTokenAddress: string,
+		makerAddress: string,
+		takerAddress: string,
+		fillableAmount: BigNumber,
+		expirationUnixTimestampSec?: BigNumber,
+	): Promise<SignedOrder> {
+		return this.createAsymmetricFillableSignedOrderAsync(
+			makerTokenAddress,
+			takerTokenAddress,
+			makerAddress,
+			takerAddress,
+			fillableAmount,
+			fillableAmount,
+			expirationUnixTimestampSec,
+		);
+	}
+	public async createFillableSignedOrderWithFeesAsync(
+		makerTokenAddress: string,
+		takerTokenAddress: string,
+		makerFee: BigNumber,
+		takerFee: BigNumber,
+		makerAddress: string,
+		takerAddress: string,
+		fillableAmount: BigNumber,
+		feeRecepient: string,
+		expirationUnixTimestampSec?: BigNumber,
+	): Promise<SignedOrder> {
+		return this._createAsymmetricFillableSignedOrderWithFeesAsync(
+			makerTokenAddress,
+			takerTokenAddress,
+			makerFee,
+			takerFee,
+			makerAddress,
+			takerAddress,
+			fillableAmount,
+			fillableAmount,
+			feeRecepient,
+			expirationUnixTimestampSec,
+		);
+	}
+	public async createAsymmetricFillableSignedOrderAsync(
+		makerTokenAddress: string,
+		takerTokenAddress: string,
+		makerAddress: string,
+		takerAddress: string,
+		makerFillableAmount: BigNumber,
+		takerFillableAmount: BigNumber,
+		expirationUnixTimestampSec?: BigNumber,
+	): Promise<SignedOrder> {
+		const makerFee = new BigNumber(0);
+		const takerFee = new BigNumber(0);
+		const feeRecepient = constants.NULL_ADDRESS;
+		return this._createAsymmetricFillableSignedOrderWithFeesAsync(
+			makerTokenAddress,
+			takerTokenAddress,
+			makerFee,
+			takerFee,
+			makerAddress,
+			takerAddress,
+			makerFillableAmount,
+			takerFillableAmount,
+			feeRecepient,
+			expirationUnixTimestampSec,
+		);
+	}
+	public async createPartiallyFilledSignedOrderAsync(
+		makerTokenAddress: string,
+		takerTokenAddress: string,
+		takerAddress: string,
+		fillableAmount: BigNumber,
+		partialFillAmount: BigNumber,
+	) {
+		const [makerAddress] = this._userAddresses;
+		const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
+			makerTokenAddress,
+			takerTokenAddress,
+			makerAddress,
+			takerAddress,
+			fillableAmount,
+			fillableAmount,
+		);
+		const shouldThrowOnInsufficientBalanceOrAllowance = false;
+		await this._zeroEx.exchange.fillOrderAsync(
+			signedOrder,
+			partialFillAmount,
+			shouldThrowOnInsufficientBalanceOrAllowance,
+			takerAddress,
+		);
+		return signedOrder;
+	}
+	private async _createAsymmetricFillableSignedOrderWithFeesAsync(
+		makerTokenAddress: string,
+		takerTokenAddress: string,
+		makerFee: BigNumber,
+		takerFee: BigNumber,
+		makerAddress: string,
+		takerAddress: string,
+		makerFillableAmount: BigNumber,
+		takerFillableAmount: BigNumber,
+		feeRecepient: string,
+		expirationUnixTimestampSec?: BigNumber,
+	): Promise<SignedOrder> {
+		await Promise.all([
+			this._increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
+			this._increaseBalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
+		]);
+		await Promise.all([
+			this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
+			this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
+		]);
 
-        const signedOrder = await orderFactory.createSignedOrderAsync(
-            this._zeroEx,
-            makerAddress,
-            takerAddress,
-            makerFee,
-            takerFee,
-            makerFillableAmount,
-            makerTokenAddress,
-            takerFillableAmount,
-            takerTokenAddress,
-            this._exchangeContractAddress,
-            feeRecepient,
-            expirationUnixTimestampSec,
-        );
-        return signedOrder;
-    }
-    private async _increaseBalanceAndAllowanceAsync(
-        tokenAddress: string,
-        address: string,
-        amount: BigNumber,
-    ): Promise<void> {
-        if (amount.isZero() || address === ZeroEx.NULL_ADDRESS) {
-            return; // noop
-        }
-        await Promise.all([
-            this._increaseBalanceAsync(tokenAddress, address, amount),
-            this._increaseAllowanceAsync(tokenAddress, address, amount),
-        ]);
-    }
-    private async _increaseBalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-        await this._zeroEx.token.transferAsync(tokenAddress, this._coinbase, address, amount);
-    }
-    private async _increaseAllowanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-        const oldMakerAllowance = await this._zeroEx.token.getProxyAllowanceAsync(tokenAddress, address);
-        const newMakerAllowance = oldMakerAllowance.plus(amount);
-        await this._zeroEx.token.setProxyAllowanceAsync(tokenAddress, address, newMakerAllowance);
-    }
+		const signedOrder = await orderFactory.createSignedOrderAsync(
+			this._zeroEx,
+			makerAddress,
+			takerAddress,
+			makerFee,
+			takerFee,
+			makerFillableAmount,
+			makerTokenAddress,
+			takerFillableAmount,
+			takerTokenAddress,
+			this._exchangeContractAddress,
+			feeRecepient,
+			expirationUnixTimestampSec,
+		);
+		return signedOrder;
+	}
+	private async _increaseBalanceAndAllowanceAsync(
+		tokenAddress: string,
+		address: string,
+		amount: BigNumber,
+	): Promise<void> {
+		if (amount.isZero() || address === ZeroEx.NULL_ADDRESS) {
+			return; // noop
+		}
+		await Promise.all([
+			this._increaseBalanceAsync(tokenAddress, address, amount),
+			this._increaseAllowanceAsync(tokenAddress, address, amount),
+		]);
+	}
+	private async _increaseBalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+		await this._zeroEx.token.transferAsync(tokenAddress, this._coinbase, address, amount);
+	}
+	private async _increaseAllowanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+		const oldMakerAllowance = await this._zeroEx.token.getProxyAllowanceAsync(tokenAddress, address);
+		const newMakerAllowance = oldMakerAllowance.plus(amount);
+		await this._zeroEx.token.setProxyAllowanceAsync(tokenAddress, address, newMakerAllowance);
+	}
 }
diff --git a/packages/0x.js/test/utils/order_factory.ts b/packages/0x.js/test/utils/order_factory.ts
index 08f2081a4..b65920e64 100644
--- a/packages/0x.js/test/utils/order_factory.ts
+++ b/packages/0x.js/test/utils/order_factory.ts
@@ -6,41 +6,41 @@ import { SignedOrder, ZeroEx } from '../../src';
 const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
 
 export const orderFactory = {
-    async createSignedOrderAsync(
-        zeroEx: ZeroEx,
-        maker: string,
-        taker: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerTokenAmount: BigNumber,
-        makerTokenAddress: string,
-        takerTokenAmount: BigNumber,
-        takerTokenAddress: string,
-        exchangeContractAddress: string,
-        feeRecipient: string,
-        expirationUnixTimestampSecIfExists?: BigNumber,
-    ): Promise<SignedOrder> {
-        const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
-        const expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSecIfExists)
-            ? defaultExpirationUnixTimestampSec
-            : expirationUnixTimestampSecIfExists;
-        const order = {
-            maker,
-            taker,
-            makerFee,
-            takerFee,
-            makerTokenAmount,
-            takerTokenAmount,
-            makerTokenAddress,
-            takerTokenAddress,
-            salt: ZeroEx.generatePseudoRandomSalt(),
-            exchangeContractAddress,
-            feeRecipient,
-            expirationUnixTimestampSec,
-        };
-        const orderHash = ZeroEx.getOrderHashHex(order);
-        const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker, SHOULD_ADD_PERSONAL_MESSAGE_PREFIX);
-        const signedOrder: SignedOrder = _.assign(order, { ecSignature });
-        return signedOrder;
-    },
+	async createSignedOrderAsync(
+		zeroEx: ZeroEx,
+		maker: string,
+		taker: string,
+		makerFee: BigNumber,
+		takerFee: BigNumber,
+		makerTokenAmount: BigNumber,
+		makerTokenAddress: string,
+		takerTokenAmount: BigNumber,
+		takerTokenAddress: string,
+		exchangeContractAddress: string,
+		feeRecipient: string,
+		expirationUnixTimestampSecIfExists?: BigNumber,
+	): Promise<SignedOrder> {
+		const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
+		const expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSecIfExists)
+			? defaultExpirationUnixTimestampSec
+			: expirationUnixTimestampSecIfExists;
+		const order = {
+			maker,
+			taker,
+			makerFee,
+			takerFee,
+			makerTokenAmount,
+			takerTokenAmount,
+			makerTokenAddress,
+			takerTokenAddress,
+			salt: ZeroEx.generatePseudoRandomSalt(),
+			exchangeContractAddress,
+			feeRecipient,
+			expirationUnixTimestampSec,
+		};
+		const orderHash = ZeroEx.getOrderHashHex(order);
+		const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker, SHOULD_ADD_PERSONAL_MESSAGE_PREFIX);
+		const signedOrder: SignedOrder = _.assign(order, { ecSignature });
+		return signedOrder;
+	},
 };
diff --git a/packages/0x.js/test/utils/report_callback_errors.ts b/packages/0x.js/test/utils/report_callback_errors.ts
index 27c9745c9..0b619f73e 100644
--- a/packages/0x.js/test/utils/report_callback_errors.ts
+++ b/packages/0x.js/test/utils/report_callback_errors.ts
@@ -6,61 +6,61 @@ import { DoneCallback } from '../../src/types';
 const expect = chai.expect;
 
 export const reportNoErrorCallbackErrors = (done: DoneCallback, expectToBeCalledOnce = true) => {
-    return <T>(f?: (value: T) => void) => {
-        const wrapped = (value: T) => {
-            if (_.isUndefined(f)) {
-                done();
-                return;
-            }
-            try {
-                f(value);
-                if (expectToBeCalledOnce) {
-                    done();
-                }
-            } catch (err) {
-                done(err);
-            }
-        };
-        return wrapped;
-    };
+	return <T>(f?: (value: T) => void) => {
+		const wrapped = (value: T) => {
+			if (_.isUndefined(f)) {
+				done();
+				return;
+			}
+			try {
+				f(value);
+				if (expectToBeCalledOnce) {
+					done();
+				}
+			} catch (err) {
+				done(err);
+			}
+		};
+		return wrapped;
+	};
 };
 
 export const reportNodeCallbackErrors = (done: DoneCallback, expectToBeCalledOnce = true) => {
-    return <T>(f?: (value: T) => void) => {
-        const wrapped = (error: Error | null, value: T | undefined) => {
-            if (!_.isNull(error)) {
-                done(error);
-            } else {
-                if (_.isUndefined(f)) {
-                    done();
-                    return;
-                }
-                try {
-                    f(value as T);
-                    if (expectToBeCalledOnce) {
-                        done();
-                    }
-                } catch (err) {
-                    done(err);
-                }
-            }
-        };
-        return wrapped;
-    };
+	return <T>(f?: (value: T) => void) => {
+		const wrapped = (error: Error | null, value: T | undefined) => {
+			if (!_.isNull(error)) {
+				done(error);
+			} else {
+				if (_.isUndefined(f)) {
+					done();
+					return;
+				}
+				try {
+					f(value as T);
+					if (expectToBeCalledOnce) {
+						done();
+					}
+				} catch (err) {
+					done(err);
+				}
+			}
+		};
+		return wrapped;
+	};
 };
 
 export const assertNodeCallbackError = (done: DoneCallback, errMsg: string) => {
-    const wrapped = <T>(error: Error | null, value: T | undefined) => {
-        if (_.isNull(error)) {
-            done(new Error('Expected callback to receive an error'));
-        } else {
-            try {
-                expect(error.message).to.be.equal(errMsg);
-                done();
-            } catch (err) {
-                done(err);
-            }
-        }
-    };
-    return wrapped;
+	const wrapped = <T>(error: Error | null, value: T | undefined) => {
+		if (_.isNull(error)) {
+			done(new Error('Expected callback to receive an error'));
+		} else {
+			try {
+				expect(error.message).to.be.equal(errMsg);
+				done();
+			} catch (err) {
+				done(err);
+			}
+		}
+	};
+	return wrapped;
 };
diff --git a/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts b/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts
index 53f2be83d..466b0f350 100644
--- a/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts
+++ b/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts
@@ -6,22 +6,22 @@ import { JSONRPCPayload } from '../../../src/types';
  * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
  */
 export class EmptyWalletSubprovider {
-    // This method needs to be here to satisfy the interface but linter wants it to be static.
-    // tslint:disable-next-line:prefer-function-over-method
-    public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
-        switch (payload.method) {
-            case 'eth_accounts':
-                end(null, []);
-                return;
+	// This method needs to be here to satisfy the interface but linter wants it to be static.
+	// tslint:disable-next-line:prefer-function-over-method
+	public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
+		switch (payload.method) {
+			case 'eth_accounts':
+				end(null, []);
+				return;
 
-            default:
-                next();
-                return;
-        }
-    }
-    // Required to implement this method despite not needing it for this subprovider
-    // tslint:disable-next-line:prefer-function-over-method
-    public setEngine(engine: any) {
-        // noop
-    }
+			default:
+				next();
+				return;
+		}
+	}
+	// Required to implement this method despite not needing it for this subprovider
+	// tslint:disable-next-line:prefer-function-over-method
+	public setEngine(engine: any) {
+		// noop
+	}
 }
diff --git a/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts b/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts
index e1113a851..307bfb188 100644
--- a/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts
+++ b/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts
@@ -9,26 +9,26 @@ import { JSONRPCPayload } from '../../../src/types';
  * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
  */
 export class FakeGasEstimateSubprovider {
-    private _constantGasAmount: number;
-    constructor(constantGasAmount: number) {
-        this._constantGasAmount = constantGasAmount;
-    }
-    // This method needs to be here to satisfy the interface but linter wants it to be static.
-    // tslint:disable-next-line:prefer-function-over-method
-    public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
-        switch (payload.method) {
-            case 'eth_estimateGas':
-                end(null, this._constantGasAmount);
-                return;
+	private _constantGasAmount: number;
+	constructor(constantGasAmount: number) {
+		this._constantGasAmount = constantGasAmount;
+	}
+	// This method needs to be here to satisfy the interface but linter wants it to be static.
+	// tslint:disable-next-line:prefer-function-over-method
+	public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
+		switch (payload.method) {
+			case 'eth_estimateGas':
+				end(null, this._constantGasAmount);
+				return;
 
-            default:
-                next();
-                return;
-        }
-    }
-    // Required to implement this method despite not needing it for this subprovider
-    // tslint:disable-next-line:prefer-function-over-method
-    public setEngine(engine: any) {
-        // noop
-    }
+			default:
+				next();
+				return;
+		}
+	}
+	// Required to implement this method despite not needing it for this subprovider
+	// tslint:disable-next-line:prefer-function-over-method
+	public setEngine(engine: any) {
+		// noop
+	}
 }
diff --git a/packages/0x.js/test/utils/token_utils.ts b/packages/0x.js/test/utils/token_utils.ts
index d3fc22ff4..9cbefcf8e 100644
--- a/packages/0x.js/test/utils/token_utils.ts
+++ b/packages/0x.js/test/utils/token_utils.ts
@@ -6,28 +6,28 @@ const PROTOCOL_TOKEN_SYMBOL = 'ZRX';
 const WETH_TOKEN_SYMBOL = 'WETH';
 
 export class TokenUtils {
-    private _tokens: Token[];
-    constructor(tokens: Token[]) {
-        this._tokens = tokens;
-    }
-    public getProtocolTokenOrThrow(): Token {
-        const zrxToken = _.find(this._tokens, { symbol: PROTOCOL_TOKEN_SYMBOL });
-        if (_.isUndefined(zrxToken)) {
-            throw new Error(InternalZeroExError.ZrxNotInTokenRegistry);
-        }
-        return zrxToken;
-    }
-    public getWethTokenOrThrow(): Token {
-        const wethToken = _.find(this._tokens, { symbol: WETH_TOKEN_SYMBOL });
-        if (_.isUndefined(wethToken)) {
-            throw new Error(InternalZeroExError.WethNotInTokenRegistry);
-        }
-        return wethToken;
-    }
-    public getDummyTokens(): Token[] {
-        const dummyTokens = _.filter(this._tokens, token => {
-            return !_.includes([PROTOCOL_TOKEN_SYMBOL, WETH_TOKEN_SYMBOL], token.symbol);
-        });
-        return dummyTokens;
-    }
+	private _tokens: Token[];
+	constructor(tokens: Token[]) {
+		this._tokens = tokens;
+	}
+	public getProtocolTokenOrThrow(): Token {
+		const zrxToken = _.find(this._tokens, { symbol: PROTOCOL_TOKEN_SYMBOL });
+		if (_.isUndefined(zrxToken)) {
+			throw new Error(InternalZeroExError.ZrxNotInTokenRegistry);
+		}
+		return zrxToken;
+	}
+	public getWethTokenOrThrow(): Token {
+		const wethToken = _.find(this._tokens, { symbol: WETH_TOKEN_SYMBOL });
+		if (_.isUndefined(wethToken)) {
+			throw new Error(InternalZeroExError.WethNotInTokenRegistry);
+		}
+		return wethToken;
+	}
+	public getDummyTokens(): Token[] {
+		const dummyTokens = _.filter(this._tokens, token => {
+			return !_.includes([PROTOCOL_TOKEN_SYMBOL, WETH_TOKEN_SYMBOL], token.symbol);
+		});
+		return dummyTokens;
+	}
 }
diff --git a/packages/0x.js/test/utils/web3_factory.ts b/packages/0x.js/test/utils/web3_factory.ts
index 26c26e03d..640b96256 100644
--- a/packages/0x.js/test/utils/web3_factory.ts
+++ b/packages/0x.js/test/utils/web3_factory.ts
@@ -19,24 +19,24 @@ import { constants } from './constants';
 import * as Web3 from 'web3';
 
 export const web3Factory = {
-    create(hasAddresses: boolean = true): Web3 {
-        const provider = this.getRpcProvider(hasAddresses);
-        const web3 = new Web3();
-        web3.setProvider(provider);
-        return web3;
-    },
-    getRpcProvider(hasAddresses: boolean = true): Web3.Provider {
-        const provider = new ProviderEngine();
-        if (!hasAddresses) {
-            provider.addProvider(new EmptyWalletSubprovider());
-        }
-        provider.addProvider(new FakeGasEstimateSubprovider(constants.GAS_ESTIMATE));
-        provider.addProvider(
-            new RpcSubprovider({
-                rpcUrl: constants.RPC_URL,
-            }),
-        );
-        provider.start();
-        return provider;
-    },
+	create(hasAddresses: boolean = true): Web3 {
+		const provider = this.getRpcProvider(hasAddresses);
+		const web3 = new Web3();
+		web3.setProvider(provider);
+		return web3;
+	},
+	getRpcProvider(hasAddresses: boolean = true): Web3.Provider {
+		const provider = new ProviderEngine();
+		if (!hasAddresses) {
+			provider.addProvider(new EmptyWalletSubprovider());
+		}
+		provider.addProvider(new FakeGasEstimateSubprovider(constants.GAS_ESTIMATE));
+		provider.addProvider(
+			new RpcSubprovider({
+				rpcUrl: constants.RPC_URL,
+			}),
+		);
+		provider.start();
+		return provider;
+	},
 };