Add config file specifically in prettier command and fix files

5 files changed, 441 insertions, 441 deletions

diff --git a/packages/subproviders/test/chai_setup.ts b/packages/subproviders/test/chai_setup.ts
index 941a141d5..a281bab6c 100644
--- a/packages/subproviders/test/chai_setup.ts
+++ b/packages/subproviders/test/chai_setup.ts
@@ -3,9 +3,9 @@ import chaiAsPromised = require('chai-as-promised');
 import * as dirtyChai from 'dirty-chai';
 
 export const chaiSetup = {
-	configure() {
-		chai.config.includeStack = true;
-		chai.use(dirtyChai);
-		chai.use(chaiAsPromised);
-	},
+    configure() {
+        chai.config.includeStack = true;
+        chai.use(dirtyChai);
+        chai.use(chaiAsPromised);
+    },
 };
diff --git a/packages/subproviders/test/integration/ledger_subprovider_test.ts b/packages/subproviders/test/integration/ledger_subprovider_test.ts
index 6c1de46aa..628b532d7 100644
--- a/packages/subproviders/test/integration/ledger_subprovider_test.ts
+++ b/packages/subproviders/test/integration/ledger_subprovider_test.ts
@@ -17,168 +17,168 @@ const expect = chai.expect;
 const TEST_RPC_ACCOUNT_0 = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
 
 describe('LedgerSubprovider', () => {
-	let ledgerSubprovider: LedgerSubprovider;
-	const networkId: number = 42;
-	before(async () => {
-		ledgerSubprovider = new LedgerSubprovider({
-			networkId,
-			ledgerEthereumClientFactoryAsync: ledgerEthereumNodeJsClientFactoryAsync,
-		});
-	});
-	describe('direct method calls', () => {
-		it('returns a list of accounts', async () => {
-			const accounts = await ledgerSubprovider.getAccountsAsync();
-			expect(accounts[0]).to.not.be.an('undefined');
-			expect(accounts.length).to.be.equal(10);
-		});
-		it('signs a personal message', async () => {
-			const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-			const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data);
-			expect(ecSignatureHex.length).to.be.equal(132);
-			expect(ecSignatureHex.substr(0, 2)).to.be.equal('0x');
-		});
-		it('signs a transaction', async () => {
-			const tx = {
-				nonce: '0x00',
-				gas: '0x2710',
-				to: '0x0000000000000000000000000000000000000000',
-				value: '0x00',
-				chainId: 3,
-			};
-			const txHex = await ledgerSubprovider.signTransactionAsync(tx);
-			expect(txHex).to.be.equal(
-				'0xf85f8080822710940000000000000000000000000000000000000000808077a088a95ef1378487bc82be558e82c8478baf840c545d5b887536bb1da63673a98ba0019f4a4b9a107d1e6752bf7f701e275f28c13791d6e76af895b07373462cefaa',
-			);
-		});
-	});
-	describe('calls through a provider', () => {
-		let defaultProvider: Web3ProviderEngine;
-		let ledgerProvider: Web3ProviderEngine;
-		before(() => {
-			ledgerProvider = new Web3ProviderEngine();
-			ledgerProvider.addProvider(ledgerSubprovider);
-			const httpProvider = new RpcSubprovider({
-				rpcUrl: 'http://localhost:8545',
-			});
-			ledgerProvider.addProvider(httpProvider);
-			ledgerProvider.start();
+    let ledgerSubprovider: LedgerSubprovider;
+    const networkId: number = 42;
+    before(async () => {
+        ledgerSubprovider = new LedgerSubprovider({
+            networkId,
+            ledgerEthereumClientFactoryAsync: ledgerEthereumNodeJsClientFactoryAsync,
+        });
+    });
+    describe('direct method calls', () => {
+        it('returns a list of accounts', async () => {
+            const accounts = await ledgerSubprovider.getAccountsAsync();
+            expect(accounts[0]).to.not.be.an('undefined');
+            expect(accounts.length).to.be.equal(10);
+        });
+        it('signs a personal message', async () => {
+            const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+            const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data);
+            expect(ecSignatureHex.length).to.be.equal(132);
+            expect(ecSignatureHex.substr(0, 2)).to.be.equal('0x');
+        });
+        it('signs a transaction', async () => {
+            const tx = {
+                nonce: '0x00',
+                gas: '0x2710',
+                to: '0x0000000000000000000000000000000000000000',
+                value: '0x00',
+                chainId: 3,
+            };
+            const txHex = await ledgerSubprovider.signTransactionAsync(tx);
+            expect(txHex).to.be.equal(
+                '0xf85f8080822710940000000000000000000000000000000000000000808077a088a95ef1378487bc82be558e82c8478baf840c545d5b887536bb1da63673a98ba0019f4a4b9a107d1e6752bf7f701e275f28c13791d6e76af895b07373462cefaa',
+            );
+        });
+    });
+    describe('calls through a provider', () => {
+        let defaultProvider: Web3ProviderEngine;
+        let ledgerProvider: Web3ProviderEngine;
+        before(() => {
+            ledgerProvider = new Web3ProviderEngine();
+            ledgerProvider.addProvider(ledgerSubprovider);
+            const httpProvider = new RpcSubprovider({
+                rpcUrl: 'http://localhost:8545',
+            });
+            ledgerProvider.addProvider(httpProvider);
+            ledgerProvider.start();
 
-			defaultProvider = new Web3ProviderEngine();
-			defaultProvider.addProvider(httpProvider);
-			defaultProvider.start();
-		});
-		it('returns a list of accounts', (done: DoneCallback) => {
-			const payload = {
-				jsonrpc: '2.0',
-				method: 'eth_accounts',
-				params: [],
-				id: 1,
-			};
-			const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-				expect(err).to.be.a('null');
-				expect(response.result.length).to.be.equal(10);
-				done();
-			});
-			ledgerProvider.sendAsync(payload, callback);
-		});
-		it('signs a personal message with eth_sign', (done: DoneCallback) => {
-			(async () => {
-				const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-				const accounts = await ledgerSubprovider.getAccountsAsync();
-				const signer = accounts[0];
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sign',
-					params: [signer, messageHex],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					expect(response.result.length).to.be.equal(132);
-					expect(response.result.substr(0, 2)).to.be.equal('0x');
-					done();
-				});
-				ledgerProvider.sendAsync(payload, callback);
-			})().catch(done);
-		});
-		it('signs a personal message with personal_sign', (done: DoneCallback) => {
-			(async () => {
-				const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-				const accounts = await ledgerSubprovider.getAccountsAsync();
-				const signer = accounts[0];
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'personal_sign',
-					params: [messageHex, signer],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					expect(response.result.length).to.be.equal(132);
-					expect(response.result.substr(0, 2)).to.be.equal('0x');
-					done();
-				});
-				ledgerProvider.sendAsync(payload, callback);
-			})().catch(done);
-		});
-		it('signs a transaction', (done: DoneCallback) => {
-			const tx = {
-				to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
-				value: '0x00',
-			};
-			const payload = {
-				jsonrpc: '2.0',
-				method: 'eth_signTransaction',
-				params: [tx],
-				id: 1,
-			};
-			const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-				expect(err).to.be.a('null');
-				expect(response.result.raw.length).to.be.equal(206);
-				expect(response.result.raw.substr(0, 2)).to.be.equal('0x');
-				done();
-			});
-			ledgerProvider.sendAsync(payload, callback);
-		});
-		it('signs and sends a transaction', (done: DoneCallback) => {
-			(async () => {
-				const accounts = await ledgerSubprovider.getAccountsAsync();
+            defaultProvider = new Web3ProviderEngine();
+            defaultProvider.addProvider(httpProvider);
+            defaultProvider.start();
+        });
+        it('returns a list of accounts', (done: DoneCallback) => {
+            const payload = {
+                jsonrpc: '2.0',
+                method: 'eth_accounts',
+                params: [],
+                id: 1,
+            };
+            const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                expect(err).to.be.a('null');
+                expect(response.result.length).to.be.equal(10);
+                done();
+            });
+            ledgerProvider.sendAsync(payload, callback);
+        });
+        it('signs a personal message with eth_sign', (done: DoneCallback) => {
+            (async () => {
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const accounts = await ledgerSubprovider.getAccountsAsync();
+                const signer = accounts[0];
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sign',
+                    params: [signer, messageHex],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result.length).to.be.equal(132);
+                    expect(response.result.substr(0, 2)).to.be.equal('0x');
+                    done();
+                });
+                ledgerProvider.sendAsync(payload, callback);
+            })().catch(done);
+        });
+        it('signs a personal message with personal_sign', (done: DoneCallback) => {
+            (async () => {
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const accounts = await ledgerSubprovider.getAccountsAsync();
+                const signer = accounts[0];
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'personal_sign',
+                    params: [messageHex, signer],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result.length).to.be.equal(132);
+                    expect(response.result.substr(0, 2)).to.be.equal('0x');
+                    done();
+                });
+                ledgerProvider.sendAsync(payload, callback);
+            })().catch(done);
+        });
+        it('signs a transaction', (done: DoneCallback) => {
+            const tx = {
+                to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
+                value: '0x00',
+            };
+            const payload = {
+                jsonrpc: '2.0',
+                method: 'eth_signTransaction',
+                params: [tx],
+                id: 1,
+            };
+            const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                expect(err).to.be.a('null');
+                expect(response.result.raw.length).to.be.equal(206);
+                expect(response.result.raw.substr(0, 2)).to.be.equal('0x');
+                done();
+            });
+            ledgerProvider.sendAsync(payload, callback);
+        });
+        it('signs and sends a transaction', (done: DoneCallback) => {
+            (async () => {
+                const accounts = await ledgerSubprovider.getAccountsAsync();
 
-				// Give first account on Ledger sufficient ETH to complete tx send
-				let tx = {
-					to: accounts[0],
-					from: TEST_RPC_ACCOUNT_0,
-					value: '0x8ac7230489e80000', // 10 ETH
-				};
-				let payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sendTransaction',
-					params: [tx],
-					id: 1,
-				};
-				await promisify(defaultProvider.sendAsync, defaultProvider)(payload);
+                // Give first account on Ledger sufficient ETH to complete tx send
+                let tx = {
+                    to: accounts[0],
+                    from: TEST_RPC_ACCOUNT_0,
+                    value: '0x8ac7230489e80000', // 10 ETH
+                };
+                let payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendTransaction',
+                    params: [tx],
+                    id: 1,
+                };
+                await promisify(defaultProvider.sendAsync, defaultProvider)(payload);
 
-				// Send transaction from Ledger
-				tx = {
-					to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
-					from: accounts[0],
-					value: '0xde0b6b3a7640000',
-				};
-				payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sendTransaction',
-					params: [tx],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					const result = response.result.result;
-					expect(result.length).to.be.equal(66);
-					expect(result.substr(0, 2)).to.be.equal('0x');
-					done();
-				});
-				ledgerProvider.sendAsync(payload, callback);
-			})().catch(done);
-		});
-	});
+                // Send transaction from Ledger
+                tx = {
+                    to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
+                    from: accounts[0],
+                    value: '0xde0b6b3a7640000',
+                };
+                payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendTransaction',
+                    params: [tx],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    const result = response.result.result;
+                    expect(result.length).to.be.equal(66);
+                    expect(result.substr(0, 2)).to.be.equal('0x');
+                    done();
+                });
+                ledgerProvider.sendAsync(payload, callback);
+            })().catch(done);
+        });
+    });
 });
diff --git a/packages/subproviders/test/unit/ledger_subprovider_test.ts b/packages/subproviders/test/unit/ledger_subprovider_test.ts
index 101b6b906..1c70dd3a6 100644
--- a/packages/subproviders/test/unit/ledger_subprovider_test.ts
+++ b/packages/subproviders/test/unit/ledger_subprovider_test.ts
@@ -15,230 +15,230 @@ const expect = chai.expect;
 const FAKE_ADDRESS = '0xb088a3bc93f71b4de97b9de773e9647645983688';
 
 describe('LedgerSubprovider', () => {
-	const networkId: number = 42;
-	let ledgerSubprovider: LedgerSubprovider;
-	before(async () => {
-		const ledgerEthereumClientFactoryAsync = async () => {
-			// tslint:disable:no-object-literal-type-assertion
-			const ledgerEthClient = {
-				getAddress_async: async () => {
-					const publicKey =
-						'04f428290f4c5ed6a198f71b8205f488141dbb3f0840c923bbfa798ecbee6370986c03b5575d94d506772fb48a6a44e345e4ebd4f028a6f609c44b655d6d3e71a1';
-					const chainCode = 'ac055a5537c0c7e9e02d14a197cad6b857836da2a12043b46912a37d959b5ae8';
-					const address = '0xBa388BA5e5EEF2c6cE42d831c2B3A28D3c99bdB1';
-					return {
-						publicKey,
-						address,
-						chainCode,
-					};
-				},
-				signPersonalMessage_async: async () => {
-					const ecSignature = {
-						v: 28,
-						r: 'a6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae49148',
-						s: '0652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d0',
-					};
-					return ecSignature;
-				},
-				signTransaction_async: async (derivationPath: string, txHex: string) => {
-					const ecSignature = {
-						v: '77',
-						r: '88a95ef1378487bc82be558e82c8478baf840c545d5b887536bb1da63673a98b',
-						s: '019f4a4b9a107d1e6752bf7f701e275f28c13791d6e76af895b07373462cefaa',
-					};
-					return ecSignature;
-				},
-				comm: {
-					close_async: _.noop,
-				} as LedgerCommunicationClient,
-			};
-			// tslint:enable:no-object-literal-type-assertion
-			return ledgerEthClient;
-		};
-		ledgerSubprovider = new LedgerSubprovider({
-			networkId,
-			ledgerEthereumClientFactoryAsync,
-		});
-	});
-	describe('direct method calls', () => {
-		describe('success cases', () => {
-			it('returns a list of accounts', async () => {
-				const accounts = await ledgerSubprovider.getAccountsAsync();
-				expect(accounts[0]).to.be.equal(FAKE_ADDRESS);
-				expect(accounts.length).to.be.equal(10);
-			});
-			it('signs a personal message', async () => {
-				const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-				const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data);
-				expect(ecSignatureHex).to.be.equal(
-					'0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
-				);
-			});
-		});
-		describe('failure cases', () => {
-			it('cannot open multiple simultaneous connections to the Ledger device', async () => {
-				const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-				return expect(
-					Promise.all([
-						ledgerSubprovider.getAccountsAsync(),
-						ledgerSubprovider.signPersonalMessageAsync(data),
-					]),
-				).to.be.rejectedWith(LedgerSubproviderErrors.MultipleOpenConnectionsDisallowed);
-			});
-		});
-	});
-	describe('calls through a provider', () => {
-		let provider: Web3ProviderEngine;
-		before(() => {
-			provider = new Web3ProviderEngine();
-			provider.addProvider(ledgerSubprovider);
-			const httpProvider = new RpcSubprovider({
-				rpcUrl: 'http://localhost:8545',
-			});
-			provider.addProvider(httpProvider);
-			provider.start();
-		});
-		describe('success cases', () => {
-			it('returns a list of accounts', (done: DoneCallback) => {
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_accounts',
-					params: [],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					expect(response.result.length).to.be.equal(10);
-					expect(response.result[0]).to.be.equal(FAKE_ADDRESS);
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-			it('signs a personal message with eth_sign', (done: DoneCallback) => {
-				const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sign',
-					params: ['0x0000000000000000000000000000000000000000', messageHex],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					expect(response.result).to.be.equal(
-						'0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
-					);
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-			it('signs a personal message with personal_sign', (done: DoneCallback) => {
-				const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'personal_sign',
-					params: [messageHex, '0x0000000000000000000000000000000000000000'],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					expect(response.result).to.be.equal(
-						'0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
-					);
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-			it('signs a transaction', (done: DoneCallback) => {
-				const tx = {
-					to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
-					value: '0x00',
-					gasPrice: '0x00',
-					nonce: '0x00',
-					gas: '0x00',
-				};
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_signTransaction',
-					params: [tx],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.be.a('null');
-					expect(response.result.raw.length).to.be.equal(192);
-					expect(response.result.raw.substr(0, 2)).to.be.equal('0x');
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-		});
-		describe('failure cases', () => {
-			it('should throw if `data` param not hex when calling eth_sign', (done: DoneCallback) => {
-				const nonHexMessage = 'hello world';
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sign',
-					params: ['0x0000000000000000000000000000000000000000', nonHexMessage],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.not.be.a('null');
-					expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world');
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-			it('should throw if `data` param not hex when calling personal_sign', (done: DoneCallback) => {
-				const nonHexMessage = 'hello world';
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'personal_sign',
-					params: [nonHexMessage, '0x0000000000000000000000000000000000000000'],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.not.be.a('null');
-					expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world');
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-			it('should throw if `from` param missing when calling eth_sendTransaction', (done: DoneCallback) => {
-				const tx = {
-					to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
-					value: '0xde0b6b3a7640000',
-				};
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sendTransaction',
-					params: [tx],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.not.be.a('null');
-					expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-			it('should throw if `from` param invalid address when calling eth_sendTransaction', (done: DoneCallback) => {
-				const tx = {
-					to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
-					from: '0xIncorrectEthereumAddress',
-					value: '0xde0b6b3a7640000',
-				};
-				const payload = {
-					jsonrpc: '2.0',
-					method: 'eth_sendTransaction',
-					params: [tx],
-					id: 1,
-				};
-				const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-					expect(err).to.not.be.a('null');
-					expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
-					done();
-				});
-				provider.sendAsync(payload, callback);
-			});
-		});
-	});
+    const networkId: number = 42;
+    let ledgerSubprovider: LedgerSubprovider;
+    before(async () => {
+        const ledgerEthereumClientFactoryAsync = async () => {
+            // tslint:disable:no-object-literal-type-assertion
+            const ledgerEthClient = {
+                getAddress_async: async () => {
+                    const publicKey =
+                        '04f428290f4c5ed6a198f71b8205f488141dbb3f0840c923bbfa798ecbee6370986c03b5575d94d506772fb48a6a44e345e4ebd4f028a6f609c44b655d6d3e71a1';
+                    const chainCode = 'ac055a5537c0c7e9e02d14a197cad6b857836da2a12043b46912a37d959b5ae8';
+                    const address = '0xBa388BA5e5EEF2c6cE42d831c2B3A28D3c99bdB1';
+                    return {
+                        publicKey,
+                        address,
+                        chainCode,
+                    };
+                },
+                signPersonalMessage_async: async () => {
+                    const ecSignature = {
+                        v: 28,
+                        r: 'a6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae49148',
+                        s: '0652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d0',
+                    };
+                    return ecSignature;
+                },
+                signTransaction_async: async (derivationPath: string, txHex: string) => {
+                    const ecSignature = {
+                        v: '77',
+                        r: '88a95ef1378487bc82be558e82c8478baf840c545d5b887536bb1da63673a98b',
+                        s: '019f4a4b9a107d1e6752bf7f701e275f28c13791d6e76af895b07373462cefaa',
+                    };
+                    return ecSignature;
+                },
+                comm: {
+                    close_async: _.noop,
+                } as LedgerCommunicationClient,
+            };
+            // tslint:enable:no-object-literal-type-assertion
+            return ledgerEthClient;
+        };
+        ledgerSubprovider = new LedgerSubprovider({
+            networkId,
+            ledgerEthereumClientFactoryAsync,
+        });
+    });
+    describe('direct method calls', () => {
+        describe('success cases', () => {
+            it('returns a list of accounts', async () => {
+                const accounts = await ledgerSubprovider.getAccountsAsync();
+                expect(accounts[0]).to.be.equal(FAKE_ADDRESS);
+                expect(accounts.length).to.be.equal(10);
+            });
+            it('signs a personal message', async () => {
+                const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data);
+                expect(ecSignatureHex).to.be.equal(
+                    '0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
+                );
+            });
+        });
+        describe('failure cases', () => {
+            it('cannot open multiple simultaneous connections to the Ledger device', async () => {
+                const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                return expect(
+                    Promise.all([
+                        ledgerSubprovider.getAccountsAsync(),
+                        ledgerSubprovider.signPersonalMessageAsync(data),
+                    ]),
+                ).to.be.rejectedWith(LedgerSubproviderErrors.MultipleOpenConnectionsDisallowed);
+            });
+        });
+    });
+    describe('calls through a provider', () => {
+        let provider: Web3ProviderEngine;
+        before(() => {
+            provider = new Web3ProviderEngine();
+            provider.addProvider(ledgerSubprovider);
+            const httpProvider = new RpcSubprovider({
+                rpcUrl: 'http://localhost:8545',
+            });
+            provider.addProvider(httpProvider);
+            provider.start();
+        });
+        describe('success cases', () => {
+            it('returns a list of accounts', (done: DoneCallback) => {
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_accounts',
+                    params: [],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result.length).to.be.equal(10);
+                    expect(response.result[0]).to.be.equal(FAKE_ADDRESS);
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('signs a personal message with eth_sign', (done: DoneCallback) => {
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sign',
+                    params: ['0x0000000000000000000000000000000000000000', messageHex],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result).to.be.equal(
+                        '0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
+                    );
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('signs a personal message with personal_sign', (done: DoneCallback) => {
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'personal_sign',
+                    params: [messageHex, '0x0000000000000000000000000000000000000000'],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result).to.be.equal(
+                        '0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
+                    );
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('signs a transaction', (done: DoneCallback) => {
+                const tx = {
+                    to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
+                    value: '0x00',
+                    gasPrice: '0x00',
+                    nonce: '0x00',
+                    gas: '0x00',
+                };
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_signTransaction',
+                    params: [tx],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result.raw.length).to.be.equal(192);
+                    expect(response.result.raw.substr(0, 2)).to.be.equal('0x');
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+        });
+        describe('failure cases', () => {
+            it('should throw if `data` param not hex when calling eth_sign', (done: DoneCallback) => {
+                const nonHexMessage = 'hello world';
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sign',
+                    params: ['0x0000000000000000000000000000000000000000', nonHexMessage],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.not.be.a('null');
+                    expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world');
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('should throw if `data` param not hex when calling personal_sign', (done: DoneCallback) => {
+                const nonHexMessage = 'hello world';
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'personal_sign',
+                    params: [nonHexMessage, '0x0000000000000000000000000000000000000000'],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.not.be.a('null');
+                    expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world');
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('should throw if `from` param missing when calling eth_sendTransaction', (done: DoneCallback) => {
+                const tx = {
+                    to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
+                    value: '0xde0b6b3a7640000',
+                };
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendTransaction',
+                    params: [tx],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.not.be.a('null');
+                    expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('should throw if `from` param invalid address when calling eth_sendTransaction', (done: DoneCallback) => {
+                const tx = {
+                    to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
+                    from: '0xIncorrectEthereumAddress',
+                    value: '0xde0b6b3a7640000',
+                };
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendTransaction',
+                    params: [tx],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+                    expect(err).to.not.be.a('null');
+                    expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+        });
+    });
 });
diff --git a/packages/subproviders/test/unit/redundant_rpc_subprovider_test.ts b/packages/subproviders/test/unit/redundant_rpc_subprovider_test.ts
index defb741dd..c3170745c 100644
--- a/packages/subproviders/test/unit/redundant_rpc_subprovider_test.ts
+++ b/packages/subproviders/test/unit/redundant_rpc_subprovider_test.ts
@@ -12,45 +12,45 @@ const expect = chai.expect;
 chaiSetup.configure();
 
 describe('RedundantRpcSubprovider', () => {
-	let provider: Web3ProviderEngine;
-	it('succeeds when supplied a healthy endpoint', (done: DoneCallback) => {
-		provider = new Web3ProviderEngine();
-		const endpoints = ['http://localhost:8545'];
-		const redundantSubprovider = new RedundantRPCSubprovider(endpoints);
-		provider.addProvider(redundantSubprovider);
-		provider.start();
+    let provider: Web3ProviderEngine;
+    it('succeeds when supplied a healthy endpoint', (done: DoneCallback) => {
+        provider = new Web3ProviderEngine();
+        const endpoints = ['http://localhost:8545'];
+        const redundantSubprovider = new RedundantRPCSubprovider(endpoints);
+        provider.addProvider(redundantSubprovider);
+        provider.start();
 
-		const payload = {
-			jsonrpc: '2.0',
-			method: 'eth_accounts',
-			params: [],
-			id: 1,
-		};
-		const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-			expect(err).to.be.a('null');
-			expect(response.result.length).to.be.equal(10);
-			done();
-		});
-		provider.sendAsync(payload, callback);
-	});
-	it('succeeds when supplied at least one healthy endpoint', (done: DoneCallback) => {
-		provider = new Web3ProviderEngine();
-		const endpoints = ['http://does-not-exist:3000', 'http://localhost:8545'];
-		const redundantSubprovider = new RedundantRPCSubprovider(endpoints);
-		provider.addProvider(redundantSubprovider);
-		provider.start();
+        const payload = {
+            jsonrpc: '2.0',
+            method: 'eth_accounts',
+            params: [],
+            id: 1,
+        };
+        const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+            expect(err).to.be.a('null');
+            expect(response.result.length).to.be.equal(10);
+            done();
+        });
+        provider.sendAsync(payload, callback);
+    });
+    it('succeeds when supplied at least one healthy endpoint', (done: DoneCallback) => {
+        provider = new Web3ProviderEngine();
+        const endpoints = ['http://does-not-exist:3000', 'http://localhost:8545'];
+        const redundantSubprovider = new RedundantRPCSubprovider(endpoints);
+        provider.addProvider(redundantSubprovider);
+        provider.start();
 
-		const payload = {
-			jsonrpc: '2.0',
-			method: 'eth_accounts',
-			params: [],
-			id: 1,
-		};
-		const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
-			expect(err).to.be.a('null');
-			expect(response.result.length).to.be.equal(10);
-			done();
-		});
-		provider.sendAsync(payload, callback);
-	});
+        const payload = {
+            jsonrpc: '2.0',
+            method: 'eth_accounts',
+            params: [],
+            id: 1,
+        };
+        const callback = reportCallbackErrors(done)((err: Error, response: Web3.JSONRPCResponsePayload) => {
+            expect(err).to.be.a('null');
+            expect(response.result.length).to.be.equal(10);
+            done();
+        });
+        provider.sendAsync(payload, callback);
+    });
 });
diff --git a/packages/subproviders/test/utils/report_callback_errors.ts b/packages/subproviders/test/utils/report_callback_errors.ts
index e6aadfa84..8a8f4d966 100644
--- a/packages/subproviders/test/utils/report_callback_errors.ts
+++ b/packages/subproviders/test/utils/report_callback_errors.ts
@@ -1,14 +1,14 @@
 import { DoneCallback } from '../../src/types';
 
 export const reportCallbackErrors = (done: DoneCallback) => {
-	return (f: (...args: any[]) => void) => {
-		const wrapped = async (...args: any[]) => {
-			try {
-				f(...args);
-			} catch (err) {
-				done(err);
-			}
-		};
-		return wrapped;
-	};
+    return (f: (...args: any[]) => void) => {
+        const wrapped = async (...args: any[]) => {
+            try {
+                f(...args);
+            } catch (err) {
+                done(err);
+            }
+        };
+        return wrapped;
+    };
 };