Merge branch 'v2-prototype' into v2-contract-wrappers-WIP

4 files changed, 102 insertions, 68 deletions

diff --git a/packages/subproviders/src/globals.d.ts b/packages/subproviders/src/globals.d.ts
index 4b3ecdf3c..94e63a32d 100644
--- a/packages/subproviders/src/globals.d.ts
+++ b/packages/subproviders/src/globals.d.ts
@@ -1,56 +1,3 @@
-// tslint:disable:max-classes-per-file
-// tslint:disable:class-name
-// tslint:disable:async-suffix
-// tslint:disable:completed-docs
-
-// Ethereumjs-tx declarations
-
-// Ledgerco declarations
-interface ECSignatureString {
-    v: string;
-    r: string;
-    s: string;
-}
-interface ECSignature {
-    v: number;
-    r: string;
-    s: string;
-}
-
-interface LedgerTransport {
-    close(): Promise<void>;
-}
-
-declare module '@ledgerhq/hw-app-eth' {
-    class Eth {
-        public transport: LedgerTransport;
-        constructor(transport: LedgerTransport);
-        public getAddress(
-            path: string,
-            boolDisplay?: boolean,
-            boolChaincode?: boolean,
-        ): Promise<{ publicKey: string; address: string; chainCode: string }>;
-        public signTransaction(path: string, rawTxHex: string): Promise<ECSignatureString>;
-        public getAppConfiguration(): Promise<{ arbitraryDataEnabled: number; version: string }>;
-        public signPersonalMessage(path: string, messageHex: string): Promise<ECSignature>;
-    }
-    export default Eth;
-}
-
-declare module '@ledgerhq/hw-transport-u2f' {
-    export default class TransportU2F implements LedgerTransport {
-        public static create(): Promise<LedgerTransport>;
-        public close(): Promise<void>;
-    }
-}
-
-declare module '@ledgerhq/hw-transport-node-hid' {
-    export default class TransportNodeHid implements LedgerTransport {
-        public static create(): Promise<LedgerTransport>;
-        public close(): Promise<void>;
-    }
-}
-
 declare module '*.json' {
     const json: any;
     /* tslint:disable */
diff --git a/packages/subproviders/src/index.ts b/packages/subproviders/src/index.ts
index 6cc650a4d..71d643f14 100644
--- a/packages/subproviders/src/index.ts
+++ b/packages/subproviders/src/index.ts
@@ -7,7 +7,7 @@ import { LedgerEthereumClient } from './types';
 export { prependSubprovider } from './utils/subprovider_utils';
 export { EmptyWalletSubprovider } from './subproviders/empty_wallet_subprovider';
 export { FakeGasEstimateSubprovider } from './subproviders/fake_gas_estimate_subprovider';
-export { InjectedWeb3Subprovider } from './subproviders/injected_web3';
+export { SignerSubprovider } from './subproviders/signer';
 export { RedundantSubprovider } from './subproviders/redundant_subprovider';
 export { LedgerSubprovider } from './subproviders/ledger';
 export { GanacheSubprovider } from './subproviders/ganache';
@@ -15,11 +15,13 @@ export { Subprovider } from './subproviders/subprovider';
 export { NonceTrackerSubprovider } from './subproviders/nonce_tracker';
 export { PrivateKeyWalletSubprovider } from './subproviders/private_key_wallet';
 export { MnemonicWalletSubprovider } from './subproviders/mnemonic_wallet';
+export { EthLightwalletSubprovider } from './subproviders/eth_lightwallet_subprovider';
 export {
     Callback,
     ErrorCallback,
     NextCallback,
     LedgerCommunicationClient,
+    LedgerEthereumClient,
     NonceSubproviderErrors,
     LedgerSubproviderConfigs,
 } from './types';
diff --git a/packages/subproviders/src/subproviders/eth_lightwallet_subprovider.ts b/packages/subproviders/src/subproviders/eth_lightwallet_subprovider.ts
new file mode 100644
index 000000000..a9ebbb790
--- /dev/null
+++ b/packages/subproviders/src/subproviders/eth_lightwallet_subprovider.ts
@@ -0,0 +1,68 @@
+import * as lightwallet from 'eth-lightwallet';
+
+import { PartialTxParams } from '../types';
+
+import { BaseWalletSubprovider } from './base_wallet_subprovider';
+import { PrivateKeyWalletSubprovider } from './private_key_wallet';
+
+/*
+ * This class implements the web3-provider-engine subprovider interface and forwards
+ * requests involving user accounts and signing operations to eth-lightwallet
+ *
+ * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
+ */
+export class EthLightwalletSubprovider extends BaseWalletSubprovider {
+    private _keystore: lightwallet.keystore;
+    private _pwDerivedKey: Uint8Array;
+    constructor(keystore: lightwallet.keystore, pwDerivedKey: Uint8Array) {
+        super();
+        this._keystore = keystore;
+        this._pwDerivedKey = pwDerivedKey;
+    }
+    /**
+     * Retrieve the accounts associated with the eth-lightwallet instance.
+     * 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[]> {
+        const accounts = this._keystore.getAddresses();
+        return accounts;
+    }
+    /**
+     * Signs a transaction with the account specificed by the `from` field in txParams.
+     * 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> {
+        // Lightwallet loses the chain id information when hex encoding the transaction
+        // this results in a different signature on certain networks. PrivateKeyWallet
+        // respects this as it uses the parameters passed in
+        let privKey = this._keystore.exportPrivateKey(txParams.from, this._pwDerivedKey);
+        const privKeyWallet = new PrivateKeyWalletSubprovider(privKey);
+        privKey = '';
+        const privKeySignature = await privKeyWallet.signTransactionAsync(txParams);
+        return privKeySignature;
+    }
+    /**
+     * Sign a personal Ethereum signed message. The signing account will be the account
+     * associated with the provided address.
+     * If you've added the MnemonicWalletSubprovider 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 Hex string message to sign
+     * @param address Address of the account to sign with
+     * @return Signature hex string (order: rsv)
+     */
+    public async signPersonalMessageAsync(data: string, address: string): Promise<string> {
+        let privKey = this._keystore.exportPrivateKey(address, this._pwDerivedKey);
+        const privKeyWallet = new PrivateKeyWalletSubprovider(privKey);
+        privKey = '';
+        const result = privKeyWallet.signPersonalMessageAsync(data, address);
+        return result;
+    }
+}
diff --git a/packages/subproviders/src/subproviders/injected_web3.ts b/packages/subproviders/src/subproviders/signer.ts
index 2691dec53..08a9daceb 100644
--- a/packages/subproviders/src/subproviders/injected_web3.ts
+++ b/packages/subproviders/src/subproviders/signer.ts
@@ -1,5 +1,5 @@
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { JSONRPCRequestPayload, Provider } from 'ethereum-types';
-import * as Web3 from 'web3';
 
 import { Callback, ErrorCallback } from '../types';
 
@@ -7,19 +7,19 @@ import { Subprovider } from './subprovider';
 
 /**
  * This class implements the [web3-provider-engine](https://github.com/MetaMask/provider-engine)
- * subprovider interface. It forwards JSON RPC requests involving user accounts (getAccounts,
- * sendTransaction, etc...) to the provider instance supplied at instantiation. All other requests
+ * subprovider interface. It forwards JSON RPC requests involving the domain of a signer (getAccounts,
+ * sendTransaction, signMessage etc...) to the provider instance supplied at instantiation. All other requests
  * are passed onwards for subsequent subproviders to handle.
  */
-export class InjectedWeb3Subprovider extends Subprovider {
-    private _injectedWeb3: Web3;
+export class SignerSubprovider extends Subprovider {
+    private _web3Wrapper: Web3Wrapper;
     /**
-     * Instantiates a new InjectedWeb3Subprovider
+     * Instantiates a new SignerSubprovider
      * @param provider Web3 provider that should handle  all user account related requests
      */
     constructor(provider: Provider) {
         super();
-        this._injectedWeb3 = new Web3(provider);
+        this._web3Wrapper = new Web3Wrapper(provider);
     }
     /**
      * This method conforms to the web3-provider-engine interface.
@@ -33,22 +33,39 @@ export class InjectedWeb3Subprovider extends Subprovider {
     public async handleRequest(payload: JSONRPCRequestPayload, next: Callback, end: ErrorCallback): Promise<void> {
         switch (payload.method) {
             case 'web3_clientVersion':
-                this._injectedWeb3.version.getNode(end);
+                try {
+                    const nodeVersion = await this._web3Wrapper.getNodeVersionAsync();
+                    end(null, nodeVersion);
+                } catch (err) {
+                    end(err);
+                }
                 return;
             case 'eth_accounts':
-                this._injectedWeb3.eth.getAccounts(end);
+                try {
+                    const accounts = await this._web3Wrapper.getAvailableAddressesAsync();
+                    end(null, accounts);
+                } catch (err) {
+                    end(err);
+                }
                 return;
-
             case 'eth_sendTransaction':
                 const [txParams] = payload.params;
-                this._injectedWeb3.eth.sendTransaction(txParams, end);
+                try {
+                    const txHash = await this._web3Wrapper.sendTransactionAsync(txParams);
+                    end(null, txHash);
+                } catch (err) {
+                    end(err);
+                }
                 return;
-
             case 'eth_sign':
                 const [address, message] = payload.params;
-                this._injectedWeb3.eth.sign(address, message, end);
+                try {
+                    const signature = await this._web3Wrapper.signMessageAsync(address, message);
+                    end(null, signature);
+                } catch (err) {
+                    end(err);
+                }
                 return;
-
             default:
                 next();
                 return;