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
  ...

4 files changed, 240 insertions, 5 deletions

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);