crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Brandon Millman
2017-12-20 00:44:08 -05:00
committed by Leonid Logvinov
parent 972e1675f6
commit cb11aec84d
93 changed files with 1418 additions and 1345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
packages/contracts/deploy/src/compiler.ts
View File

@@ -19,18 +19,18 @@ import {utils} from './utils/utils';
const SOLIDITY_FILE_EXTENSION = '.sol';
export class Compiler {
private contractsDir: string;
private networkId: number;
private optimizerEnabled: number;
private artifactsDir: string;
private contractSourcesIfExists?: ContractSources;
private solcErrors: Set<string>;
private _contractsDir: string;
private _networkId: number;
private _optimizerEnabled: number;
private _artifactsDir: string;
private _contractSourcesIfExists?: ContractSources;
private _solcErrors: Set<string>;
/**
* Recursively retrieves Solidity source code from directory.
* @param dirPath Directory to search.
* @return Mapping of contract name to contract source.
*/
private static async getContractSourcesAsync(dirPath: string): Promise<ContractSources> {
private static async _getContractSourcesAsync(dirPath: string): Promise<ContractSources> {
let dirContents: string[] = [];
try {
dirContents = await fsWrapper.readdirAsync(dirPath);
@@ -52,7 +52,7 @@ export class Compiler {
}
} else {
try {
const nestedSources = await Compiler.getContractSourcesAsync(contentPath);
const nestedSources = await Compiler._getContractSourcesAsync(contentPath);
sources = {
...sources,
...nestedSources,
@@ -69,7 +69,7 @@ export class Compiler {
* @param source Source code of contract.
* @return Solc compiler version.
*/
private static parseSolidityVersion(source: string): string {
private static _parseSolidityVersion(source: string): string {
const solcVersionMatch = source.match(/(?:solidity\s\^?)([0-9]{1,2}[.][0-9]{1,2}[.][0-9]{1,2})/);
if (_.isNull(solcVersionMatch)) {
throw new Error('Could not find Solidity version in source');
@@ -85,7 +85,7 @@ export class Compiler {
* @param errMsg An error message from the compiled output.
* @return The error message with directories truncated from the contract path.
*/
private static getNormalizedErrMsg(errMsg: string): string {
private static _getNormalizedErrMsg(errMsg: string): string {
const errPathMatch = errMsg.match(/(.*\.sol)/);
if (_.isNull(errPathMatch)) {
throw new Error('Could not find a path in error message');
@@ -101,26 +101,26 @@ export class Compiler {
* @return An instance of the Compiler class.
*/
constructor(opts: CompilerOptions) {
this.contractsDir = opts.contractsDir;
this.networkId = opts.networkId;
this.optimizerEnabled = opts.optimizerEnabled;
this.artifactsDir = opts.artifactsDir;
this.solcErrors = new Set();
this._contractsDir = opts.contractsDir;
this._networkId = opts.networkId;
this._optimizerEnabled = opts.optimizerEnabled;
this._artifactsDir = opts.artifactsDir;
this._solcErrors = new Set();
}
/**
* Compiles all Solidity files found in contractsDir and writes JSON artifacts to artifactsDir.
*/
public async compileAllAsync(): Promise<void> {
await this.createArtifactsDirIfDoesNotExistAsync();
this.contractSourcesIfExists = await Compiler.getContractSourcesAsync(this.contractsDir);
await this._createArtifactsDirIfDoesNotExistAsync();
this._contractSourcesIfExists = await Compiler._getContractSourcesAsync(this._contractsDir);
const contractBaseNames = _.keys(this.contractSourcesIfExists);
const contractBaseNames = _.keys(this._contractSourcesIfExists);
const compiledContractPromises = _.map(contractBaseNames, async (contractBaseName: string): Promise<void> => {
return this.compileContractAsync(contractBaseName);
return this._compileContractAsync(contractBaseName);
});
await Promise.all(compiledContractPromises);
this.solcErrors.forEach(errMsg => {
this._solcErrors.forEach(errMsg => {
utils.consoleLog(errMsg);
});
}
@@ -128,14 +128,14 @@ export class Compiler {
* Compiles contract and saves artifact to artifactsDir.
* @param contractBaseName Name of contract with '.sol' extension.
*/
private async compileContractAsync(contractBaseName: string): Promise<void> {
if (_.isUndefined(this.contractSourcesIfExists)) {
private async _compileContractAsync(contractBaseName: string): Promise<void> {
if (_.isUndefined(this._contractSourcesIfExists)) {
throw new Error('Contract sources not yet initialized');
}
const source = this.contractSourcesIfExists[contractBaseName];
const source = this._contractSourcesIfExists[contractBaseName];
const contractName = path.basename(contractBaseName, SOLIDITY_FILE_EXTENSION);
const currentArtifactPath = `${this.artifactsDir}/${contractName}.json`;
const currentArtifactPath = `${this._artifactsDir}/${contractName}.json`;
const sourceHash = `0x${ethUtil.sha3(source).toString('hex')}`;
let currentArtifactString: string;
@@ -149,10 +149,10 @@ export class Compiler {
currentArtifactString = await fsWrapper.readFileAsync(currentArtifactPath, opts);
currentArtifact = JSON.parse(currentArtifactString);
oldNetworks = currentArtifact.networks;
const oldNetwork: ContractData = oldNetworks[this.networkId];
const oldNetwork: ContractData = oldNetworks[this._networkId];
shouldCompile = _.isUndefined(oldNetwork) ||
oldNetwork.keccak256 !== sourceHash ||
oldNetwork.optimizer_enabled !== this.optimizerEnabled;
oldNetwork.optimizer_enabled !== this._optimizerEnabled;
} catch (err) {
shouldCompile = true;
}
@@ -164,7 +164,7 @@ export class Compiler {
const input = {
[contractBaseName]: source,
};
const solcVersion = Compiler.parseSolidityVersion(source);
const solcVersion = Compiler._parseSolidityVersion(source);
const fullSolcVersion = binPaths[solcVersion];
const solcBinPath = `./../solc/solc_bin/${fullSolcVersion}`;
const solcBin = require(solcBinPath);
@@ -175,13 +175,13 @@ export class Compiler {
sources: input,
};
const compiled = solcInstance.compile(sourcesToCompile,
this.optimizerEnabled,
this.findImportsIfSourcesExist.bind(this));
this._optimizerEnabled,
this._findImportsIfSourcesExist.bind(this));
if (!_.isUndefined(compiled.errors)) {
_.each(compiled.errors, errMsg => {
const normalizedErrMsg = Compiler.getNormalizedErrMsg(errMsg);
this.solcErrors.add(normalizedErrMsg);
const normalizedErrMsg = Compiler._getNormalizedErrMsg(errMsg);
this._solcErrors.add(normalizedErrMsg);
});
}
@@ -192,7 +192,7 @@ export class Compiler {
const contractData: ContractData = {
solc_version: solcVersion,
keccak256: sourceHash,
optimizer_enabled: this.optimizerEnabled,
optimizer_enabled: this._optimizerEnabled,
abi,
unlinked_binary,
updated_at,
@@ -204,14 +204,14 @@ export class Compiler {
...currentArtifact,
networks: {
...oldNetworks,
[this.networkId]: contractData,
[this._networkId]: contractData,
},
};
} else {
newArtifact = {
contract_name: contractName,
networks: {
[this.networkId]: contractData,
[this._networkId]: contractData,
},
};
}
@@ -226,12 +226,12 @@ export class Compiler {
* @param importPath Path to an imported dependency.
* @return Import contents object containing source code of dependency.
*/
private findImportsIfSourcesExist(importPath: string): ImportContents {
if (_.isUndefined(this.contractSourcesIfExists)) {
private _findImportsIfSourcesExist(importPath: string): ImportContents {
if (_.isUndefined(this._contractSourcesIfExists)) {
throw new Error('Contract sources not yet initialized');
}
const contractBaseName = path.basename(importPath);
const source = this.contractSourcesIfExists[contractBaseName];
const source = this._contractSourcesIfExists[contractBaseName];
const importContents: ImportContents = {
contents: source,
};
@@ -240,10 +240,10 @@ export class Compiler {
/**
* Creates the artifacts directory if it does not already exist.
*/
private async createArtifactsDirIfDoesNotExistAsync(): Promise<void> {
if (!fsWrapper.doesPathExistSync(this.artifactsDir)) {
private async _createArtifactsDirIfDoesNotExistAsync(): Promise<void> {
if (!fsWrapper.doesPathExistSync(this._artifactsDir)) {
utils.consoleLog('Creating artifacts directory...');
await fsWrapper.mkdirAsync(this.artifactsDir);
await fsWrapper.mkdirAsync(this._artifactsDir);
}
}
}

66
packages/contracts/deploy/src/deployer.ts
View File

@@ -18,19 +18,19 @@ const EXTRA_GAS = 200000;
export class Deployer {
public web3Wrapper: Web3Wrapper;
private artifactsDir: string;
private jsonrpcPort: number;
private networkId: number;
private defaults: Partial<TxData>;
private _artifactsDir: string;
private _jsonrpcPort: number;
private _networkId: number;
private _defaults: Partial<TxData>;
constructor(opts: DeployerOptions) {
this.artifactsDir = opts.artifactsDir;
this.jsonrpcPort = opts.jsonrpcPort;
this.networkId = opts.networkId;
const jsonrpcUrl = `http://localhost:${this.jsonrpcPort}`;
this._artifactsDir = opts.artifactsDir;
this._jsonrpcPort = opts.jsonrpcPort;
this._networkId = opts.networkId;
const jsonrpcUrl = `http://localhost:${this._jsonrpcPort}`;
const web3Provider = new Web3.providers.HttpProvider(jsonrpcUrl);
this.defaults = opts.defaults;
this.web3Wrapper = new Web3Wrapper(web3Provider, this.defaults);
this._defaults = opts.defaults;
this.web3Wrapper = new Web3Wrapper(web3Provider, this._defaults);
}
/**
* Loads contract artifact and deploys contract with given arguments.
@@ -39,21 +39,21 @@ export class Deployer {
* @return Deployed contract instance.
*/
public async deployAsync(contractName: string, args: any[] = []): Promise<Web3.ContractInstance> {
const contractArtifact: ContractArtifact = this.loadContractArtifactIfExists(contractName);
const contractData: ContractData = this.getContractDataFromArtifactIfExists(contractArtifact);
const contractArtifact: ContractArtifact = this._loadContractArtifactIfExists(contractName);
const contractData: ContractData = this._getContractDataFromArtifactIfExists(contractArtifact);
const data = contractData.unlinked_binary;
const from = await this.getFromAddressAsync();
const gas = await this.getAllowableGasEstimateAsync(data);
const from = await this._getFromAddressAsync();
const gas = await this._getAllowableGasEstimateAsync(data);
const txData = {
gasPrice: this.defaults.gasPrice,
gasPrice: this._defaults.gasPrice,
from,
data,
gas,
};
const abi = contractData.abi;
const web3ContractInstance = await this.deployFromAbiAsync(abi, args, txData);
const web3ContractInstance = await this._deployFromAbiAsync(abi, args, txData);
utils.consoleLog(`${contractName}.sol successfully deployed at ${web3ContractInstance.address}`);
const contractInstance = new Contract(web3ContractInstance, this.defaults);
const contractInstance = new Contract(web3ContractInstance, this._defaults);
return contractInstance;
}
/**
@@ -64,7 +64,7 @@ export class Deployer {
*/
public async deployAndSaveAsync(contractName: string, args: any[] = []): Promise<Web3.ContractInstance> {
const contractInstance = await this.deployAsync(contractName, args);
await this.saveContractDataToArtifactAsync(contractName, contractInstance.address, args);
await this._saveContractDataToArtifactAsync(contractName, contractInstance.address, args);
return contractInstance;
}
/**
@@ -74,7 +74,7 @@ export class Deployer {
* @param txData Tx options used for deployment.
* @return Promise that resolves to a web3 contract instance.
*/
private async deployFromAbiAsync(abi: Web3.ContractAbi, args: any[], txData: Web3.TxData): Promise<any> {
private async _deployFromAbiAsync(abi: Web3.ContractAbi, args: any[], txData: Web3.TxData): Promise<any> {
const contract: Web3.Contract<Web3.ContractInstance> = this.web3Wrapper.getContractFromAbi(abi);
const deployPromise = new Promise((resolve, reject) => {
/**
@@ -99,10 +99,10 @@ export class Deployer {
* @param contractAddress Contract address to save to artifact.
* @param args Contract constructor arguments that will be encoded and saved to artifact.
*/
private async saveContractDataToArtifactAsync(contractName: string,
contractAddress: string, args: any[]): Promise<void> {
const contractArtifact: ContractArtifact = this.loadContractArtifactIfExists(contractName);
const contractData: ContractData = this.getContractDataFromArtifactIfExists(contractArtifact);
private async _saveContractDataToArtifactAsync(contractName: string,
contractAddress: string, args: any[]): Promise<void> {
const contractArtifact: ContractArtifact = this._loadContractArtifactIfExists(contractName);
const contractData: ContractData = this._getContractDataFromArtifactIfExists(contractArtifact);
const abi = contractData.abi;
const encodedConstructorArgs = encoder.encodeConstructorArgsFromAbi(args, abi);
const newContractData = {
@@ -114,11 +114,11 @@ export class Deployer {
...contractArtifact,
networks: {
...contractArtifact.networks,
[this.networkId]: newContractData,
[this._networkId]: newContractData,
},
};
const artifactString = utils.stringifyWithFormatting(newArtifact);
const artifactPath = `${this.artifactsDir}/${contractName}.json`;
const artifactPath = `${this._artifactsDir}/${contractName}.json`;
await fsWrapper.writeFileAsync(artifactPath, artifactString);
}
/**
@@ -126,8 +126,8 @@ export class Deployer {
* @param contractName Name of the contract, without the extension.
* @return The contract artifact.
*/
private loadContractArtifactIfExists(contractName: string): ContractArtifact {
const artifactPath = `${this.artifactsDir}/${contractName}.json`;
private _loadContractArtifactIfExists(contractName: string): ContractArtifact {
const artifactPath = `${this._artifactsDir}/${contractName}.json`;
try {
const contractArtifact: ContractArtifact = require(artifactPath);
return contractArtifact;
@@ -140,8 +140,8 @@ export class Deployer {
* @param contractArtifact The contract artifact.
* @return Network specific contract data.
*/
private getContractDataFromArtifactIfExists(contractArtifact: ContractArtifact): ContractData {
const contractData = contractArtifact.networks[this.networkId];
private _getContractDataFromArtifactIfExists(contractArtifact: ContractArtifact): ContractData {
const contractData = contractArtifact.networks[this._networkId];
if (_.isUndefined(contractData)) {
throw new Error(`Data not found in artifact for contract: ${contractArtifact.contract_name}`);
}
@@ -151,13 +151,13 @@ export class Deployer {
* Gets the address to use for sending a transaction.
* @return The default from address. If not specified, returns the first address accessible by web3.
*/
private async getFromAddressAsync(): Promise<string> {
private async _getFromAddressAsync(): Promise<string> {
let from: string;
if (_.isUndefined(this.defaults.from)) {
if (_.isUndefined(this._defaults.from)) {
const accounts = await this.web3Wrapper.getAvailableAddressesAsync();
from = accounts[0];
} else {
from = this.defaults.from;
from = this._defaults.from;
}
return from;
}
@@ -167,7 +167,7 @@ export class Deployer {
* @param data Bytecode to estimate gas for.
* @return Gas estimate for transaction data.
*/
private async getAllowableGasEstimateAsync(data: string): Promise<number> {
private async _getAllowableGasEstimateAsync(data: string): Promise<number> {
const block = await this.web3Wrapper.getBlockAsync('latest');
let gas: number;
try {

14
packages/contracts/deploy/src/utils/contract.ts
View File

@@ -8,9 +8,9 @@ import {AbiType} from './types';
export class Contract implements Web3.ContractInstance {
public address: string;
public abi: Web3.ContractAbi;
private contract: Web3.ContractInstance;
private defaults: Partial<Web3.TxData>;
private validator: SchemaValidator;
private _contract: Web3.ContractInstance;
private _defaults: Partial<Web3.TxData>;
private _validator: SchemaValidator;
// This class instance is going to be populated with functions and events depending on the ABI
// and we don't know their types in advance
[name: string]: any;
@@ -23,7 +23,7 @@ export class Contract implements Web3.ContractInstance {
this.populateFunctions();
this.validator = new SchemaValidator();
}
private populateFunctions(): void {
private _populateFunctions(): void {
const functionsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Function);
_.forEach(functionsAbi, (functionAbi: Web3.MethodAbi) => {
if (functionAbi.constant) {
@@ -41,13 +41,13 @@ export class Contract implements Web3.ContractInstance {
}
});
}
private populateEvents(): void {
private _populateEvents(): void {
const eventsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Event);
_.forEach(eventsAbi, (eventAbi: Web3.EventAbi) => {
this[eventAbi.name] = this.contract[eventAbi.name];
});
}
private promisifyWithDefaultParams(fn: (...args: any[]) => void): (...args: any[]) => Promise<any> {
private _promisifyWithDefaultParams(fn: (...args: any[]) => void): (...args: any[]) => Promise<any> {
const promisifiedWithDefaultParams = async (...args: any[]) => {
const promise = new Promise((resolve, reject) => {
const lastArg = args[args.length - 1];
@@ -74,7 +74,7 @@ export class Contract implements Web3.ContractInstance {
};
return promisifiedWithDefaultParams;
}
private isTxData(lastArg: any): boolean {
private _isTxData(lastArg: any): boolean {
const isValid = this.validator.isValid(lastArg, schemas.txDataSchema);
return isValid;
}

12
packages/contracts/util/balances.ts
View File

@@ -7,16 +7,16 @@ import {BalancesByOwner, ContractInstance} from './types';
bigNumberConfigs.configure();
export class Balances {
private tokenContractInstances: ContractInstance[];
private ownerAddresses: string[];
private _tokenContractInstances: ContractInstance[];
private _ownerAddresses: string[];
constructor(tokenContractInstances: ContractInstance[], ownerAddresses: string[]) {
this.tokenContractInstances = tokenContractInstances;
this.ownerAddresses = ownerAddresses;
this._tokenContractInstances = tokenContractInstances;
this._ownerAddresses = ownerAddresses;
}
public async getAsync(): Promise<BalancesByOwner> {
const balancesByOwner: BalancesByOwner = {};
for (const tokenContractInstance of this.tokenContractInstances) {
for (const ownerAddress of this.ownerAddresses) {
for (const tokenContractInstance of this._tokenContractInstances) {
for (const ownerAddress of this._ownerAddresses) {
let balance = await tokenContractInstance.balanceOf(ownerAddress);
balance = new BigNumber(balance);
if (_.isUndefined(balancesByOwner[ownerAddress])) {

26
packages/contracts/util/exchange_wrapper.ts
View File

@@ -6,9 +6,9 @@ import {Order} from './order';
import {ContractInstance} from './types';
export class ExchangeWrapper {
private exchange: ContractInstance;
private _exchange: ContractInstance;
constructor(exchangeContractInstance: ContractInstance) {
this.exchange = exchangeContractInstance;
this._exchange = exchangeContractInstance;
}
public async fillOrderAsync(order: Order, from: string,
opts: {
@@ -17,7 +17,7 @@ export class ExchangeWrapper {
} = {}) {
const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
const tx = await this.exchange.fillOrder(
const tx = await this._exchange.fillOrder(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmount,
@@ -33,7 +33,7 @@ export class ExchangeWrapper {
public async cancelOrderAsync(order: Order, from: string,
opts: {cancelTakerTokenAmount?: BigNumber} = {}) {
const params = order.createCancel(opts.cancelTakerTokenAmount);
const tx = await this.exchange.cancelOrder(
const tx = await this._exchange.cancelOrder(
params.orderAddresses,
params.orderValues,
params.cancelTakerTokenAmount,
@@ -46,7 +46,7 @@ export class ExchangeWrapper {
opts: {fillTakerTokenAmount?: BigNumber} = {}) {
const shouldThrowOnInsufficientBalanceOrAllowance = true;
const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
const tx = await this.exchange.fillOrKillOrder(
const tx = await this._exchange.fillOrKillOrder(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmount,
@@ -66,7 +66,7 @@ export class ExchangeWrapper {
const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
const params = formatters.createBatchFill(
orders, shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmounts);
const tx = await this.exchange.batchFillOrders(
const tx = await this._exchange.batchFillOrders(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmounts,
@@ -82,7 +82,7 @@ export class ExchangeWrapper {
public async batchFillOrKillOrdersAsync(orders: Order[], from: string,
opts: {fillTakerTokenAmounts?: BigNumber[]} = {}) {
const params = formatters.createBatchFill(orders, undefined, opts.fillTakerTokenAmounts);
const tx = await this.exchange.batchFillOrKillOrders(
const tx = await this._exchange.batchFillOrKillOrders(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmounts,
@@ -103,7 +103,7 @@ export class ExchangeWrapper {
const params = formatters.createFillUpTo(orders,
shouldThrowOnInsufficientBalanceOrAllowance,
opts.fillTakerTokenAmount);
const tx = await this.exchange.fillOrdersUpTo(
const tx = await this._exchange.fillOrdersUpTo(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmount,
@@ -119,7 +119,7 @@ export class ExchangeWrapper {
public async batchCancelOrdersAsync(orders: Order[], from: string,
opts: {cancelTakerTokenAmounts?: BigNumber[]} = {}) {
const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
const tx = await this.exchange.batchCancelOrders(
const tx = await this._exchange.batchCancelOrders(
params.orderAddresses,
params.orderValues,
params.cancelTakerTokenAmounts,
@@ -131,11 +131,11 @@ export class ExchangeWrapper {
public async getOrderHashAsync(order: Order): Promise<string> {
const shouldThrowOnInsufficientBalanceOrAllowance = false;
const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance);
const orderHash = await this.exchange.getOrderHash(params.orderAddresses, params.orderValues);
const orderHash = await this._exchange.getOrderHash(params.orderAddresses, params.orderValues);
return orderHash;
}
public async isValidSignatureAsync(order: Order): Promise<boolean> {
const isValidSignature = await this.exchange.isValidSignature(
const isValidSignature = await this._exchange.isValidSignature(
order.params.maker,
order.params.orderHashHex,
order.params.v,
@@ -146,12 +146,12 @@ export class ExchangeWrapper {
}
public async isRoundingErrorAsync(numerator: BigNumber, denominator: BigNumber,
target: BigNumber): Promise<boolean> {
const isRoundingError = await this.exchange.isRoundingError(numerator, denominator, target);
const isRoundingError = await this._exchange.isRoundingError(numerator, denominator, target);
return isRoundingError;
}
public async getPartialAmountAsync(numerator: BigNumber, denominator: BigNumber,
target: BigNumber): Promise<BigNumber> {
const partialAmount = new BigNumber(await this.exchange.getPartialAmount(numerator, denominator, target));
const partialAmount = new BigNumber(await this._exchange.getPartialAmount(numerator, denominator, target));
return partialAmount;
}
}

6
packages/contracts/util/multi_sig_wrapper.ts
View File

@@ -6,7 +6,7 @@ import * as Web3 from 'web3';
import {ContractInstance, TransactionDataParams} from './types';
export class MultiSigWrapper {
private multiSig: ContractInstance;
private _multiSig: ContractInstance;
public static encodeFnArgs(name: string, abi: Web3.AbiDefinition[], args: any[]) {
const abiEntity = _.find(abi, {name}) as Web3.MethodAbi;
if (_.isUndefined(abiEntity)) {
@@ -22,13 +22,13 @@ export class MultiSigWrapper {
return funcSig + argsData.join('');
}
constructor(multiSigContractInstance: ContractInstance) {
this.multiSig = multiSigContractInstance;
this._multiSig = multiSigContractInstance;
}
public async submitTransactionAsync(destination: string, from: string,
dataParams: TransactionDataParams,
value: number = 0) {
const {name, abi, args = []} = dataParams;
const encoded = MultiSigWrapper.encodeFnArgs(name, abi, args);
return this.multiSig.submitTransaction(destination, value, encoded, {from});
return this._multiSig.submitTransaction(destination, value, encoded, {from});
}
}

6
packages/contracts/util/order.ts
View File

@@ -21,7 +21,7 @@ export class Order {
if (_.isUndefined(v) || _.isUndefined(r) || _.isUndefined(s)) {
throw new Error('Cannot call isValidSignature on unsigned order');
}
const orderHash = this.getOrderHash();
const orderHash = this._getOrderHash();
const msgHash = ethUtil.hashPersonalMessage(ethUtil.toBuffer(orderHash));
try {
const pubKey = ethUtil.ecrecover(msgHash, v, ethUtil.toBuffer(r), ethUtil.toBuffer(s));
@@ -32,7 +32,7 @@ export class Order {
}
}
public async signAsync() {
const orderHash = this.getOrderHash();
const orderHash = this._getOrderHash();
const signature = await promisify<string>(web3.eth.sign)(this.params.maker, orderHash);
const {v, r, s} = ethUtil.fromRpcSig(signature);
this.params = _.assign(this.params, {
@@ -88,7 +88,7 @@ export class Order {
};
return cancel;
}
private getOrderHash(): string {
private _getOrderHash(): string {
const orderHash = crypto.solSHA3([
this.params.exchangeContractAddress,
this.params.maker,

6
packages/contracts/util/order_factory.ts
View File

@@ -6,9 +6,9 @@ import {Order} from './order';
import {DefaultOrderParams, OptionalOrderParams, OrderParams} from './types';
export class OrderFactory {
private defaultOrderParams: DefaultOrderParams;
private _defaultOrderParams: DefaultOrderParams;
constructor(defaultOrderParams: DefaultOrderParams) {
this.defaultOrderParams = defaultOrderParams;
this._defaultOrderParams = defaultOrderParams;
}
public async newSignedOrderAsync(customOrderParams: OptionalOrderParams = {}) {
const randomExpiration = new BigNumber(Math.floor((Date.now() + (Math.random() * 100000000000)) / 1000));
@@ -16,7 +16,7 @@ export class OrderFactory {
expirationTimestampInSec: randomExpiration,
salt: ZeroEx.generatePseudoRandomSalt(),
taker: ZeroEx.NULL_ADDRESS,
}, this.defaultOrderParams, customOrderParams);
}, this._defaultOrderParams, customOrderParams);
const order = new Order(orderParams);
await order.signAsync();
return order;

12
packages/contracts/util/token_registry_wrapper.ts
View File

@@ -1,12 +1,12 @@
import {ContractInstance, Token} from './types';
export class TokenRegWrapper {
private tokenReg: ContractInstance;
private _tokenReg: ContractInstance;
constructor(tokenRegContractInstance: ContractInstance) {
this.tokenReg = tokenRegContractInstance;
this._tokenReg = tokenRegContractInstance;
}
public addTokenAsync(token: Token, from: string) {
const tx = this.tokenReg.addToken(
const tx = this._tokenReg.addToken(
token.address,
token.name,
token.symbol,
@@ -18,7 +18,7 @@ export class TokenRegWrapper {
return tx;
}
public async getTokenMetaDataAsync(tokenAddress: string) {
const data = await this.tokenReg.getTokenMetaData(tokenAddress);
const data = await this._tokenReg.getTokenMetaData(tokenAddress);
const token: Token = {
address: data[0],
name: data[1],
@@ -30,7 +30,7 @@ export class TokenRegWrapper {
return token;
}
public async getTokenByNameAsync(tokenName: string) {
const data = await this.tokenReg.getTokenByName(tokenName);
const data = await this._tokenReg.getTokenByName(tokenName);
const token: Token = {
address: data[0],
name: data[1],
@@ -42,7 +42,7 @@ export class TokenRegWrapper {
return token;
}
public async getTokenBySymbolAsync(tokenSymbol: string) {
const data = await this.tokenReg.getTokenBySymbol(tokenSymbol);
const data = await this._tokenReg.getTokenBySymbol(tokenSymbol);
const token: Token = {
address: data[0],
name: data[1],