Merge branch 'development' into fix/docLinks

* development:
  Update and standardize contracts README
  Add to CHANGELOG
  Refactor toBaseUnitAmount so that it throws if user supplies unitAmount with too many decimals
  Make assertion stricter so that one cannot submit invalid baseUnit amounts to `toUnitAmount`
  Add some missed underscores, update changelog and comments
  Add new underscore-privates rule to @0xproject/tslint-config and fix lint errors

# Conflicts:
#	packages/website/ts/pages/documentation/documentation.tsx
#	packages/website/ts/pages/shared/nested_sidebar_menu.tsx

1 files changed, 39 insertions, 39 deletions

diff --git a/packages/web3-wrapper/src/index.ts b/packages/web3-wrapper/src/index.ts
index 7df24e9a5..dd94d683e 100644
--- a/packages/web3-wrapper/src/index.ts
+++ b/packages/web3-wrapper/src/index.ts
@@ -16,9 +16,9 @@ interface RawLogEntry {
 }
 
 export class Web3Wrapper {
-    private web3: Web3;
-    private defaults: Partial<TxData>;
-    private jsonRpcRequestId: number;
+    private _web3: Web3;
+    private _defaults: Partial<TxData>;
+    private _jsonRpcRequestId: number;
     constructor(provider: Web3.Provider, defaults?: Partial<TxData>) {
         if (_.isUndefined((provider as any).sendAsync)) {
             // Web3@1.0 provider doesn't support synchronous http requests,
@@ -26,69 +26,69 @@ export class Web3Wrapper {
             // We re-assign the send method so that Web3@1.0 providers work with 0x.js
             (provider as any).sendAsync = (provider as any).send;
         }
-        this.web3 = new Web3();
-        this.web3.setProvider(provider);
-        this.defaults = defaults || {};
-        this.jsonRpcRequestId = 0;
+        this._web3 = new Web3();
+        this._web3.setProvider(provider);
+        this._defaults = defaults || {};
+        this._jsonRpcRequestId = 0;
     }
     public getContractDefaults(): Partial<TxData> {
-        return this.defaults;
+        return this._defaults;
     }
     public setProvider(provider: Web3.Provider, networkId: number) {
-        this.web3.setProvider(provider);
+        this._web3.setProvider(provider);
     }
     public isAddress(address: string): boolean {
-        return this.web3.isAddress(address);
+        return this._web3.isAddress(address);
     }
     public async isSenderAddressAvailableAsync(senderAddress: string): Promise<boolean> {
         const addresses = await this.getAvailableAddressesAsync();
         return _.includes(addresses, senderAddress);
     }
     public async getNodeVersionAsync(): Promise<string> {
-        const nodeVersion = await promisify<string>(this.web3.version.getNode)();
+        const nodeVersion = await promisify<string>(this._web3.version.getNode)();
         return nodeVersion;
     }
     public async getNetworkIdAsync(): Promise<number> {
-        const networkIdStr = await promisify<string>(this.web3.version.getNetwork)();
+        const networkIdStr = await promisify<string>(this._web3.version.getNetwork)();
         const networkId = _.parseInt(networkIdStr);
         return networkId;
     }
     public async getTransactionReceiptAsync(txHash: string): Promise<TransactionReceipt> {
-        const transactionReceipt = await promisify<TransactionReceipt>(this.web3.eth.getTransactionReceipt)(txHash);
+        const transactionReceipt = await promisify<TransactionReceipt>(this._web3.eth.getTransactionReceipt)(txHash);
         if (!_.isNull(transactionReceipt)) {
-            transactionReceipt.status = this.normalizeTxReceiptStatus(transactionReceipt.status);
+            transactionReceipt.status = this._normalizeTxReceiptStatus(transactionReceipt.status);
         }
         return transactionReceipt;
     }
     public getCurrentProvider(): Web3.Provider {
-        return this.web3.currentProvider;
+        return this._web3.currentProvider;
     }
     public toWei(ethAmount: BigNumber): BigNumber {
-        const balanceWei = this.web3.toWei(ethAmount, 'ether');
+        const balanceWei = this._web3.toWei(ethAmount, 'ether');
         return balanceWei;
     }
     public async getBalanceInWeiAsync(owner: string): Promise<BigNumber> {
-        let balanceInWei = await promisify<BigNumber>(this.web3.eth.getBalance)(owner);
+        let balanceInWei = await promisify<BigNumber>(this._web3.eth.getBalance)(owner);
         // Rewrap in a new BigNumber
         balanceInWei = new BigNumber(balanceInWei);
         return balanceInWei;
     }
     public async doesContractExistAtAddressAsync(address: string): Promise<boolean> {
-        const code = await promisify<string>(this.web3.eth.getCode)(address);
+        const code = await promisify<string>(this._web3.eth.getCode)(address);
         // Regex matches 0x0, 0x00, 0x in order to accommodate poorly implemented clients
         const codeIsEmpty = /^0x0{0,40}$/i.test(code);
         return !codeIsEmpty;
     }
     public async signTransactionAsync(address: string, message: string): Promise<string> {
-        const signData = await promisify<string>(this.web3.eth.sign)(address, message);
+        const signData = await promisify<string>(this._web3.eth.sign)(address, message);
         return signData;
     }
     public async getBlockNumberAsync(): Promise<number> {
-        const blockNumber = await promisify<number>(this.web3.eth.getBlockNumber)();
+        const blockNumber = await promisify<number>(this._web3.eth.getBlockNumber)();
         return blockNumber;
     }
     public async getBlockAsync(blockParam: string|Web3.BlockParam): Promise<Web3.BlockWithoutTransactionData> {
-        const block = await promisify<Web3.BlockWithoutTransactionData>(this.web3.eth.getBlock)(blockParam);
+        const block = await promisify<Web3.BlockWithoutTransactionData>(this._web3.eth.getBlock)(blockParam);
         return block;
     }
     public async getBlockTimestampAsync(blockParam: string|Web3.BlockParam): Promise<number> {
@@ -96,17 +96,17 @@ export class Web3Wrapper {
         return timestamp;
     }
     public async getAvailableAddressesAsync(): Promise<string[]> {
-        const addresses = await promisify<string[]>(this.web3.eth.getAccounts)();
+        const addresses = await promisify<string[]>(this._web3.eth.getAccounts)();
         return addresses;
     }
     public async getLogsAsync(filter: Web3.FilterObject): Promise<Web3.LogEntry[]> {
         let fromBlock = filter.fromBlock;
         if (_.isNumber(fromBlock)) {
-            fromBlock = this.web3.toHex(fromBlock);
+            fromBlock = this._web3.toHex(fromBlock);
         }
         let toBlock = filter.toBlock;
         if (_.isNumber(toBlock)) {
-            toBlock = this.web3.toHex(toBlock);
+            toBlock = this._web3.toHex(toBlock);
         }
         const serializedFilter = {
             ...filter,
@@ -115,16 +115,16 @@ export class Web3Wrapper {
         };
         const payload = {
             jsonrpc: '2.0',
-            id: this.jsonRpcRequestId++,
+            id: this._jsonRpcRequestId++,
             method: 'eth_getLogs',
             params: [serializedFilter],
         };
-        const rawLogs = await this.sendRawPayloadAsync<RawLogEntry[]>(payload);
-        const formattedLogs = _.map(rawLogs, this.formatLog.bind(this));
+        const rawLogs = await this._sendRawPayloadAsync<RawLogEntry[]>(payload);
+        const formattedLogs = _.map(rawLogs, this._formatLog.bind(this));
         return formattedLogs;
     }
     public getContractFromAbi(abi: Web3.ContractAbi): Web3.Contract<any> {
-        const web3Contract = this.web3.eth.contract(abi);
+        const web3Contract = this._web3.eth.contract(abi);
         return web3Contract;
     }
     public getContractInstance(abi: Web3.ContractAbi, address: string): Web3.ContractInstance {
@@ -132,43 +132,43 @@ export class Web3Wrapper {
         return web3ContractInstance;
     }
     public async estimateGasAsync(data: string): Promise<number> {
-        const gas = await promisify<number>(this.web3.eth.estimateGas)({data});
+        const gas = await promisify<number>(this._web3.eth.estimateGas)({data});
         return gas;
     }
-    private async sendRawPayloadAsync<A>(payload: Web3.JSONRPCRequestPayload): Promise<A> {
-        const sendAsync = this.web3.currentProvider.sendAsync.bind(this.web3.currentProvider);
+    private async _sendRawPayloadAsync<A>(payload: Web3.JSONRPCRequestPayload): Promise<A> {
+        const sendAsync = this._web3.currentProvider.sendAsync.bind(this._web3.currentProvider);
         const response = await promisify<Web3.JSONRPCResponsePayload>(sendAsync)(payload);
         const result = response.result;
         return result;
     }
-    private normalizeTxReceiptStatus(status: undefined|null|string|0|1): null|0|1 {
+    private _normalizeTxReceiptStatus(status: undefined|null|string|0|1): null|0|1 {
         // Transaction status might have four values
         // undefined - Testrpc and other old clients
         // null - New clients on old transactions
         // number - Parity
         // hex - Geth
         if (_.isString(status)) {
-            return this.web3.toDecimal(status) as 0|1;
+            return this._web3.toDecimal(status) as 0|1;
         } else if (_.isUndefined(status)) {
             return null;
         } else {
             return status;
         }
     }
-    private formatLog(rawLog: RawLogEntry): Web3.LogEntry {
+    private _formatLog(rawLog: RawLogEntry): Web3.LogEntry {
         const formattedLog = {
             ...rawLog,
-            logIndex: this.hexToDecimal(rawLog.logIndex),
-            blockNumber: this.hexToDecimal(rawLog.blockNumber),
-            transactionIndex: this.hexToDecimal(rawLog.transactionIndex),
+            logIndex: this._hexToDecimal(rawLog.logIndex),
+            blockNumber: this._hexToDecimal(rawLog.blockNumber),
+            transactionIndex: this._hexToDecimal(rawLog.transactionIndex),
         };
         return formattedLog;
     }
-    private hexToDecimal(hex: string|null): number|null {
+    private _hexToDecimal(hex: string|null): number|null {
         if (_.isNull(hex)) {
             return null;
         }
-        const decimal = this.web3.toDecimal(hex);
+        const decimal = this._web3.toDecimal(hex);
         return decimal;
     }
 }