Merge pull request #506 from 0xProject/feature/subproviders/pk-wallet-subprovider

Private Key subprovider

12 files changed, 450 insertions, 224 deletions

diff --git a/packages/subproviders/CHANGELOG.json b/packages/subproviders/CHANGELOG.json
index 54eb32378..f0702cd5d 100644
--- a/packages/subproviders/CHANGELOG.json
+++ b/packages/subproviders/CHANGELOG.json
@@ -1,5 +1,14 @@
 [
     {
+        "version": "0.8.5",
+        "changes": [
+            {
+                "note": "Add private key subprovider and refactor shared functionality into a base wallet subprovider",
+                "pr": 506
+            }
+        ]
+    },
+    {
         "timestamp": 1522673609,
         "version": "0.8.4",
         "changes": [
diff --git a/packages/subproviders/src/index.ts b/packages/subproviders/src/index.ts
index 9786347e6..dd553fde4 100644
--- a/packages/subproviders/src/index.ts
+++ b/packages/subproviders/src/index.ts
@@ -12,6 +12,7 @@ export { LedgerSubprovider } from './subproviders/ledger';
 export { GanacheSubprovider } from './subproviders/ganache';
 export { Subprovider } from './subproviders/subprovider';
 export { NonceTrackerSubprovider } from './subproviders/nonce_tracker';
+export { PrivateKeyWalletSubprovider } from './subproviders/private_key_wallet_subprovider';
 export {
     Callback,
     ErrorCallback,
diff --git a/packages/subproviders/src/subproviders/base_wallet_subprovider.ts b/packages/subproviders/src/subproviders/base_wallet_subprovider.ts
new file mode 100644
index 000000000..034f83e7f
--- /dev/null
+++ b/packages/subproviders/src/subproviders/base_wallet_subprovider.ts
@@ -0,0 +1,137 @@
+import { assert } from '@0xproject/assert';
+import { JSONRPCRequestPayload, JSONRPCResponsePayload } from '@0xproject/types';
+import { addressUtils } from '@0xproject/utils';
+import * as _ from 'lodash';
+
+import { Callback, ErrorCallback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types';
+
+import { Subprovider } from './subprovider';
+
+export abstract class BaseWalletSubprovider extends Subprovider {
+    protected static _validateTxParams(txParams: PartialTxParams) {
+        assert.isETHAddressHex('to', txParams.to);
+        assert.isHexString('nonce', txParams.nonce);
+        assert.isHexString('gas', txParams.gas);
+    }
+    private static _validateSender(sender: string) {
+        if (_.isUndefined(sender) || !addressUtils.isAddress(sender)) {
+            throw new Error(WalletSubproviderErrors.SenderInvalidOrNotSupplied);
+        }
+    }
+
+    public abstract async getAccountsAsync(): Promise<string[]>;
+    public abstract async signTransactionAsync(txParams: PartialTxParams): Promise<string>;
+    public abstract async signPersonalMessageAsync(data: string): Promise<string>;
+
+    /**
+     * This method conforms to the web3-provider-engine interface.
+     * It is called internally by the ProviderEngine when it is this subproviders
+     * turn to handle a JSON RPC request.
+     * @param payload JSON RPC payload
+     * @param next Callback to call if this subprovider decides not to handle the request
+     * @param end Callback to call if subprovider handled the request and wants to pass back the request.
+     */
+    // tslint:disable-next-line:async-suffix
+    public async handleRequest(payload: JSONRPCRequestPayload, next: Callback, end: ErrorCallback) {
+        let accounts;
+        let txParams;
+        switch (payload.method) {
+            case 'eth_coinbase':
+                try {
+                    accounts = await this.getAccountsAsync();
+                    end(null, accounts[0]);
+                } catch (err) {
+                    end(err);
+                }
+                return;
+
+            case 'eth_accounts':
+                try {
+                    accounts = await this.getAccountsAsync();
+                    end(null, accounts);
+                } catch (err) {
+                    end(err);
+                }
+                return;
+
+            case 'eth_sendTransaction':
+                txParams = payload.params[0];
+                try {
+                    BaseWalletSubprovider._validateSender(txParams.from);
+                    const filledParams = await this._populateMissingTxParamsAsync(txParams);
+                    const signedTx = await this.signTransactionAsync(filledParams);
+                    const response = await this._emitSendTransactionAsync(signedTx);
+                    end(null, response.result);
+                } catch (err) {
+                    end(err);
+                }
+                return;
+
+            case 'eth_signTransaction':
+                txParams = payload.params[0];
+                try {
+                    const filledParams = await this._populateMissingTxParamsAsync(txParams);
+                    const signedTx = await this.signTransactionAsync(filledParams);
+                    const result = {
+                        raw: signedTx,
+                        tx: txParams,
+                    };
+                    end(null, result);
+                } catch (err) {
+                    end(err);
+                }
+                return;
+
+            case 'eth_sign':
+            case 'personal_sign':
+                const data = payload.method === 'eth_sign' ? payload.params[1] : payload.params[0];
+                try {
+                    const ecSignatureHex = await this.signPersonalMessageAsync(data);
+                    end(null, ecSignatureHex);
+                } catch (err) {
+                    end(err);
+                }
+                return;
+
+            default:
+                next();
+                return;
+        }
+    }
+    private async _emitSendTransactionAsync(signedTx: string): Promise<JSONRPCResponsePayload> {
+        const payload = {
+            method: 'eth_sendRawTransaction',
+            params: [signedTx],
+        };
+        const result = await this.emitPayloadAsync(payload);
+        return result;
+    }
+    private async _populateMissingTxParamsAsync(partialTxParams: PartialTxParams): Promise<PartialTxParams> {
+        let txParams = partialTxParams;
+        if (_.isUndefined(partialTxParams.gasPrice)) {
+            const gasPriceResult = await this.emitPayloadAsync({
+                method: 'eth_gasPrice',
+                params: [],
+            });
+            const gasPrice = gasPriceResult.result.toString();
+            txParams = { ...txParams, gasPrice };
+        }
+        if (_.isUndefined(partialTxParams.nonce)) {
+            const nonceResult = await this.emitPayloadAsync({
+                method: 'eth_getTransactionCount',
+                params: [partialTxParams.from, 'pending'],
+            });
+            const nonce = nonceResult.result;
+            txParams = { ...txParams, nonce };
+        }
+        if (_.isUndefined(partialTxParams.gas)) {
+            const gasResult = await this.emitPayloadAsync({
+                method: 'eth_estimateGas',
+                params: [partialTxParams],
+            });
+            const gas = gasResult.result.toString();
+            txParams = { ...txParams, gas };
+        }
+        return txParams;
+    }
+}
diff --git a/packages/subproviders/src/subproviders/ledger.ts b/packages/subproviders/src/subproviders/ledger.ts
index 95784a391..aa86bf6c0 100644
--- a/packages/subproviders/src/subproviders/ledger.ts
+++ b/packages/subproviders/src/subproviders/ledger.ts
@@ -15,9 +15,10 @@ import {
     LedgerSubproviderErrors,
     PartialTxParams,
     ResponseWithTxParams,
+    WalletSubproviderErrors,
 } from '../types';
 
-import { Subprovider } from './subprovider';
+import { BaseWalletSubprovider } from './base_wallet_subprovider';
 
 const DEFAULT_DERIVATION_PATH = `44'/60'/0'`;
 const DEFAULT_NUM_ADDRESSES_TO_FETCH = 10;
@@ -29,7 +30,7 @@ const SHOULD_GET_CHAIN_CODE = true;
  * This subprovider intercepts all account related RPC requests (e.g message/transaction signing, etc...) and
  * re-routes them to a Ledger device plugged into the users computer.
  */
-export class LedgerSubprovider extends Subprovider {
+export class LedgerSubprovider extends BaseWalletSubprovider {
     private _nonceLock = new Lock();
     private _connectionLock = new Lock();
     private _networkId: number;
@@ -38,11 +39,6 @@ export class LedgerSubprovider extends Subprovider {
     private _ledgerEthereumClientFactoryAsync: LedgerEthereumClientFactoryAsync;
     private _ledgerClientIfExists?: LedgerEthereumClient;
     private _shouldAlwaysAskForConfirmation: boolean;
-    private static _validateSender(sender: string) {
-        if (_.isUndefined(sender) || !addressUtils.isAddress(sender)) {
-            throw new Error(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
-        }
-    }
     /**
      * Instantiates a LedgerSubprovider. Defaults to derivationPath set to `44'/60'/0'`.
      * TestRPC/Ganache defaults to `m/44'/60'/0'/0`, so set this in the configs if desired.
@@ -133,6 +129,7 @@ export class LedgerSubprovider extends Subprovider {
      * @return Signed transaction hex string
      */
     public async signTransactionAsync(txParams: PartialTxParams): Promise<string> {
+        LedgerSubprovider._validateTxParams(txParams);
         this._ledgerClientIfExists = await this._createLedgerClientAsync();
 
         const tx = new EthereumTx(txParams);
@@ -168,7 +165,7 @@ export class LedgerSubprovider extends Subprovider {
         }
     }
     /**
-     * Sign a personal Ethereum signed message. The signing address will be to one
+     * Sign a personal Ethereum signed message. The signing address will be the one
      * retrieved given a derivationPath and pathIndex set on the subprovider.
      * The Ledger adds the Ethereum signed message prefix on-device.  If you've added
      * the LedgerSubprovider to your app's provider, you can simply send an `eth_sign`
@@ -178,6 +175,10 @@ export class LedgerSubprovider extends Subprovider {
      * @return Signature hex string (order: rsv)
      */
     public async signPersonalMessageAsync(data: string): Promise<string> {
+        if (_.isUndefined(data)) {
+            throw new Error(WalletSubproviderErrors.DataMissingForSignPersonalMessage);
+        }
+        assert.isHexString('data', data);
         this._ledgerClientIfExists = await this._createLedgerClientAsync();
         try {
             const derivationPath = this._getDerivationPath();
@@ -198,82 +199,6 @@ export class LedgerSubprovider extends Subprovider {
             throw err;
         }
     }
-    /**
-     * This method conforms to the web3-provider-engine interface.
-     * It is called internally by the ProviderEngine when it is this subproviders
-     * turn to handle a JSON RPC request.
-     * @param payload JSON RPC payload
-     * @param next Callback to call if this subprovider decides not to handle the request
-     * @param end Callback to call if subprovider handled the request and wants to pass back the request.
-     */
-    // tslint:disable-next-line:async-suffix
-    public async handleRequest(
-        payload: JSONRPCRequestPayload,
-        next: Callback,
-        end: (err: Error | null, result?: any) => void,
-    ) {
-        let accounts;
-        let txParams;
-        switch (payload.method) {
-            case 'eth_coinbase':
-                try {
-                    accounts = await this.getAccountsAsync();
-                    end(null, accounts[0]);
-                } catch (err) {
-                    end(err);
-                }
-                return;
-
-            case 'eth_accounts':
-                try {
-                    accounts = await this.getAccountsAsync();
-                    end(null, accounts);
-                } catch (err) {
-                    end(err);
-                }
-                return;
-
-            case 'eth_sendTransaction':
-                txParams = payload.params[0];
-                try {
-                    LedgerSubprovider._validateSender(txParams.from);
-                    const result = await this._sendTransactionAsync(txParams);
-                    end(null, result);
-                } catch (err) {
-                    end(err);
-                }
-                return;
-
-            case 'eth_signTransaction':
-                txParams = payload.params[0];
-                try {
-                    const result = await this._signTransactionWithoutSendingAsync(txParams);
-                    end(null, result);
-                } catch (err) {
-                    end(err);
-                }
-                return;
-
-            case 'eth_sign':
-            case 'personal_sign':
-                const data = payload.method === 'eth_sign' ? payload.params[1] : payload.params[0];
-                try {
-                    if (_.isUndefined(data)) {
-                        throw new Error(LedgerSubproviderErrors.DataMissingForSignPersonalMessage);
-                    }
-                    assert.isHexString('data', data);
-                    const ecSignatureHex = await this.signPersonalMessageAsync(data);
-                    end(null, ecSignatureHex);
-                } catch (err) {
-                    end(err);
-                }
-                return;
-
-            default:
-                next();
-                return;
-        }
-    }
     private _getDerivationPath() {
         const derivationPath = `${this.getPath()}/${this._derivationPathIndex}`;
         return derivationPath;
@@ -298,70 +223,4 @@ export class LedgerSubprovider extends Subprovider {
         this._ledgerClientIfExists = undefined;
         this._connectionLock.release();
     }
-    private async _sendTransactionAsync(txParams: PartialTxParams): Promise<string> {
-        await this._nonceLock.acquire();
-        try {
-            // fill in the extras
-            const filledParams = await this._populateMissingTxParamsAsync(txParams);
-            // sign it
-            const signedTx = await this.signTransactionAsync(filledParams);
-            // emit a submit
-            const payload = {
-                method: 'eth_sendRawTransaction',
-                params: [signedTx],
-            };
-            const result = await this.emitPayloadAsync(payload);
-            this._nonceLock.release();
-            return result.result;
-        } catch (err) {
-            this._nonceLock.release();
-            throw err;
-        }
-    }
-    private async _signTransactionWithoutSendingAsync(txParams: PartialTxParams): Promise<ResponseWithTxParams> {
-        await this._nonceLock.acquire();
-        try {
-            // fill in the extras
-            const filledParams = await this._populateMissingTxParamsAsync(txParams);
-            // sign it
-            const signedTx = await this.signTransactionAsync(filledParams);
-
-            this._nonceLock.release();
-            const result = {
-                raw: signedTx,
-                tx: txParams,
-            };
-            return result;
-        } catch (err) {
-            this._nonceLock.release();
-            throw err;
-        }
-    }
-    private async _populateMissingTxParamsAsync(txParams: PartialTxParams): Promise<PartialTxParams> {
-        if (_.isUndefined(txParams.gasPrice)) {
-            const gasPriceResult = await this.emitPayloadAsync({
-                method: 'eth_gasPrice',
-                params: [],
-            });
-            const gasPrice = gasPriceResult.result.toString();
-            txParams.gasPrice = gasPrice;
-        }
-        if (_.isUndefined(txParams.nonce)) {
-            const nonceResult = await this.emitPayloadAsync({
-                method: 'eth_getTransactionCount',
-                params: [txParams.from, 'pending'],
-            });
-            const nonce = nonceResult.result;
-            txParams.nonce = nonce;
-        }
-        if (_.isUndefined(txParams.gas)) {
-            const gasResult = await this.emitPayloadAsync({
-                method: 'eth_estimateGas',
-                params: [txParams],
-            });
-            const gas = gasResult.result.toString();
-            txParams.gas = gas;
-        }
-        return txParams;
-    }
 }
diff --git a/packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts b/packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts
new file mode 100644
index 000000000..c3a53773a
--- /dev/null
+++ b/packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts
@@ -0,0 +1,70 @@
+import { assert } from '@0xproject/assert';
+import { JSONRPCRequestPayload } from '@0xproject/types';
+import EthereumTx = require('ethereumjs-tx');
+import * as ethUtil from 'ethereumjs-util';
+import * as _ from 'lodash';
+
+import { Callback, ErrorCallback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types';
+
+import { BaseWalletSubprovider } from './base_wallet_subprovider';
+import { Subprovider } from './subprovider';
+
+/**
+ * This class implements the [web3-provider-engine](https://github.com/MetaMask/provider-engine) subprovider interface.
+ * This subprovider intercepts all account related RPC requests (e.g message/transaction signing, etc...) and handles
+ * all requests with the supplied Ethereum private key.
+ */
+export class PrivateKeyWalletSubprovider extends BaseWalletSubprovider {
+    private _address: string;
+    private _privateKeyBuffer: Buffer;
+    constructor(privateKey: string) {
+        assert.isString('privateKey', privateKey);
+        super();
+        this._privateKeyBuffer = new Buffer(privateKey, 'hex');
+        this._address = `0x${ethUtil.privateToAddress(this._privateKeyBuffer).toString('hex')}`;
+    }
+    /**
+     * Retrieve the account associated with the supplied private key.
+     * This method is implicitly called when issuing a `eth_accounts` JSON RPC request
+     * via your providerEngine instance.
+     * @return An array of accounts
+     */
+    public async getAccountsAsync(): Promise<string[]> {
+        return [this._address];
+    }
+    /**
+     * Sign a transaction with the private key. If you've added this Subprovider to your
+     * app's provider, you can simply send an `eth_sendTransaction` JSON RPC request, and
+     * this method will be called auto-magically. If you are not using this via a ProviderEngine
+     * instance, you can call it directly.
+     * @param txParams Parameters of the transaction to sign
+     * @return Signed transaction hex string
+     */
+    public async signTransactionAsync(txParams: PartialTxParams): Promise<string> {
+        PrivateKeyWalletSubprovider._validateTxParams(txParams);
+        const tx = new EthereumTx(txParams);
+        tx.sign(this._privateKeyBuffer);
+        const rawTx = `0x${tx.serialize().toString('hex')}`;
+        return rawTx;
+    }
+    /**
+     * Sign a personal Ethereum signed message. The signing address will be
+     * calculated from the private key.
+     * If you've added the PKWalletSubprovider to your app's provider, you can simply send an `eth_sign`
+     * or `personal_sign` JSON RPC request, and this method will be called auto-magically.
+     * If you are not using this via a ProviderEngine instance, you can call it directly.
+     * @param data Message to sign
+     * @return Signature hex string (order: rsv)
+     */
+    public async signPersonalMessageAsync(dataIfExists: string): Promise<string> {
+        if (_.isUndefined(dataIfExists)) {
+            throw new Error(WalletSubproviderErrors.DataMissingForSignPersonalMessage);
+        }
+        assert.isHexString('data', dataIfExists);
+        const dataBuff = ethUtil.toBuffer(dataIfExists);
+        const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff);
+        const sig = ethUtil.ecsign(msgHashBuff, this._privateKeyBuffer);
+        const rpcSig = ethUtil.toRpcSig(sig.v, sig.r, sig.s);
+        return rpcSig;
+    }
+}
diff --git a/packages/subproviders/src/types.ts b/packages/subproviders/src/types.ts
index a1fec1882..bacb7091b 100644
--- a/packages/subproviders/src/types.ts
+++ b/packages/subproviders/src/types.ts
@@ -95,11 +95,13 @@ export interface ResponseWithTxParams {
     tx: PartialTxParams;
 }
 
+export enum WalletSubproviderErrors {
+    DataMissingForSignPersonalMessage = 'DATA_MISSING_FOR_SIGN_PERSONAL_MESSAGE',
+    SenderInvalidOrNotSupplied = 'SENDER_INVALID_OR_NOT_SUPPLIED',
+}
 export enum LedgerSubproviderErrors {
     TooOldLedgerFirmware = 'TOO_OLD_LEDGER_FIRMWARE',
     FromAddressMissingOrInvalid = 'FROM_ADDRESS_MISSING_OR_INVALID',
-    DataMissingForSignPersonalMessage = 'DATA_MISSING_FOR_SIGN_PERSONAL_MESSAGE',
-    SenderInvalidOrNotSupplied = 'SENDER_INVALID_OR_NOT_SUPPLIED',
     MultipleOpenConnectionsDisallowed = 'MULTIPLE_OPEN_CONNECTIONS_DISALLOWED',
 }
 
diff --git a/packages/subproviders/test/integration/ledger_subprovider_test.ts b/packages/subproviders/test/integration/ledger_subprovider_test.ts
index bc60b4330..503618089 100644
--- a/packages/subproviders/test/integration/ledger_subprovider_test.ts
+++ b/packages/subproviders/test/integration/ledger_subprovider_test.ts
@@ -14,6 +14,7 @@ import RpcSubprovider = require('web3-provider-engine/subproviders/rpc');
 import { LedgerSubprovider } from '../../src';
 import { DoneCallback, LedgerEthereumClient } from '../../src/types';
 import { chaiSetup } from '../chai_setup';
+import { fixtureData } from '../utils/fixture_data';
 import { reportCallbackErrors } from '../utils/report_callback_errors';
 
 chaiSetup.configure();
@@ -25,17 +26,14 @@ async function ledgerEthereumNodeJsClientFactoryAsync(): Promise<LedgerEthereumC
     return ledgerEthClient;
 }
 
-const TESTRPC_DERIVATION_PATH = `m/44'/60'/0'/0`;
-const TEST_RPC_ACCOUNT_0 = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-
 describe('LedgerSubprovider', () => {
     let ledgerSubprovider: LedgerSubprovider;
-    const networkId: number = 42;
+    const networkId: number = fixtureData.NETWORK_ID;
     before(async () => {
         ledgerSubprovider = new LedgerSubprovider({
             networkId,
             ledgerEthereumClientFactoryAsync: ledgerEthereumNodeJsClientFactoryAsync,
-            derivationPath: TESTRPC_DERIVATION_PATH,
+            derivationPath: fixtureData.TESTRPC_DERIVATION_PATH,
         });
     });
     describe('direct method calls', () => {
@@ -46,7 +44,7 @@ describe('LedgerSubprovider', () => {
         });
         it('returns the expected first account from a ledger set up with the test mnemonic', async () => {
             const accounts = await ledgerSubprovider.getAccountsAsync();
-            expect(accounts[0]).to.be.equal(TEST_RPC_ACCOUNT_0);
+            expect(accounts[0]).to.be.equal(fixtureData.TEST_RPC_ACCOUNT_0);
         });
         it('returns requested number of accounts', async () => {
             const numberOfAccounts = 20;
@@ -55,24 +53,14 @@ describe('LedgerSubprovider', () => {
             expect(accounts.length).to.be.equal(numberOfAccounts);
         });
         it('signs a personal message', async () => {
-            const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+            const data = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING));
             const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data);
             expect(ecSignatureHex.length).to.be.equal(132);
-            expect(ecSignatureHex.substr(0, 2)).to.be.equal('0x');
+            expect(ecSignatureHex).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT);
         });
         it('signs a transaction', async () => {
-            const tx = {
-                nonce: '0x00',
-                gas: '0x2710',
-                to: '0x0000000000000000000000000000000000000000',
-                value: '0x00',
-                chainId: 3,
-                from: TEST_RPC_ACCOUNT_0,
-            };
-            const txHex = await ledgerSubprovider.signTransactionAsync(tx);
-            expect(txHex).to.be.equal(
-                '0xf85f8080822710940000000000000000000000000000000000000000808078a0712854c73c69445cc1b22a7c3d7312ff9a97fe4ffba35fd636e8236b211b6e7ca0647cee031615e52d916c7c707025bc64ad525d8f1b9876c3435a863b42743178',
-            );
+            const txHex = await ledgerSubprovider.signTransactionAsync(fixtureData.TX_DATA);
+            expect(txHex).to.be.equal(fixtureData.TX_DATA_SIGNED_RESULT);
         });
     });
     describe('calls through a provider', () => {
@@ -146,20 +134,15 @@ describe('LedgerSubprovider', () => {
             })().catch(done);
         });
         it('signs a transaction', (done: DoneCallback) => {
-            const tx = {
-                to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66',
-                value: '0x00',
-            };
             const payload = {
                 jsonrpc: '2.0',
                 method: 'eth_signTransaction',
-                params: [tx],
+                params: [fixtureData.TX_DATA],
                 id: 1,
             };
             const callback = reportCallbackErrors(done)((err: Error, response: 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');
+                expect(response.result.raw).to.be.equal(fixtureData.TX_DATA_SIGNED_RESULT);
                 done();
             });
             ledgerProvider.sendAsync(payload, callback);
@@ -171,7 +154,7 @@ describe('LedgerSubprovider', () => {
                 // Give first account on Ledger sufficient ETH to complete tx send
                 let tx = {
                     to: accounts[0],
-                    from: TEST_RPC_ACCOUNT_0,
+                    from: fixtureData.TEST_RPC_ACCOUNT_0,
                     value: '0x8ac7230489e80000', // 10 ETH
                 };
                 let payload = {
diff --git a/packages/subproviders/test/unit/ledger_subprovider_test.ts b/packages/subproviders/test/unit/ledger_subprovider_test.ts
index 3cb487f02..c18506681 100644
--- a/packages/subproviders/test/unit/ledger_subprovider_test.ts
+++ b/packages/subproviders/test/unit/ledger_subprovider_test.ts
@@ -7,8 +7,14 @@ import Web3ProviderEngine = require('web3-provider-engine');
 import RpcSubprovider = require('web3-provider-engine/subproviders/rpc');
 
 import { LedgerSubprovider } from '../../src';
-import { DoneCallback, LedgerCommunicationClient, LedgerSubproviderErrors } from '../../src/types';
+import {
+    DoneCallback,
+    LedgerCommunicationClient,
+    LedgerSubproviderErrors,
+    WalletSubproviderErrors,
+} from '../../src/types';
 import { chaiSetup } from '../chai_setup';
+import { fixtureData } from '../utils/fixture_data';
 import { reportCallbackErrors } from '../utils/report_callback_errors';
 
 chaiSetup.configure();
@@ -75,7 +81,7 @@ describe('LedgerSubprovider', () => {
                 expect(accounts.length).to.be.equal(numberOfAccounts);
             });
             it('signs a personal message', async () => {
-                const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const data = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING));
                 const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data);
                 expect(ecSignatureHex).to.be.equal(
                     '0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001',
@@ -139,7 +145,7 @@ describe('LedgerSubprovider', () => {
                 provider.sendAsync(payload, callback);
             });
             it('signs a personal message with personal_sign', (done: DoneCallback) => {
-                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world'));
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING));
                 const payload = {
                     jsonrpc: '2.0',
                     method: 'personal_sign',
@@ -222,7 +228,7 @@ describe('LedgerSubprovider', () => {
                 };
                 const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => {
                     expect(err).to.not.be.a('null');
-                    expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
+                    expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied);
                     done();
                 });
                 provider.sendAsync(payload, callback);
@@ -241,7 +247,7 @@ describe('LedgerSubprovider', () => {
                 };
                 const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => {
                     expect(err).to.not.be.a('null');
-                    expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied);
+                    expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied);
                     done();
                 });
                 provider.sendAsync(payload, callback);
diff --git a/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts b/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts
new file mode 100644
index 000000000..ca0665871
--- /dev/null
+++ b/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts
@@ -0,0 +1,170 @@
+import { JSONRPCResponsePayload } from '@0xproject/types';
+import * as chai from 'chai';
+import * as ethUtils from 'ethereumjs-util';
+import * as _ from 'lodash';
+import Web3ProviderEngine = require('web3-provider-engine');
+
+import { GanacheSubprovider, PrivateKeyWalletSubprovider } from '../../src/';
+import {
+    DoneCallback,
+    LedgerCommunicationClient,
+    LedgerSubproviderErrors,
+    WalletSubproviderErrors,
+} from '../../src/types';
+import { chaiSetup } from '../chai_setup';
+import { fixtureData } from '../utils/fixture_data';
+import { reportCallbackErrors } from '../utils/report_callback_errors';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+describe('PrivateKeyWalletSubprovider', () => {
+    let subprovider: PrivateKeyWalletSubprovider;
+    before(async () => {
+        subprovider = new PrivateKeyWalletSubprovider(fixtureData.TEST_RPC_ACCOUNT_0_ACCOUNT_PRIVATE_KEY);
+    });
+    describe('direct method calls', () => {
+        describe('success cases', () => {
+            it('returns the account', async () => {
+                const accounts = await subprovider.getAccountsAsync();
+                expect(accounts[0]).to.be.equal(fixtureData.TEST_RPC_ACCOUNT_0);
+                expect(accounts.length).to.be.equal(1);
+            });
+            it('signs a personal message', async () => {
+                const data = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING));
+                const ecSignatureHex = await subprovider.signPersonalMessageAsync(data);
+                expect(ecSignatureHex).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT);
+            });
+            it('signs a transaction', async () => {
+                const txHex = await subprovider.signTransactionAsync(fixtureData.TX_DATA);
+                expect(txHex).to.be.equal(fixtureData.TX_DATA_SIGNED_RESULT);
+            });
+        });
+    });
+    describe('calls through a provider', () => {
+        let provider: Web3ProviderEngine;
+        before(() => {
+            provider = new Web3ProviderEngine();
+            provider.addProvider(subprovider);
+            const ganacheSubprovider = new GanacheSubprovider({});
+            provider.addProvider(ganacheSubprovider);
+            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: JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result[0]).to.be.equal(fixtureData.TEST_RPC_ACCOUNT_0);
+                    expect(response.result.length).to.be.equal(1);
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('signs a personal message with eth_sign', (done: DoneCallback) => {
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING));
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'eth_sign',
+                    params: ['0x0000000000000000000000000000000000000000', messageHex],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT);
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+            it('signs a personal message with personal_sign', (done: DoneCallback) => {
+                const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING));
+                const payload = {
+                    jsonrpc: '2.0',
+                    method: 'personal_sign',
+                    params: [messageHex, '0x0000000000000000000000000000000000000000'],
+                    id: 1,
+                };
+                const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => {
+                    expect(err).to.be.a('null');
+                    expect(response.result).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT);
+                    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: 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: 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: JSONRPCResponsePayload) => {
+                    expect(err).to.not.be.a('null');
+                    expect(err.message).to.be.equal(WalletSubproviderErrors.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: JSONRPCResponsePayload) => {
+                    expect(err).to.not.be.a('null');
+                    expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied);
+                    done();
+                });
+                provider.sendAsync(payload, callback);
+            });
+        });
+    });
+});
diff --git a/packages/subproviders/test/utils/fixture_data.ts b/packages/subproviders/test/utils/fixture_data.ts
new file mode 100644
index 000000000..890573d0d
--- /dev/null
+++ b/packages/subproviders/test/utils/fixture_data.ts
@@ -0,0 +1,23 @@
+const TEST_RPC_ACCOUNT_0 = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
+const networkId = 42;
+export const fixtureData = {
+    TEST_RPC_ACCOUNT_0,
+    TEST_RPC_ACCOUNT_0_ACCOUNT_PRIVATE_KEY: 'F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D',
+    PERSONAL_MESSAGE_STRING: 'hello world',
+    PERSONAL_MESSAGE_SIGNED_RESULT:
+        '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00',
+    TESTRPC_DERIVATION_PATH: `m/44'/60'/0'/0`,
+    NETWORK_ID: networkId,
+    TX_DATA: {
+        nonce: '0x00',
+        gasPrice: '0x0',
+        gas: '0x2710',
+        to: '0x0000000000000000000000000000000000000000',
+        value: '0x00',
+        chainId: networkId,
+        from: TEST_RPC_ACCOUNT_0,
+    },
+    // This is the signed result of the abouve Transaction Data
+    TX_DATA_SIGNED_RESULT:
+        '0xf85f8080822710940000000000000000000000000000000000000000808078a0712854c73c69445cc1b22a7c3d7312ff9a97fe4ffba35fd636e8236b211b6e7ca0647cee031615e52d916c7c707025bc64ad525d8f1b9876c3435a863b42743178',
+};
diff --git a/packages/testnet-faucets/src/ts/handler.ts b/packages/testnet-faucets/src/ts/handler.ts
index f9ac484de..a6e786552 100644
--- a/packages/testnet-faucets/src/ts/handler.ts
+++ b/packages/testnet-faucets/src/ts/handler.ts
@@ -9,15 +9,13 @@ import * as Web3 from 'web3';
 // we are not running in a browser env.
 // Filed issue: https://github.com/ethereum/web3.js/issues/844
 (global as any).XMLHttpRequest = undefined;
-import { NonceTrackerSubprovider } from '@0xproject/subproviders';
+import { NonceTrackerSubprovider, PrivateKeyWalletSubprovider } from '@0xproject/subproviders';
 import ProviderEngine = require('web3-provider-engine');
-import HookedWalletSubprovider = require('web3-provider-engine/subproviders/hooked-wallet');
 import RpcSubprovider = require('web3-provider-engine/subproviders/rpc');
 
 import { configs } from './configs';
 import { DispatchQueue } from './dispatch_queue';
 import { dispenseAssetTasks } from './dispense_asset_tasks';
-import { idManagement } from './id_management';
 import { rpcUrls } from './rpc_urls';
 
 interface NetworkConfig {
@@ -41,9 +39,12 @@ const FIVE_DAYS_IN_MS = 4.32e8; // TODO: make this configurable
 export class Handler {
     private _networkConfigByNetworkId: ItemByNetworkId<NetworkConfig> = {};
     private static _createProviderEngine(rpcUrl: string) {
+        if (_.isUndefined(configs.DISPENSER_PRIVATE_KEY)) {
+            throw new Error('Dispenser Private key not found');
+        }
         const engine = new ProviderEngine();
         engine.addProvider(new NonceTrackerSubprovider());
-        engine.addProvider(new HookedWalletSubprovider(idManagement));
+        engine.addProvider(new PrivateKeyWalletSubprovider(configs.DISPENSER_PRIVATE_KEY));
         engine.addProvider(
             new RpcSubprovider({
                 rpcUrl,
diff --git a/packages/testnet-faucets/src/ts/id_management.ts b/packages/testnet-faucets/src/ts/id_management.ts
deleted file mode 100644
index 7c598f91c..000000000
--- a/packages/testnet-faucets/src/ts/id_management.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import EthereumTx = require('ethereumjs-tx');
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { configs } from './configs';
-
-type Callback = (err: Error | null, result: any) => void;
-
-export const idManagement = {
-    getAccounts(callback: Callback) {
-        callback(null, [configs.DISPENSER_ADDRESS]);
-    },
-    approveTransaction(txData: object, callback: Callback) {
-        callback(null, true);
-    },
-    signTransaction(txData: object, callback: Callback) {
-        const tx = new EthereumTx(txData);
-        const privateKeyBuffer = new Buffer(configs.DISPENSER_PRIVATE_KEY as string, 'hex');
-        tx.sign(privateKeyBuffer);
-        const rawTx = `0x${tx.serialize().toString('hex')}`;
-        callback(null, rawTx);
-    },
-    signMessage(message: object, callback: Callback) {
-        const dataIfExists = _.get(message, 'data');
-        if (_.isUndefined(dataIfExists)) {
-            callback(new Error('NO_DATA_TO_SIGN'), null);
-        }
-        const privateKeyBuffer = new Buffer(configs.DISPENSER_PRIVATE_KEY as string, 'hex');
-        const dataBuff = ethUtil.toBuffer(dataIfExists);
-        const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff);
-        const sig = ethUtil.ecsign(msgHashBuff, privateKeyBuffer);
-        const rpcSig = ethUtil.toRpcSig(sig.v, sig.r, sig.s);
-        callback(null, rpcSig);
-    },
-};