Add new underscore-privates rule to @0xproject/tslint-config and fix lint errors

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