Merge branch 'development' into fix/underscorePrivate

* development: (29 commits)
  Move call to error reporter to end of handler so that even if reporting the error takes a while, it doesn't block the UI
  Update outdated WETH ranges
  Fix conditional
  Fix top-padding
  Publish
  Update CHANGELOGs
  Add slashes to base URLs
  Fix linter issue
  Fix WETH symbol
  Update snapshot and artifacts
  Replace our EtherTokens with WETH9 from maker
  Fix test description
  Fix a typo
  Add err==null assertions
  Add WETH9 tests
  Use the new snapshot including WETH9 and it's artifacts
  Add WETH9 and mirations
  Fix WETH events watching
  Fix a typo
  Init the _etherTokenContractsByAddress
  ...

12 files changed, 427 insertions, 27 deletions

diff --git a/packages/0x.js/CHANGELOG.md b/packages/0x.js/CHANGELOG.md
index c69edd88c..d85ace89f 100644
--- a/packages/0x.js/CHANGELOG.md
+++ b/packages/0x.js/CHANGELOG.md
@@ -1,11 +1,15 @@
 # CHANGELOG
 
-v0.x.x - _TBD, 2017_
+v0.28.0 - _December 20, 2017_
 ------------------------
     * Add `etherTokenAddress` arg to `depositAsync` and `withdrawAsync` methods on `zeroEx.etherToken` (#267)
     * Removed accidentally included `unsubscribeAll` method from `zeroEx.proxy`, `zeroEx.etherToken` and `zeroEx.tokenRegistry` (#267)
     * Removed `etherTokenContractAddress` from `ZeroEx` constructor arg `ZeroExConfig` (#267)
     * Rename `SubscriptionOpts` to `BlockRange` (#272)
+    * Add `zeroEx.etherToken.subscribe`, `zeroEx.etherToken.unsubscribe`, `zeroEx.etherToken.unsubscribeAll` (#277)
+    * Add `zeroEx.etherToken.getLogsAsync` (#277)
+    * Add new public types `BlockParamLiteral`, `EtherTokenEvents`, `EtherTokenContractEventArgs`, `DepositContractEventArgs`, `WithdrawalContractEventArgs` (#277)
+    * Support `Deposit` and `Withdraw` events on etherToken (#277)
     * Improve the error message when taker is not a string (#278)
 
 v0.27.1 - _November 28, 2017_
diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json
index fcb08646a..145bbff16 100644
--- a/packages/0x.js/package.json
+++ b/packages/0x.js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "0x.js",
-  "version": "0.27.2",
+  "version": "0.28.0",
   "description": "A javascript library for interacting with the 0x protocol",
   "keywords": [
     "0x.js",
@@ -45,10 +45,10 @@
     "node": ">=6.0.0"
   },
   "devDependencies": {
-    "@0xproject/abi-gen": "^0.0.2",
-    "@0xproject/tslint-config": "^0.2.1",
-    "@0xproject/types": "^0.1.0",
-    "@0xproject/dev-utils": "^0.0.1",
+    "@0xproject/abi-gen": "^0.0.3",
+    "@0xproject/dev-utils": "^0.0.2",
+    "@0xproject/tslint-config": "^0.3.0",
+    "@0xproject/types": "^0.1.1",
     "@types/bintrees": "^1.0.2",
     "@types/jsonschema": "^1.1.1",
     "@types/lodash": "^4.14.86",
@@ -84,10 +84,10 @@
     "webpack": "^3.1.0"
   },
   "dependencies": {
-    "@0xproject/assert": "^0.0.7",
-    "@0xproject/json-schemas": "^0.6.10",
-    "@0xproject/utils": "^0.1.0",
-    "@0xproject/web3-wrapper": "^0.1.0",
+    "@0xproject/assert": "^0.0.8",
+    "@0xproject/json-schemas": "^0.7.0",
+    "@0xproject/utils": "^0.1.1",
+    "@0xproject/web3-wrapper": "^0.1.1",
     "bignumber.js": "~4.1.0",
     "bintrees": "^1.0.2",
     "bn.js": "^4.11.8",
diff --git a/packages/0x.js/src/0x.ts b/packages/0x.js/src/0x.ts
index e4965f9a2..7393cc814 100644
--- a/packages/0x.js/src/0x.ts
+++ b/packages/0x.js/src/0x.ts
@@ -201,7 +201,7 @@ export class ZeroEx {
             this._web3Wrapper, config.networkId, config.tokenRegistryContractAddress,
         );
         this.etherToken = new EtherTokenWrapper(
-            this._web3Wrapper, config.networkId, this.token,
+            this._web3Wrapper, config.networkId, this._abiDecoder, this.token,
         );
         this.orderStateWatcher = new OrderStateWatcher(
             this._web3Wrapper, this._abiDecoder, this.token, this.exchange, config.orderWatcherConfig,
diff --git a/packages/0x.js/src/artifacts/EtherToken.json b/packages/0x.js/src/artifacts/EtherToken.json
index de6946cf2..1105af3b0 100644
--- a/packages/0x.js/src/artifacts/EtherToken.json
+++ b/packages/0x.js/src/artifacts/EtherToken.json
@@ -231,17 +231,51 @@
       ],
       "name": "Approval",
       "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "name": "_owner",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "name": "_value",
+          "type": "uint256"
+        }
+      ],
+      "name": "Deposit",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "name": "_owner",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "name": "_value",
+          "type": "uint256"
+        }
+      ],
+      "name": "Withdrawal",
+      "type": "event"
     }
   ],
   "networks": {
     "1": {
-      "address": "0x2956356cd2a2bf3202f771f50d3d14a367b48070"
+      "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
     },
     "3": {
       "address": "0xc00fd9820cd2898cc4c054b7bf142de637ad129a"
     },
     "42": {
-      "address": "0x05d090b51c40b020eab3bfcb6a2dff130df22e9c"
+      "address": "0x653e49e301e508a13237c0ddc98ae7d4cd2667a1"
     },
     "50": {
       "address": "0x871dd7c2b4b25e1aa18728e9d5f2af4c4e431f5c"
diff --git a/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts b/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts
index a6acbe45d..969f30463 100644
--- a/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts
+++ b/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts
@@ -1,9 +1,20 @@
+import {schemas} from '@0xproject/json-schemas';
 import {Web3Wrapper} from '@0xproject/web3-wrapper';
 import BigNumber from 'bignumber.js';
 import * as _ from 'lodash';
 
 import {artifacts} from '../artifacts';
-import {TransactionOpts, ZeroExError} from '../types';
+import {
+    BlockRange,
+    EtherTokenContractEventArgs,
+    EtherTokenEvents,
+    EventCallback,
+    IndexedFilterValues,
+    LogWithDecodedArgs,
+    TransactionOpts,
+    ZeroExError,
+} from '../types';
+import {AbiDecoder} from '../utils/abi_decoder';
 import {assert} from '../utils/assert';
 
 import {ContractWrapper} from './contract_wrapper';
@@ -15,10 +26,10 @@ import {TokenWrapper} from './token_wrapper';
  * The caller can convert ETH into the equivalent number of wrapped ETH ERC20 tokens and back.
  */
 export class EtherTokenWrapper extends ContractWrapper {
-    private _etherTokenContractIfExists?: EtherTokenContract;
+    private _etherTokenContractsByAddress: {[address: string]: EtherTokenContract} = {};
     private _tokenWrapper: TokenWrapper;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenWrapper: TokenWrapper) {
-        super(web3Wrapper, networkId);
+    constructor(web3Wrapper: Web3Wrapper, networkId: number, abiDecoder: AbiDecoder, tokenWrapper: TokenWrapper) {
+        super(web3Wrapper, networkId, abiDecoder);
         this._tokenWrapper = tokenWrapper;
     }
     /**
@@ -75,15 +86,76 @@ export class EtherTokenWrapper extends ContractWrapper {
         });
         return txHash;
     }
+    /**
+     * Gets historical logs without creating a subscription
+     * @param   etherTokenAddress   An address of the ether token that emmited the logs.
+     * @param   eventName           The ether token contract event you would like to subscribe to.
+     * @param   blockRange          Block range to get logs from.
+     * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
+     *                              the value is the value you are interested in. E.g `{_owner: aUserAddressHex}`
+     * @return  Array of logs that match the parameters
+     */
+    public async getLogsAsync<ArgsType extends EtherTokenContractEventArgs>(
+        etherTokenAddress: string, eventName: EtherTokenEvents, blockRange: BlockRange,
+        indexFilterValues: IndexedFilterValues): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+        assert.doesBelongToStringEnum('eventName', eventName, EtherTokenEvents);
+        assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
+        assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+        const logs = await this._getLogsAsync<ArgsType>(
+            etherTokenAddress, eventName, blockRange, indexFilterValues, artifacts.EtherTokenArtifact.abi,
+        );
+        return logs;
+    }
+    /**
+     * Subscribe to an event type emitted by the Token contract.
+     * @param   etherTokenAddress   The hex encoded address where the ether token is deployed.
+     * @param   eventName           The ether token contract event you would like to subscribe to.
+     * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
+     *                              the value is the value you are interested in. E.g `{_owner: aUserAddressHex}`
+     * @param   callback            Callback that gets called when a log is added/removed
+     * @return Subscription token used later to unsubscribe
+     */
+    public subscribe<ArgsType extends EtherTokenContractEventArgs>(
+        etherTokenAddress: string, eventName: EtherTokenEvents, indexFilterValues: IndexedFilterValues,
+        callback: EventCallback<ArgsType>): string {
+        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+        assert.doesBelongToStringEnum('eventName', eventName, EtherTokenEvents);
+        assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+        assert.isFunction('callback', callback);
+        const subscriptionToken = this._subscribe<ArgsType>(
+            etherTokenAddress, eventName, indexFilterValues, artifacts.EtherTokenArtifact.abi, callback,
+        );
+        return subscriptionToken;
+    }
+    /**
+     * Cancel a subscription
+     * @param   subscriptionToken Subscription token returned by `subscribe()`
+     */
+    public unsubscribe(subscriptionToken: string): void {
+        this._unsubscribe(subscriptionToken);
+    }
+    /**
+     * Cancels all existing subscriptions
+     */
+    public unsubscribeAll(): void {
+        super.unsubscribeAll();
+    }
     private _invalidateContractInstance(): void {
-        delete this._etherTokenContractIfExists;
+        this.unsubscribeAll();
+        this._etherTokenContractsByAddress = {};
     }
     private async _getEtherTokenContractAsync(etherTokenAddress: string): Promise<EtherTokenContract> {
+        let etherTokenContract = this._etherTokenContractsByAddress[etherTokenAddress];
+        if (!_.isUndefined(etherTokenContract)) {
+            return etherTokenContract;
+        }
         const web3ContractInstance = await this._instantiateContractIfExistsAsync(
             artifacts.EtherTokenArtifact, etherTokenAddress,
         );
         const contractInstance = new EtherTokenContract(web3ContractInstance, this._web3Wrapper.getContractDefaults());
-        this._etherTokenContractIfExists = contractInstance;
-        return this._etherTokenContractIfExists;
+        etherTokenContract = contractInstance;
+        this._etherTokenContractsByAddress[etherTokenAddress] = etherTokenContract;
+        return etherTokenContract;
     }
 }
diff --git a/packages/0x.js/src/index.ts b/packages/0x.js/src/index.ts
index b75ca4fa3..da06aad34 100644
--- a/packages/0x.js/src/index.ts
+++ b/packages/0x.js/src/index.ts
@@ -2,6 +2,7 @@ export {ZeroEx} from './0x';
 
 export {
     Order,
+    BlockParamLiteral,
     SignedOrder,
     ECSignature,
     ZeroExError,
@@ -23,10 +24,14 @@ export {
     TransferContractEventArgs,
     ApprovalContractEventArgs,
     TokenContractEventArgs,
+    EtherTokenContractEventArgs,
+    WithdrawalContractEventArgs,
+    DepositContractEventArgs,
     ContractEventArgs,
     ContractEventArg,
     Web3Provider,
     ZeroExConfig,
+    EtherTokenEvents,
     TransactionReceiptWithDecodedLogs,
     LogWithDecodedArgs,
     MethodOpts,
diff --git a/packages/0x.js/src/order_watcher/order_state_watcher.ts b/packages/0x.js/src/order_watcher/order_state_watcher.ts
index bba01eb43..b093ba52c 100644
--- a/packages/0x.js/src/order_watcher/order_state_watcher.ts
+++ b/packages/0x.js/src/order_watcher/order_state_watcher.ts
@@ -12,6 +12,8 @@ import {
     ApprovalContractEventArgs,
     BlockParamLiteral,
     ContractEventArgs,
+    DepositContractEventArgs,
+    EtherTokenEvents,
     ExchangeContractErrs,
     ExchangeEvents,
     LogCancelContractEventArgs,
@@ -24,6 +26,7 @@ import {
     SignedOrder,
     TokenEvents,
     TransferContractEventArgs,
+    WithdrawalContractEventArgs,
     ZeroExError,
 } from '../types';
 import {AbiDecoder} from '../utils/abi_decoder';
@@ -243,6 +246,36 @@ export class OrderStateWatcher {
                 }
                 break;
             }
+            case EtherTokenEvents.Deposit:
+            {
+                // Invalidate cache
+                const args = decodedLog.args as DepositContractEventArgs;
+                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._owner);
+                // Revalidate orders
+                makerToken = decodedLog.address;
+                makerAddress = args._owner;
+                if (!_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
+                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])) {
+                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
+                    await this._emitRevalidateOrdersAsync(orderHashes);
+                }
+                break;
+            }
+            case EtherTokenEvents.Withdrawal:
+            {
+                // Invalidate cache
+                const args = decodedLog.args as WithdrawalContractEventArgs;
+                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._owner);
+                // Revalidate orders
+                makerToken = decodedLog.address;
+                makerAddress = args._owner;
+                if (!_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
+                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])) {
+                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
+                    await this._emitRevalidateOrdersAsync(orderHashes);
+                }
+                break;
+            }
             case ExchangeEvents.LogFill:
             {
                 // Invalidate cache
diff --git a/packages/0x.js/src/types.ts b/packages/0x.js/src/types.ts
index 704e59ce5..e6a2c05d0 100644
--- a/packages/0x.js/src/types.ts
+++ b/packages/0x.js/src/types.ts
@@ -28,6 +28,7 @@ export enum ZeroExError {
 export enum InternalZeroExError {
     NoAbiDecoder = 'NO_ABI_DECODER',
     ZrxNotInTokenRegistry = 'ZRX_NOT_IN_TOKEN_REGISTRY',
+    WethNotInTokenRegistry = 'WETH_NOT_IN_TOKEN_REGISTRY',
 }
 
 /**
@@ -146,8 +147,17 @@ export interface ApprovalContractEventArgs {
     _spender: string;
     _value: BigNumber;
 }
+export interface DepositContractEventArgs {
+    _owner: string;
+    _value: BigNumber;
+}
+export interface WithdrawalContractEventArgs {
+    _owner: string;
+    _value: BigNumber;
+}
 export type TokenContractEventArgs = TransferContractEventArgs|ApprovalContractEventArgs;
-export type ContractEventArgs = ExchangeContractEventArgs|TokenContractEventArgs;
+export type EtherTokenContractEventArgs = TokenContractEventArgs|DepositContractEventArgs|WithdrawalContractEventArgs;
+export type ContractEventArgs = ExchangeContractEventArgs|TokenContractEventArgs|EtherTokenContractEventArgs;
 export type ContractEventArg = string|BigNumber;
 
 export interface Order {
@@ -201,7 +211,14 @@ export enum TokenEvents {
     Approval = 'Approval',
 }
 
-export type ContractEvents = TokenEvents|ExchangeEvents;
+export enum EtherTokenEvents  {
+    Transfer = 'Transfer',
+    Approval = 'Approval',
+    Deposit = 'Deposit',
+    Withdrawal = 'Withdrawal',
+}
+
+export type ContractEvents = TokenEvents|ExchangeEvents|EtherTokenEvents;
 
 export interface IndexedFilterValues {
     [index: string]: ContractEventArg;
diff --git a/packages/0x.js/test/ether_token_wrapper_test.ts b/packages/0x.js/test/ether_token_wrapper_test.ts
index b5ed19308..4fcb37409 100644
--- a/packages/0x.js/test/ether_token_wrapper_test.ts
+++ b/packages/0x.js/test/ether_token_wrapper_test.ts
@@ -4,11 +4,25 @@ import * as chai from 'chai';
 import 'mocha';
 import * as Web3 from 'web3';
 
-import {ZeroEx, ZeroExError} from '../src';
+import {
+    ApprovalContractEventArgs,
+    BlockParamLiteral,
+    BlockRange,
+    DecodedLogEvent,
+    DepositContractEventArgs,
+    EtherTokenEvents,
+    Token,
+    TransferContractEventArgs,
+    WithdrawalContractEventArgs,
+    ZeroEx,
+    ZeroExError,
+} from '../src';
 import {artifacts} from '../src/artifacts';
+import {DoneCallback} from '../src/types';
 
 import {chaiSetup} from './utils/chai_setup';
 import {constants} from './utils/constants';
+import {TokenUtils} from './utils/token_utils';
 import {web3Factory} from './utils/web3_factory';
 
 chaiSetup.configure();
@@ -24,24 +38,32 @@ const MAX_REASONABLE_GAS_COST_IN_WEI = 62517;
 describe('EtherTokenWrapper', () => {
     let web3: Web3;
     let zeroEx: ZeroEx;
+    let tokens: Token[];
     let userAddresses: string[];
     let addressWithETH: string;
     let wethContractAddress: string;
     let depositWeiAmount: BigNumber;
     let decimalPlaces: number;
+    let addressWithoutFunds: string;
     const gasPrice = new BigNumber(1);
     const zeroExConfig = {
         gasPrice,
         networkId: constants.TESTRPC_NETWORK_ID,
     };
+    const transferAmount = new BigNumber(42);
+    const allowanceAmount = new BigNumber(42);
+    const depositAmount = new BigNumber(42);
+    const withdrawalAmount = new BigNumber(42);
     before(async () => {
         web3 = web3Factory.create();
         zeroEx = new ZeroEx(web3.currentProvider, zeroExConfig);
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         addressWithETH = userAddresses[0];
         wethContractAddress = (zeroEx.etherToken as any)._getContractAddress(artifacts.EtherTokenArtifact);
         depositWeiAmount = (zeroEx as any)._web3Wrapper.toWei(new BigNumber(5));
         decimalPlaces = 7;
+        addressWithoutFunds = userAddresses[1];
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -113,4 +135,209 @@ describe('EtherTokenWrapper', () => {
             ).to.be.rejectedWith(ZeroExError.InsufficientWEthBalanceForWithdrawal);
         });
     });
+    describe('#subscribe', () => {
+        const indexFilterValues = {};
+        let etherTokenAddress: string;
+        before(() => {
+            const tokenUtils = new TokenUtils(tokens);
+            const etherToken = tokenUtils.getWethTokenOrThrow();
+            etherTokenAddress = etherToken.address;
+        });
+        afterEach(() => {
+            zeroEx.etherToken.unsubscribeAll();
+        });
+        // Hack: Mocha does not allow a test to be both async and have a `done` callback
+        // Since we need to await the receipt of the event in the `subscribe` callback,
+        // we do need both. A hack is to make the top-level async fn w/ a done callback and then
+        // wrap the rest of the test in an async block
+        // Source: https://github.com/mochajs/mocha/issues/2407
+        it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
+                    expect(err).to.be.null();
+                    expect(logEvent).to.not.be.undefined();
+                    expect(logEvent.isRemoved).to.be.false();
+                    expect(logEvent.log.logIndex).to.be.equal(0);
+                    expect(logEvent.log.transactionIndex).to.be.equal(0);
+                    expect(logEvent.log.blockNumber).to.be.a('number');
+                    const args = logEvent.log.args;
+                    expect(args._from).to.be.equal(addressWithETH);
+                    expect(args._to).to.be.equal(addressWithoutFunds);
+                    expect(args._value).to.be.bignumber.equal(transferAmount);
+                    done();
+                };
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callback);
+                await zeroEx.token.transferAsync(
+                    etherTokenAddress, addressWithETH, addressWithoutFunds, transferAmount,
+                );
+            })().catch(done);
+        });
+        it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    expect(err).to.be.null();
+                    expect(logEvent).to.not.be.undefined();
+                    expect(logEvent.isRemoved).to.be.false();
+                    const args = logEvent.log.args;
+                    expect(args._owner).to.be.equal(addressWithETH);
+                    expect(args._spender).to.be.equal(addressWithoutFunds);
+                    expect(args._value).to.be.bignumber.equal(allowanceAmount);
+                    done();
+                };
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Approval, indexFilterValues, callback);
+                await zeroEx.token.setAllowanceAsync(
+                    etherTokenAddress, addressWithETH, addressWithoutFunds, allowanceAmount,
+                );
+            })().catch(done);
+        });
+        it('Should receive the Deposit event when ether is being deposited', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<DepositContractEventArgs>) => {
+                    expect(err).to.be.null();
+                    expect(logEvent).to.not.be.undefined();
+                    expect(logEvent.isRemoved).to.be.false();
+                    const args = logEvent.log.args;
+                    expect(args._owner).to.be.equal(addressWithETH);
+                    expect(args._value).to.be.bignumber.equal(depositAmount);
+                    done();
+                };
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Deposit, indexFilterValues, callback);
+                await zeroEx.etherToken.depositAsync(
+                    etherTokenAddress, depositAmount, addressWithETH,
+                );
+            })().catch(done);
+        });
+        it('Should receive the Withdrawal event when ether is being withdrawn', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<WithdrawalContractEventArgs>) => {
+                    expect(err).to.be.null();
+                    expect(logEvent).to.not.be.undefined();
+                    expect(logEvent.isRemoved).to.be.false();
+                    const args = logEvent.log.args;
+                    expect(args._owner).to.be.equal(addressWithETH);
+                    expect(args._value).to.be.bignumber.equal(depositAmount);
+                    done();
+                };
+                await zeroEx.etherToken.depositAsync(
+                    etherTokenAddress, depositAmount, addressWithETH,
+                );
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Withdrawal, indexFilterValues, callback);
+                await zeroEx.etherToken.withdrawAsync(
+                    etherTokenAddress, withdrawalAmount, addressWithETH,
+                );
+            })().catch(done);
+        });
+        it('should cancel outstanding subscriptions when ZeroEx.setProvider is called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    done(new Error('Expected this subscription to have been cancelled'));
+                };
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled,
+                );
+                const callbackToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    done();
+                };
+                const newProvider = web3Factory.getRpcProvider();
+                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callbackToBeCalled,
+                );
+                await zeroEx.token.transferAsync(
+                    etherTokenAddress, addressWithETH, addressWithoutFunds, transferAmount,
+                );
+            })().catch(done);
+        });
+        it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    done(new Error('Expected this subscription to have been cancelled'));
+                };
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                const subscriptionToken = zeroEx.etherToken.subscribe(
+                    etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
+                zeroEx.etherToken.unsubscribe(subscriptionToken);
+                await zeroEx.token.transferAsync(
+                    etherTokenAddress, addressWithETH, addressWithoutFunds, transferAmount,
+                );
+                done();
+            })().catch(done);
+        });
+    });
+    describe('#getLogsAsync', () => {
+        let etherTokenAddress: string;
+        let tokenTransferProxyAddress: string;
+        const blockRange: BlockRange = {
+            fromBlock: 0,
+            toBlock: BlockParamLiteral.Latest,
+        };
+        let txHash: string;
+        before(() => {
+            addressWithETH = userAddresses[0];
+            const tokenUtils = new TokenUtils(tokens);
+            const etherToken = tokenUtils.getWethTokenOrThrow();
+            etherTokenAddress = etherToken.address;
+            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
+        });
+        it('should get logs with decoded args emitted by Approval', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = EtherTokenEvents.Approval;
+            const indexFilterValues = {};
+            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
+                etherTokenAddress, eventName, blockRange, indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(logs[0].event).to.be.equal(eventName);
+            expect(args._owner).to.be.equal(addressWithETH);
+            expect(args._spender).to.be.equal(tokenTransferProxyAddress);
+            expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+        it('should get logs with decoded args emitted by Deposit', async () => {
+            await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+            const eventName = EtherTokenEvents.Deposit;
+            const indexFilterValues = {};
+            const logs = await zeroEx.etherToken.getLogsAsync<DepositContractEventArgs>(
+                etherTokenAddress, eventName, blockRange, indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(logs[0].event).to.be.equal(eventName);
+            expect(args._owner).to.be.equal(addressWithETH);
+            expect(args._value).to.be.bignumber.equal(depositAmount);
+        });
+        it('should only get the logs with the correct event name', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const differentEventName = EtherTokenEvents.Transfer;
+            const indexFilterValues = {};
+            const logs = await zeroEx.etherToken.getLogsAsync(
+                etherTokenAddress, differentEventName, blockRange, indexFilterValues,
+            );
+            expect(logs).to.have.length(0);
+        });
+        it('should only get the logs with the correct indexed fields', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithoutFunds);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = EtherTokenEvents.Approval;
+            const indexFilterValues = {
+                _owner: addressWithETH,
+            };
+            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
+                etherTokenAddress, eventName, blockRange, indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(args._owner).to.be.equal(addressWithETH);
+        });
+    });
 });
diff --git a/packages/0x.js/test/token_wrapper_test.ts b/packages/0x.js/test/token_wrapper_test.ts
index 48742b663..a43cef675 100644
--- a/packages/0x.js/test/token_wrapper_test.ts
+++ b/packages/0x.js/test/token_wrapper_test.ts
@@ -7,6 +7,7 @@ import * as Web3 from 'web3';
 
 import {
     ApprovalContractEventArgs,
+    BlockParamLiteral,
     BlockRange,
     DecodedLogEvent,
     Token,
@@ -15,7 +16,7 @@ import {
     ZeroEx,
     ZeroExError,
 } from '../src';
-import {BlockParamLiteral, DoneCallback} from '../src/types';
+import {DoneCallback} from '../src/types';
 
 import {chaiSetup} from './utils/chai_setup';
 import {constants} from './utils/constants';
diff --git a/packages/0x.js/test/utils/constants.ts b/packages/0x.js/test/utils/constants.ts
index d486da581..7b6b2ee7b 100644
--- a/packages/0x.js/test/utils/constants.ts
+++ b/packages/0x.js/test/utils/constants.ts
@@ -1,11 +1,11 @@
 export const constants = {
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
-    RPC_URL: 'http://localhost:8545',
+    RPC_URL: 'http://localhost:8545/',
     ROPSTEN_NETWORK_ID: 3,
     KOVAN_NETWORK_ID: 42,
     TESTRPC_NETWORK_ID: 50,
-    KOVAN_RPC_URL: 'https://kovan.infura.io',
-    ROPSTEN_RPC_URL: 'https://ropsten.infura.io',
+    KOVAN_RPC_URL: 'https://kovan.infura.io/',
+    ROPSTEN_RPC_URL: 'https://ropsten.infura.io/',
     ZRX_DECIMALS: 18,
     GAS_ESTIMATE: 500000,
 };
diff --git a/packages/0x.js/test/utils/token_utils.ts b/packages/0x.js/test/utils/token_utils.ts
index bd66d81bf..e9a10d036 100644
--- a/packages/0x.js/test/utils/token_utils.ts
+++ b/packages/0x.js/test/utils/token_utils.ts
@@ -17,6 +17,13 @@ export class TokenUtils {
         }
         return zrxToken;
     }
+    public getWethTokenOrThrow(): Token {
+        const wethToken = _.find(this.tokens, {symbol: WETH_TOKEN_SYMBOL});
+        if (_.isUndefined(wethToken)) {
+            throw new Error(InternalZeroExError.WethNotInTokenRegistry);
+        }
+        return wethToken;
+    }
     public getDummyTokens(): Token[] {
         const dummyTokens = _.filter(this._tokens, token => {
             return !_.includes([PROTOCOL_TOKEN_SYMBOL, WETH_TOKEN_SYMBOL], token.symbol);