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

Merge pull request #368 from 0xProject/feature/abigen/addNetworkId

Browse Source 
Add CLI option for networkId, add abi-gen to contracts package
This commit is contained in:
Leonid 2018-02-07 11:40:06 +01:00 committed by GitHub
commit 12d62e1157
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
80 changed files with 568 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
packages/0x.js/contract_templates/contract.handlebars
View File

@ -1,7 +1,8 @@
/**
* This file is auto-generated using abi-gen. Don't edit directly.
* Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates.
* Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/0x.js/contract_templates.
*/
// tslint:disable:no-consecutive-blank-lines
// tslint:disable-next-line:no-unused-variable
import { TxData, TxDataPayable } from '@0xproject/types';
import { BigNumber, classUtils, promisify } from '@0xproject/utils';
@ -9,6 +10,24 @@ import * as Web3 from 'web3';
import {BaseContract} from './base_contract';
{{#if events}}
export type {{contractName}}ContractEventArgs =
{{#each events}}
| {{name}}ContractEventArgs{{#if @last}};{{/if}}
{{/each}}
export enum {{contractName}}Events {
{{#each events}}
{{name}} = '{{name}}',
{{/each}}
}
{{#each events}}
{{> event}}
{{/each}}
{{/if}}
export class {{contractName}}Contract extends BaseContract {
{{#each methods}}
{{#this.constant}}

5
packages/0x.js/contract_templates/partials/event.handlebars Normal file
View File

@ -0,0 +1,5 @@
export interface {{name}}ContractEventArgs {
{{#each inputs}}
{{name}}: {{#returnType type}}{{/returnType}};
{{/each}}
}

12
packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts
View File

@ -5,19 +5,11 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as _ from 'lodash';
import { artifacts } from '../artifacts';
import {
BlockRange,
EtherTokenContractEventArgs,
EtherTokenEvents,
EventCallback,
IndexedFilterValues,
TransactionOpts,
ZeroExError,
} from '../types';
import { BlockRange, EventCallback, IndexedFilterValues, TransactionOpts, ZeroExError } from '../types';
import { assert } from '../utils/assert';
import { ContractWrapper } from './contract_wrapper';
import { EtherTokenContract } from './generated/ether_token';
import { EtherTokenContract, EtherTokenContractEventArgs, EtherTokenEvents } from './generated/ether_token';
import { TokenWrapper } from './token_wrapper';
/**

10
packages/0x.js/src/contract_wrappers/exchange_wrapper.ts
View File

@ -12,10 +12,7 @@ import {
EventCallback,
ExchangeContractErrCodes,
ExchangeContractErrs,
ExchangeContractEventArgs,
ExchangeEvents,
IndexedFilterValues,
LogErrorContractEventArgs,
MethodOpts,
Order,
OrderAddresses,
@ -33,7 +30,12 @@ import { OrderValidationUtils } from '../utils/order_validation_utils';
import { utils } from '../utils/utils';
import { ContractWrapper } from './contract_wrapper';
import { ExchangeContract } from './generated/exchange';
import {
ExchangeContract,
ExchangeContractEventArgs,
ExchangeEvents,
LogErrorContractEventArgs,
} from './generated/exchange';
import { TokenWrapper } from './token_wrapper';
const SHOULD_VALIDATE_BY_DEFAULT = true;

13
packages/0x.js/src/contract_wrappers/token_wrapper.ts
View File

@ -5,21 +5,12 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as _ from 'lodash';
import { artifacts } from '../artifacts';
import {
BlockRange,
EventCallback,
IndexedFilterValues,
MethodOpts,
TokenContractEventArgs,
TokenEvents,
TransactionOpts,
ZeroExError,
} from '../types';
import { BlockRange, EventCallback, IndexedFilterValues, MethodOpts, TransactionOpts, ZeroExError } from '../types';
import { assert } from '../utils/assert';
import { constants } from '../utils/constants';
import { ContractWrapper } from './contract_wrapper';
import { TokenContract } from './generated/token';
import { TokenContract, TokenContractEventArgs, TokenEvents } from './generated/token';
import { TokenTransferProxyWrapper } from './token_transfer_proxy_wrapper';
/**

35
packages/0x.js/src/index.ts
View File

@ -9,26 +9,13 @@ export {
ExchangeContractErrs,
ContractEvent,
Token,
ExchangeEvents,
TokenEvents,
IndexedFilterValues,
BlockRange,
OrderCancellationRequest,
OrderFillRequest,
LogErrorContractEventArgs,
LogCancelContractEventArgs,
LogFillContractEventArgs,
ExchangeContractEventArgs,
TransferContractEventArgs,
ApprovalContractEventArgs,
TokenContractEventArgs,
EtherTokenContractEventArgs,
WithdrawalContractEventArgs,
DepositContractEventArgs,
ContractEventArgs,
Web3Provider,
ZeroExConfig,
EtherTokenEvents,
MethodOpts,
OrderTransactionOpts,
TransactionOpts,
@ -50,4 +37,26 @@ export {
TransactionReceiptWithDecodedLogs,
} from '@0xproject/types';
export {
EtherTokenContractEventArgs,
WithdrawalContractEventArgs,
DepositContractEventArgs,
EtherTokenEvents,
} from './contract_wrappers/generated/ether_token';
export {
TransferContractEventArgs,
ApprovalContractEventArgs,
TokenContractEventArgs,
TokenEvents,
} from './contract_wrappers/generated/token';
export {
LogErrorContractEventArgs,
LogCancelContractEventArgs,
LogFillContractEventArgs,
ExchangeContractEventArgs,
ExchangeEvents,
} from './contract_wrappers/generated/exchange';
export { TransactionReceipt } from '@0xproject/types';

24
packages/0x.js/src/order_watcher/order_state_watcher.ts
View File

@ -6,26 +6,32 @@ import * as _ from 'lodash';
import { ZeroEx } from '../0x';
import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
import {
DepositContractEventArgs,
EtherTokenEvents,
WithdrawalContractEventArgs,
} from '../contract_wrappers/generated/ether_token';
import {
ExchangeEvents,
LogCancelContractEventArgs,
LogFillContractEventArgs,
} from '../contract_wrappers/generated/exchange';
import {
ApprovalContractEventArgs,
TokenEvents,
TransferContractEventArgs,
} from '../contract_wrappers/generated/token';
import { TokenWrapper } from '../contract_wrappers/token_wrapper';
import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store';
import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store';
import {
ApprovalContractEventArgs,
ContractEventArgs,
DepositContractEventArgs,
EtherTokenEvents,
ExchangeContractErrs,
ExchangeEvents,
LogCancelContractEventArgs,
LogEvent,
LogFillContractEventArgs,
OnOrderStateChangeCallback,
OrderState,
OrderStateWatcherConfig,
SignedOrder,
TokenEvents,
TransferContractEventArgs,
WithdrawalContractEventArgs,
ZeroExError,
} from '../types';
import { assert } from '../utils/assert';

76
packages/0x.js/src/types.ts
View File

@ -4,6 +4,10 @@ import { BlockParam, BlockParamLiteral, ContractEventArg, LogWithDecodedArgs } f
import * as Web3 from 'web3';
import { EtherTokenContractEventArgs, EtherTokenEvents } from './contract_wrappers/generated/ether_token';
import { ExchangeContractEventArgs, ExchangeEvents } from './contract_wrappers/generated/exchange';
import { TokenContractEventArgs, TokenEvents } from './contract_wrappers/generated/token';
export enum ZeroExError {
ExchangeContractDoesNotExist = 'EXCHANGE_CONTRACT_DOES_NOT_EXIST',
ZRXContractDoesNotExist = 'ZRX_CONTRACT_DOES_NOT_EXIST',
@ -101,60 +105,6 @@ export interface ContractEvent {
args: ContractEventArgs;
}
export interface LogFillContractEventArgs {
maker: string;
taker: string;
feeRecipient: string;
makerToken: string;
takerToken: string;
filledMakerTokenAmount: BigNumber;
filledTakerTokenAmount: BigNumber;
paidMakerFee: BigNumber;
paidTakerFee: BigNumber;
tokens: string;
orderHash: string;
}
export interface LogCancelContractEventArgs {
maker: string;
feeRecipient: string;
makerToken: string;
takerToken: string;
cancelledMakerTokenAmount: BigNumber;
cancelledTakerTokenAmount: BigNumber;
tokens: string;
orderHash: string;
}
export interface LogErrorContractEventArgs {
errorId: BigNumber;
orderHash: string;
}
export type ExchangeContractEventArgs =
| LogFillContractEventArgs
| LogCancelContractEventArgs
| LogErrorContractEventArgs;
export interface TransferContractEventArgs {
_from: string;
_to: string;
_value: BigNumber;
}
export interface ApprovalContractEventArgs {
_owner: string;
_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 EtherTokenContractEventArgs =
| TokenContractEventArgs
| DepositContractEventArgs
| WithdrawalContractEventArgs;
export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs;
export interface Order {
@ -197,24 +147,6 @@ export interface TokenAddressBySymbol {
[symbol: string]: string;
}
export enum ExchangeEvents {
LogFill = 'LogFill',
LogCancel = 'LogCancel',
LogError = 'LogError',
}
export enum TokenEvents {
Transfer = 'Transfer',
Approval = 'Approval',
}
export enum EtherTokenEvents {
Transfer = 'Transfer',
Approval = 'Approval',
Deposit = 'Deposit',
Withdrawal = 'Withdrawal',
}
export type ContractEvents = TokenEvents | ExchangeEvents | EtherTokenEvents;
export interface IndexedFilterValues {

1
packages/abi-gen/CHANGELOG.md
View File

@ -3,6 +3,7 @@
## v0.2.0 - _???_
* Added CLI options for explicit specifying location of partials and main template (#346)
* Added CLI option to specify networkId, adding support for the JSON artifact format found in @0xproject/contracts
## v0.1.0 - _January 11, 2018_

30
packages/abi-gen/src/index.ts
View File

@ -17,6 +17,7 @@ import { utils } from './utils';
const ABI_TYPE_CONSTRUCTOR = 'constructor';
const ABI_TYPE_METHOD = 'function';
const ABI_TYPE_EVENT = 'event';
const DEFAULT_NETWORK_ID = 50;
const args = yargs
.option('abis', {
@ -42,6 +43,11 @@ const args = yargs
demandOption: true,
normalize: true,
})
.option('network-id', {
describe: 'ID of the network where contract ABIs are nested in artifacts',
type: 'number',
default: DEFAULT_NETWORK_ID,
})
.example(
"$0 --abis 'src/artifacts/**/*.json' --out 'src/contracts/generated/' --partials 'src/templates/partials/**/*.handlebars' --template 'src/templates/contract.handlebars'",
'Full usage example',
@ -58,7 +64,10 @@ function registerPartials(partialsGlob: string) {
}
function writeOutputFile(name: string, renderedTsCode: string): void {
const fileName = toSnakeCase(name);
let fileName = toSnakeCase(name);
if (fileName === 'z_r_x_token') {
fileName = 'zrx_token';
}
const filePath = `${args.output}/${fileName}.ts`;
fs.writeFileSync(filePath, renderedTsCode);
utils.log(`Created: ${chalk.bold(filePath)}`);
@ -87,12 +96,19 @@ for (const abiFileName of abiFileNames) {
const namedContent = utils.getNamedContent(abiFileName);
utils.log(`Processing: ${chalk.bold(namedContent.name)}...`);
const parsedContent = JSON.parse(namedContent.content);
const ABI = _.isArray(parsedContent)
? parsedContent // ABI file
: parsedContent.abi; // Truffle contracts file
let ABI;
if (_.isArray(parsedContent)) {
ABI = parsedContent; // ABI file
} else if (!_.isUndefined(parsedContent.abi)) {
ABI = parsedContent.abi; // Truffle artifact
} else if (!_.isUndefined(parsedContent.networks) && !_.isUndefined(parsedContent.networks[args.networkId])) {
ABI = parsedContent.networks[args.networkId].abi; // 0x contracts package artifact
}
if (_.isUndefined(ABI)) {
utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
utils.log(`Please make sure your ABI file is either an array with ABI entries or an object with the abi key`);
utils.log(
`Please make sure your ABI file is either an array with ABI entries or a truffle artifact or 0x deployer artifact`,
);
process.exit(1);
}
@ -103,10 +119,10 @@ for (const abiFileName of abiFileNames) {
const methodAbis = ABI.filter((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_METHOD) as Web3.MethodAbi[];
const methodsData = _.map(methodAbis, methodAbi => {
_.map(methodAbi.inputs, input => {
_.map(methodAbi.inputs, (input, i: number) => {
if (_.isEmpty(input.name)) {
// Auto-generated getters don't have parameter names
input.name = 'index';
input.name = `index_${i}`;
}
});
// This will make templates simpler

26
packages/contracts/contract_templates/contract.handlebars Normal file
View File

@ -0,0 +1,26 @@
/**
* This file is auto-generated using abi-gen. Don't edit directly.
* Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates.
*/
// tslint:disable:async-suffix member-ordering no-consecutive-blank-lines
// tslint:disable-next-line:no-unused-variable
import { TxData, TxDataPayable } from '@0xproject/types';
import { BigNumber, classUtils, promisify } from '@0xproject/utils';
import * as Web3 from 'web3';
import {BaseContract} from './base_contract';
export class {{contractName}}Contract extends BaseContract {
{{#each methods}}
{{#this.constant}}
{{> call contractName=../contractName}}
{{/this.constant}}
{{^this.constant}}
{{> tx contractName=../contractName}}
{{/this.constant}}
{{/each}}
constructor(web3ContractInstance: Web3.ContractInstance, defaults?: Partial<TxData>) {
super(web3ContractInstance, defaults);
classUtils.bindAll(this, ['_web3ContractInstance', '_defaults']);
}
} // tslint:disable:max-file-line-count

10
packages/contracts/contract_templates/partials/call.handlebars Normal file
View File

@ -0,0 +1,10 @@
public async {{this.name}}(
{{> typed_params inputs=inputs}}
defaultBlock?: Web3.BlockParam,
): Promise<{{> return_type outputs=outputs}}> {
const self = this as {{contractName}}Contract;
const result = await self._web3ContractInstance.{{this.name}}.call(
{{> params inputs=inputs}}
);
return result;
}

3
packages/contracts/contract_templates/partials/params.handlebars Normal file
View File

@ -0,0 +1,3 @@
{{#each inputs}}
{{name}},
{{/each}}

10
packages/contracts/contract_templates/partials/return_type.handlebars Normal file
View File

@ -0,0 +1,10 @@
{{#if outputs.length}}
{{#singleReturnValue}}
{{#returnType outputs.0.type}}{{/returnType}}
{{/singleReturnValue}}
{{^singleReturnValue}}
[{{#each outputs}}{{#returnType type}}{{/returnType}}{{#unless @last}}, {{/unless}}{{/each}}]
{{/singleReturnValue}}
{{else}}
void
{{/if}}

36
packages/contracts/contract_templates/partials/tx.handlebars Normal file
View File

@ -0,0 +1,36 @@
public {{this.name}} = {
async sendTransactionAsync(
{{> typed_params inputs=inputs}}
{{#this.payable}}
txData: TxDataPayable = {},
{{/this.payable}}
{{^this.payable}}
txData: TxData = {},
{{/this.payable}}
): Promise<string> {
const self = this as {{contractName}}Contract;
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(txData);
const txHash = await self._web3ContractInstance.{{this.name}}(
{{> params inputs=inputs}}
txDataWithDefaults,
);
return txHash;
},
async callAsync(
{{> typed_params inputs=inputs}}
{{#this.payable}}
txData: TxDataPayable = {},
{{/this.payable}}
{{^this.payable}}
txData: TxData = {},
{{/this.payable}}
): Promise<{{> return_type outputs=outputs}}> {
const self = this as {{contractName}}Contract;
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(txData);
const returnValue = await self._web3ContractInstance.{{this.name}}.call(
{{> params inputs=inputs}}
txDataWithDefaults,
);
return returnValue;
},
};

3
packages/contracts/contract_templates/partials/typed_params.handlebars Normal file
View File

@ -0,0 +1,3 @@
{{#each inputs}}
{{name}}: {{#parameterType type}}{{/parameterType}},
{{/each}}

7
packages/contracts/package.json
View File

@ -9,14 +9,15 @@
},
"scripts": {
"build:watch": "tsc -w",
"prebuild": "run-s clean copy_artifacts",
"copy_artifacts": "copyfiles './artifacts/**/*' ./lib",
"prebuild": "run-s clean copy_artifacts generate_contract_wrappers",
"copy_artifacts": "copyfiles './src/artifacts/**/*' ./lib",
"build": "tsc",
"test": "run-s compile build run_mocha",
"run_mocha": "mocha 'lib/test/**/*.js' --timeout 10000 --bail --exit",
"compile:comment": "Yarn workspaces do not link binaries correctly so we need to reference them directly https://github.com/yarnpkg/yarn/issues/3846",
"compile": "node ../deployer/lib/src/cli.js compile",
"compile": "node ../deployer/lib/src/cli.js compile --contracts-dir src/contracts --artifacts-dir src/artifacts",
"clean": "rm -rf ./lib",
"generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/artifacts/@(DummyToken|TokenTransferProxy|Exchange|TokenRegistry|MultiSigWallet|MultiSigWalletWithTimeLock|MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress|TokenRegistry|ZRXToken).json' --template contract_templates/contract.handlebars --partials 'contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated",
"migrate": "node ../deployer/lib/src/cli.js migrate",
"lint": "tslint --project . 'migrations/**/*.ts' 'test/**/*.ts' 'util/**/*.ts' 'deploy/**/*.ts'",
"test:circleci": "yarn test"

0
packages/contracts/artifacts/DummyToken.json → packages/contracts/src/artifacts/DummyToken.json
View File

0
packages/contracts/artifacts/ERC20Token.json → packages/contracts/src/artifacts/ERC20Token.json
View File

0
packages/contracts/artifacts/ERC20Token_v1.json → packages/contracts/src/artifacts/ERC20Token_v1.json
View File

0
packages/contracts/artifacts/Exchange.json → packages/contracts/src/artifacts/Exchange.json
View File

0
packages/contracts/artifacts/MaliciousToken.json → packages/contracts/src/artifacts/MaliciousToken.json
View File

0
packages/contracts/artifacts/Mintable.json → packages/contracts/src/artifacts/Mintable.json
View File

0
packages/contracts/artifacts/MultiSigWallet.json → packages/contracts/src/artifacts/MultiSigWallet.json
View File

0
packages/contracts/artifacts/MultiSigWalletWithTimeLock.json → packages/contracts/src/artifacts/MultiSigWalletWithTimeLock.json
View File

0
packages/contracts/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json → packages/contracts/src/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json
View File

0
packages/contracts/artifacts/Ownable.json → packages/contracts/src/artifacts/Ownable.json
View File

0
packages/contracts/artifacts/Ownable_v1.json → packages/contracts/src/artifacts/Ownable_v1.json
View File

0
packages/contracts/artifacts/SafeMath.json → packages/contracts/src/artifacts/SafeMath.json
View File

0
packages/contracts/artifacts/SafeMath_v1.json → packages/contracts/src/artifacts/SafeMath_v1.json
View File

0
packages/contracts/artifacts/Token.json → packages/contracts/src/artifacts/Token.json
View File

0
packages/contracts/artifacts/TokenRegistry.json → packages/contracts/src/artifacts/TokenRegistry.json
View File

0
packages/contracts/artifacts/TokenTransferProxy.json → packages/contracts/src/artifacts/TokenTransferProxy.json
View File

0
packages/contracts/artifacts/Token_v1.json → packages/contracts/src/artifacts/Token_v1.json
View File

0
packages/contracts/artifacts/UnlimitedAllowanceToken.json → packages/contracts/src/artifacts/UnlimitedAllowanceToken.json
View File

0
packages/contracts/artifacts/UnlimitedAllowanceToken_v1.json → packages/contracts/src/artifacts/UnlimitedAllowanceToken_v1.json
View File

0
packages/contracts/artifacts/WETH9.json → packages/contracts/src/artifacts/WETH9.json
View File

0
packages/contracts/artifacts/ZRXToken.json → packages/contracts/src/artifacts/ZRXToken.json
View File

8
packages/contracts/src/contract_wrappers/generated/.gitignore vendored Normal file
View File

@ -0,0 +1,8 @@
dummy_token.ts
exchange.ts
multi_sig_wallet_with_time_lock_except_remove_authorized_address.ts
multi_sig_wallet_with_time_lock.ts
multi_sig_wallet.ts
token_registry.ts
token_transfer_proxy.ts
zrx_token.ts

35
packages/contracts/src/contract_wrappers/generated/base_contract.ts Normal file
View File

@ -0,0 +1,35 @@
import {TxData, TxDataPayable} from '@0xproject/types';
import * as _ from 'lodash';
import * as Web3 from 'web3';
export class BaseContract {
public address: string;
protected _web3ContractInstance: Web3.ContractInstance;
protected _defaults: Partial<TxData>;
protected async _applyDefaultsToTxDataAsync<T extends TxData|TxDataPayable>(
txData: T,
estimateGasAsync?: (txData: T) => Promise<number>,
): Promise<TxData> {
// Gas amount sourced with the following priorities:
// 1. Optional param passed in to public method call
// 2. Global config passed in at library instantiation
// 3. Gas estimate calculation + safety margin
const removeUndefinedProperties = _.pickBy;
const txDataWithDefaults = {
...removeUndefinedProperties(this._defaults),
...removeUndefinedProperties(txData as any),
// HACK: TS can't prove that T is spreadable.
// Awaiting https://github.com/Microsoft/TypeScript/pull/13288 to be merged
};
if (_.isUndefined(txDataWithDefaults.gas) && !_.isUndefined(estimateGasAsync)) {
const estimatedGas = await estimateGasAsync(txData);
txDataWithDefaults.gas = estimatedGas;
}
return txDataWithDefaults;
}
constructor(web3ContractInstance: Web3.ContractInstance, defaults?: Partial<TxData>) {
this.address = web3ContractInstance.address;
this._web3ContractInstance = web3ContractInstance;
this._defaults = defaults || {};
}
}

0
packages/contracts/src/current/multisig/MultiSigWallet/MultiSigWallet.sol → packages/contracts/src/contracts/current/multisig/MultiSigWallet/MultiSigWallet.sol
View File

0
packages/contracts/src/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol → packages/contracts/src/contracts/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol
View File

0
packages/contracts/src/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol → packages/contracts/src/contracts/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol
View File

0
packages/contracts/src/current/protocol/Exchange/Exchange.sol → packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol
View File

0
packages/contracts/src/current/protocol/TokenRegistry/TokenRegistry.sol → packages/contracts/src/contracts/current/protocol/TokenRegistry/TokenRegistry.sol
View File

0
packages/contracts/src/current/protocol/TokenTransferProxy/TokenTransferProxy.sol → packages/contracts/src/contracts/current/protocol/TokenTransferProxy/TokenTransferProxy.sol
View File

0
packages/contracts/src/current/test/DummyToken/DummyToken.sol → packages/contracts/src/contracts/current/test/DummyToken/DummyToken.sol
View File

0
packages/contracts/src/current/test/MaliciousToken/MaliciousToken.sol → packages/contracts/src/contracts/current/test/MaliciousToken/MaliciousToken.sol
View File

0
packages/contracts/src/current/test/Mintable/Mintable.sol → packages/contracts/src/contracts/current/test/Mintable/Mintable.sol
View File

0
packages/contracts/src/current/tokens/ERC20Token/ERC20Token.sol → packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol
View File

0
packages/contracts/src/current/tokens/Token/Token.sol → packages/contracts/src/contracts/current/tokens/Token/Token.sol
View File

0
packages/contracts/src/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol → packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol
View File

0
packages/contracts/src/current/tokens/WETH9/WETH9.sol → packages/contracts/src/contracts/current/tokens/WETH9/WETH9.sol
View File

0
packages/contracts/src/current/tokens/ZRXToken/ZRXToken.sol → packages/contracts/src/contracts/current/tokens/ZRXToken/ZRXToken.sol
View File

0
packages/contracts/src/current/utils/Ownable/Ownable.sol → packages/contracts/src/contracts/current/utils/Ownable/Ownable.sol
View File

0
packages/contracts/src/current/utils/SafeMath/SafeMath.sol → packages/contracts/src/contracts/current/utils/SafeMath/SafeMath.sol
View File

0
packages/contracts/src/previous/ERC20Token/ERC20Token_v1.sol → packages/contracts/src/contracts/previous/ERC20Token/ERC20Token_v1.sol
View File

0
packages/contracts/src/previous/Ownable/Ownable_v1.sol → packages/contracts/src/contracts/previous/Ownable/Ownable_v1.sol
View File

0
packages/contracts/src/previous/SafeMath/SafeMath_v1.sol → packages/contracts/src/contracts/previous/SafeMath/SafeMath_v1.sol
View File

0
packages/contracts/src/previous/Token/Token_v1.sol → packages/contracts/src/contracts/previous/Token/Token_v1.sol
View File

0
packages/contracts/src/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol → packages/contracts/src/contracts/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol
View File

81
packages/contracts/test/exchange/core.ts
View File

@ -13,6 +13,9 @@ import * as chai from 'chai';
import ethUtil = require('ethereumjs-util');
import * as Web3 from 'web3';
import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
import { Balances } from '../../util/balances';
import { constants } from '../../util/constants';
import { crypto } from '../../util/crypto';
@ -37,11 +40,11 @@ describe('Exchange', () => {
const INITIAL_BALANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
const INITIAL_ALLOWANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
let rep: Web3.ContractInstance;
let dgd: Web3.ContractInstance;
let zrx: Web3.ContractInstance;
let exchange: Web3.ContractInstance;
let tokenTransferProxy: Web3.ContractInstance;
let rep: DummyTokenContract;
let dgd: DummyTokenContract;
let zrx: DummyTokenContract;
let exchange: ExchangeContract;
let tokenTransferProxy: TokenTransferProxyContract;
let order: Order;
let balances: BalancesByOwner;
@ -55,14 +58,22 @@ describe('Exchange', () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
maker = accounts[0];
[tokenOwner, taker, feeRecipient] = accounts;
[rep, dgd, zrx] = await Promise.all([
const [repInstance, dgdInstance, zrxInstance] = await Promise.all([
deployer.deployAsync(ContractName.DummyToken),
deployer.deployAsync(ContractName.DummyToken),
deployer.deployAsync(ContractName.DummyToken),
]);
tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]);
await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
rep = new DummyTokenContract(repInstance);
dgd = new DummyTokenContract(dgdInstance);
zrx = new DummyTokenContract(zrxInstance);
const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
zrx.address,
tokenTransferProxy.address,
]);
exchange = new ExchangeContract(exchangeInstance);
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
zeroEx = new ZeroEx(web3.currentProvider, {
exchangeContractAddress: exchange.address,
networkId: constants.TESTRPC_NETWORK_ID,
@ -83,30 +94,30 @@ describe('Exchange', () => {
orderFactory = new OrderFactory(web3Wrapper, defaultOrderParams);
dmyBalances = new Balances([rep, dgd, zrx], [maker, taker, feeRecipient]);
await Promise.all([
rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: maker,
}),
rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: taker,
}),
rep.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }),
rep.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }),
dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
rep.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }),
rep.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }),
dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: maker,
}),
dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: taker,
}),
dgd.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }),
dgd.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }),
zrx.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
dgd.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }),
dgd.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }),
zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: maker,
}),
zrx.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: taker,
}),
zrx.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }),
zrx.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }),
zrx.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }),
zrx.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }),
]);
});
beforeEach(async () => {
@ -117,19 +128,19 @@ describe('Exchange', () => {
});
describe('internal functions', () => {
it('should include transferViaTokenTransferProxy', () => {
expect(exchange.transferViaTokenTransferProxy).to.be.undefined();
expect((exchange as any).transferViaTokenTransferProxy).to.be.undefined();
});
it('should include isTransferable', () => {
expect(exchange.isTransferable).to.be.undefined();
expect((exchange as any).isTransferable).to.be.undefined();
});
it('should include getBalance', () => {
expect(exchange.getBalance).to.be.undefined();
expect((exchange as any).getBalance).to.be.undefined();
});
it('should include getAllowance', () => {
expect(exchange.getAllowance).to.be.undefined();
expect((exchange as any).getAllowance).to.be.undefined();
});
});
@ -565,9 +576,9 @@ describe('Exchange', () => {
it('should not change balances if maker allowances are too low to fill order and \
shouldThrowOnInsufficientBalanceOrAllowance = false', async () => {
await rep.approve(tokenTransferProxy.address, 0, { from: maker });
await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: maker });
await exWrapper.fillOrderAsync(order, taker);
await rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: maker,
});
@ -577,22 +588,22 @@ describe('Exchange', () => {
it('should throw if maker allowances are too low to fill order and \
shouldThrowOnInsufficientBalanceOrAllowance = true', async () => {
await rep.approve(tokenTransferProxy.address, 0, { from: maker });
await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: maker });
expect(
exWrapper.fillOrderAsync(order, taker, {
shouldThrowOnInsufficientBalanceOrAllowance: true,
}),
).to.be.rejectedWith(constants.REVERT);
await rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: maker,
});
});
it('should not change balances if taker allowances are too low to fill order and \
shouldThrowOnInsufficientBalanceOrAllowance = false', async () => {
await dgd.approve(tokenTransferProxy.address, 0, { from: taker });
await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: taker });
await exWrapper.fillOrderAsync(order, taker);
await dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: taker,
});
@ -602,13 +613,13 @@ describe('Exchange', () => {
it('should throw if taker allowances are too low to fill order and \
shouldThrowOnInsufficientBalanceOrAllowance = true', async () => {
await dgd.approve(tokenTransferProxy.address, 0, { from: taker });
await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: taker });
expect(
exWrapper.fillOrderAsync(order, taker, {
shouldThrowOnInsufficientBalanceOrAllowance: true,
}),
).to.be.rejectedWith(constants.REVERT);
await dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: taker,
});
});
@ -668,7 +679,9 @@ describe('Exchange', () => {
it('should throw if getBalance or getAllowance attempts to change state and \
shouldThrowOnInsufficientBalanceOrAllowance = false', async () => {
const maliciousToken = await deployer.deployAsync(ContractName.MaliciousToken);
await maliciousToken.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker });
await maliciousToken.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
from: taker,
});
order = await orderFactory.newSignedOrderAsync({
takerToken: maliciousToken.address,

7
packages/contracts/test/exchange/helpers.ts
View File

@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import ethUtil = require('ethereumjs-util');
import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
import { constants } from '../../util/constants';
import { ExchangeWrapper } from '../../util/exchange_wrapper';
import { Order } from '../../util/order';
@ -38,7 +39,11 @@ describe('Exchange', () => {
deployer.deployAsync(ContractName.DummyToken),
deployer.deployAsync(ContractName.DummyToken),
]);
const exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]);
const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
zrx.address,
tokenTransferProxy.address,
]);
const exchange = new ExchangeContract(exchangeInstance);
await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
const zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID });
exchangeWrapper = new ExchangeWrapper(exchange, zeroEx);

59
packages/contracts/test/exchange/wrapper.ts
View File

@ -6,6 +6,10 @@ import * as chai from 'chai';
import * as _ from 'lodash';
import * as Web3 from 'web3';
import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
import { TokenRegistryContract } from '../../src/contract_wrappers/generated/token_registry';
import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
import { Balances } from '../../util/balances';
import { constants } from '../../util/constants';
import { ExchangeWrapper } from '../../util/exchange_wrapper';
@ -30,12 +34,12 @@ describe('Exchange', () => {
const INIT_BAL = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
const INIT_ALLOW = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
let rep: Web3.ContractInstance;
let dgd: Web3.ContractInstance;
let zrx: Web3.ContractInstance;
let exchange: Web3.ContractInstance;
let tokenRegistry: Web3.ContractInstance;
let tokenTransferProxy: Web3.ContractInstance;
let rep: DummyTokenContract;
let dgd: DummyTokenContract;
let zrx: DummyTokenContract;
let exchange: ExchangeContract;
let tokenRegistry: TokenRegistryContract;
let tokenTransferProxy: TokenTransferProxyContract;
let balances: BalancesByOwner;
@ -47,15 +51,24 @@ describe('Exchange', () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
tokenOwner = accounts[0];
[maker, taker, feeRecipient] = accounts;
[rep, dgd, zrx] = await Promise.all([
const [repInstance, dgdInstance, zrxInstance] = await Promise.all([
deployer.deployAsync(ContractName.DummyToken),
deployer.deployAsync(ContractName.DummyToken),
deployer.deployAsync(ContractName.DummyToken),
]);
tokenRegistry = await deployer.deployAsync(ContractName.TokenRegistry);
tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]);
await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
rep = new DummyTokenContract(repInstance);
dgd = new DummyTokenContract(dgdInstance);
zrx = new DummyTokenContract(zrxInstance);
const tokenRegistryInstance = await deployer.deployAsync(ContractName.TokenRegistry);
tokenRegistry = new TokenRegistryContract(tokenRegistryInstance);
const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
zrx.address,
tokenTransferProxy.address,
]);
exchange = new ExchangeContract(exchangeInstance);
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
const zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID });
exWrapper = new ExchangeWrapper(exchange, zeroEx);
@ -74,18 +87,18 @@ describe('Exchange', () => {
orderFactory = new OrderFactory(web3Wrapper, defaultOrderParams);
dmyBalances = new Balances([rep, dgd, zrx], [maker, taker, feeRecipient]);
await Promise.all([
rep.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
rep.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
rep.setBalance(maker, INIT_BAL, { from: tokenOwner }),
rep.setBalance(taker, INIT_BAL, { from: tokenOwner }),
dgd.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
dgd.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
dgd.setBalance(maker, INIT_BAL, { from: tokenOwner }),
dgd.setBalance(taker, INIT_BAL, { from: tokenOwner }),
zrx.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
zrx.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
zrx.setBalance(maker, INIT_BAL, { from: tokenOwner }),
zrx.setBalance(taker, INIT_BAL, { from: tokenOwner }),
rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
rep.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }),
rep.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }),
dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
dgd.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }),
dgd.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }),
zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
zrx.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }),
zrx.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }),
]);
});
beforeEach(async () => {

70
packages/contracts/test/multi_sig_with_time_lock.ts
View File

@ -6,6 +6,8 @@ import * as chai from 'chai';
import * as Web3 from 'web3';
import * as multiSigWalletJSON from '../../build/contracts/MultiSigWalletWithTimeLock.json';
import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet';
import { MultiSigWalletWithTimeLockContract } from '../src/contract_wrappers/generated/multi_sig_wallet_with_time_lock';
import { artifacts } from '../util/artifacts';
import { constants } from '../util/constants';
import { MultiSigWrapper } from '../util/multi_sig_wrapper';
@ -30,12 +32,12 @@ describe('MultiSigWalletWithTimeLock', () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
owners = [accounts[0], accounts[1]];
});
const SIGNATURES_REQUIRED = 2;
const SECONDS_TIME_LOCKED = 10000;
const SIGNATURES_REQUIRED = new BigNumber(2);
const SECONDS_TIME_LOCKED = new BigNumber(10000);
let multiSig: Web3.ContractInstance;
let multiSig: MultiSigWalletWithTimeLockContract;
let multiSigWrapper: MultiSigWrapper;
let txId: number;
let txId: BigNumber;
let initialSecondsTimeLocked: number;
let rpc: RPC;
@ -52,20 +54,21 @@ describe('MultiSigWalletWithTimeLock', () => {
describe('changeTimeLock', () => {
describe('initially non-time-locked', async () => {
before('deploy a walet', async () => {
multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
const multiSigInstance = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
owners,
SIGNATURES_REQUIRED,
0,
]);
multiSigWrapper = new MultiSigWrapper(multiSig);
multiSig = new MultiSigWalletWithTimeLockContract(multiSigInstance);
multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract);
const secondsTimeLocked = await multiSig.secondsTimeLocked();
initialSecondsTimeLocked = secondsTimeLocked.toNumber();
});
it('should throw when not called by wallet', async () => {
return expect(multiSig.changeTimeLock(SECONDS_TIME_LOCKED, { from: owners[0] })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
multiSig.changeTimeLock.sendTransactionAsync(SECONDS_TIME_LOCKED, { from: owners[0] }),
).to.be.rejectedWith(constants.REVERT);
});
it('should throw without enough confirmations', async () => {
@ -74,7 +77,7 @@ describe('MultiSigWalletWithTimeLock', () => {
const dataParams = {
name: 'changeTimeLock',
abi: MULTI_SIG_ABI,
args: [SECONDS_TIME_LOCKED],
args: [SECONDS_TIME_LOCKED.toNumber()],
};
const txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams);
const subRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@ -82,10 +85,10 @@ describe('MultiSigWalletWithTimeLock', () => {
SubmissionContractEventArgs
>;
txId = log.args.transactionId.toNumber();
return expect(multiSig.executeTransaction(txId, { from: owners[0] })).to.be.rejectedWith(
constants.REVERT,
);
txId = log.args.transactionId;
return expect(
multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }),
).to.be.rejectedWith(constants.REVERT);
});
it('should set confirmation time with enough confirmations', async () => {
@ -94,7 +97,7 @@ describe('MultiSigWalletWithTimeLock', () => {
const dataParams = {
name: 'changeTimeLock',
abi: MULTI_SIG_ABI,
args: [SECONDS_TIME_LOCKED],
args: [SECONDS_TIME_LOCKED.toNumber()],
};
let txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams);
const subRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@ -102,15 +105,15 @@ describe('MultiSigWalletWithTimeLock', () => {
SubmissionContractEventArgs
>;
txId = log.args.transactionId.toNumber();
txHash = await multiSig.confirmTransaction(txId, { from: owners[1] });
txId = log.args.transactionId;
txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
expect(res.logs).to.have.length(2);
const blockNum = await web3Wrapper.getBlockNumberAsync();
const blockInfo = await web3Wrapper.getBlockAsync(blockNum);
const timestamp = new BigNumber(blockInfo.timestamp);
const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes.call(txId));
const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes(txId));
expect(timestamp).to.be.bignumber.equal(confirmationTimeBigNum);
});
@ -121,7 +124,7 @@ describe('MultiSigWalletWithTimeLock', () => {
const dataParams = {
name: 'changeTimeLock',
abi: MULTI_SIG_ABI,
args: [SECONDS_TIME_LOCKED],
args: [SECONDS_TIME_LOCKED.toNumber()],
};
let txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams);
const subRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@ -129,27 +132,28 @@ describe('MultiSigWalletWithTimeLock', () => {
SubmissionContractEventArgs
>;
txId = log.args.transactionId.toNumber();
txHash = await multiSig.confirmTransaction(txId, { from: owners[1] });
txId = log.args.transactionId;
txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
expect(initialSecondsTimeLocked).to.be.equal(0);
txHash = await multiSig.executeTransaction(txId, { from: owners[0] });
txHash = await multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] });
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
expect(res.logs).to.have.length(2);
const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked.call());
const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked());
expect(secondsTimeLocked).to.be.bignumber.equal(SECONDS_TIME_LOCKED);
});
});
describe('initially time-locked', async () => {
before('deploy a walet', async () => {
multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
const multiSigInstance = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
owners,
SIGNATURES_REQUIRED,
SECONDS_TIME_LOCKED,
]);
multiSigWrapper = new MultiSigWrapper(multiSig);
multiSig = new MultiSigWalletWithTimeLockContract(multiSigInstance);
multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract);
const secondsTimeLocked = await multiSig.secondsTimeLocked();
initialSecondsTimeLocked = secondsTimeLocked.toNumber();
@ -165,8 +169,8 @@ describe('MultiSigWalletWithTimeLock', () => {
const log = abiDecoder.tryToDecodeLogOrNoop(subRes.logs[0]) as LogWithDecodedArgs<
SubmissionContractEventArgs
>;
txId = log.args.transactionId.toNumber();
txHash = await multiSig.confirmTransaction(txId, {
txId = log.args.transactionId;
txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, {
from: owners[1],
});
const confRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@ -174,16 +178,16 @@ describe('MultiSigWalletWithTimeLock', () => {
});
const newSecondsTimeLocked = 0;
it('should throw if it has enough confirmations but is not past the time lock', async () => {
return expect(multiSig.executeTransaction(txId, { from: owners[0] })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }),
).to.be.rejectedWith(constants.REVERT);
});
it('should execute if it has enough confirmations and is past the time lock', async () => {
await rpc.increaseTimeAsync(SECONDS_TIME_LOCKED);
await multiSig.executeTransaction(txId, { from: owners[0] });
await rpc.increaseTimeAsync(SECONDS_TIME_LOCKED.toNumber());
await multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] });
const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked.call());
const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked());
expect(secondsTimeLocked).to.be.bignumber.equal(newSecondsTimeLocked);
});
});

85
packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts
View File

@ -5,6 +5,9 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import * as Web3 from 'web3';
import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet';
import { MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract } from '../src/contract_wrappers/generated/multi_sig_wallet_with_time_lock_except_remove_authorized_address';
import { TokenTransferProxyContract } from '../src/contract_wrappers/generated/token_transfer_proxy';
import { artifacts } from '../util/artifacts';
import { constants } from '../util/constants';
import { crypto } from '../util/crypto';
@ -35,8 +38,8 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
let authorizedAddress: string;
let unauthorizedAddress: string;
let tokenTransferProxy: Web3.ContractInstance;
let multiSig: Web3.ContractInstance;
let tokenTransferProxy: TokenTransferProxyContract;
let multiSig: MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract;
let multiSigWrapper: MultiSigWrapper;
let validDestination: string;
@ -45,20 +48,20 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
owners = [accounts[0], accounts[1]];
[authorizedAddress, unauthorizedAddress] = accounts;
const initialOwner = accounts[0];
tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
await tokenTransferProxy.addAuthorizedAddress(authorizedAddress, {
const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(authorizedAddress, {
from: initialOwner,
});
multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress, [
owners,
requiredApprovals,
SECONDS_TIME_LOCKED,
tokenTransferProxy.address,
]);
await tokenTransferProxy.transferOwnership(multiSig.address, {
const multiSigInstance = await deployer.deployAsync(
ContractName.MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress,
[owners, requiredApprovals, SECONDS_TIME_LOCKED, tokenTransferProxy.address],
);
multiSig = new MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract(multiSigInstance);
await tokenTransferProxy.transferOwnership.sendTransactionAsync(multiSig.address, {
from: initialOwner,
});
multiSigWrapper = new MultiSigWrapper(multiSig);
multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract);
validDestination = tokenTransferProxy.address;
});
beforeEach(async () => {
@ -71,12 +74,12 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
describe('isFunctionRemoveAuthorizedAddress', () => {
it('should throw if data is not for removeAuthorizedAddress', async () => {
const data = MultiSigWrapper.encodeFnArgs('addAuthorizedAddress', PROXY_ABI, [owners[0]]);
return expect(multiSig.isFunctionRemoveAuthorizedAddress.call(data)).to.be.rejectedWith(constants.REVERT);
return expect(multiSig.isFunctionRemoveAuthorizedAddress(data)).to.be.rejectedWith(constants.REVERT);
});
it('should return true if data is for removeAuthorizedAddress', async () => {
const data = MultiSigWrapper.encodeFnArgs('removeAuthorizedAddress', PROXY_ABI, [owners[0]]);
const isFunctionRemoveAuthorizedAddress = await multiSig.isFunctionRemoveAuthorizedAddress.call(data);
const isFunctionRemoveAuthorizedAddress = await multiSig.isFunctionRemoveAuthorizedAddress(data);
expect(isFunctionRemoveAuthorizedAddress).to.be.true();
});
});
@ -91,11 +94,11 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
const txId = log.args.transactionId.toString();
const txId = log.args.transactionId;
return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
).to.be.rejectedWith(constants.REVERT);
});
it('should throw if tx destination is not the tokenTransferProxy', async () => {
@ -109,14 +112,14 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
const txHash = await multiSigWrapper.submitTransactionAsync(invalidDestination, owners[0], dataParams);
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
const txId = log.args.transactionId.toString();
await multiSig.confirmTransaction(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed.call(txId);
const txId = log.args.transactionId;
await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed(txId);
expect(isConfirmed).to.be.true();
return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
).to.be.rejectedWith(constants.REVERT);
});
it('should throw if tx data is not for removeAuthorizedAddress', async () => {
@ -128,14 +131,14 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
const txId = log.args.transactionId.toString();
await multiSig.confirmTransaction(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed.call(txId);
const txId = log.args.transactionId;
await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed(txId);
expect(isConfirmed).to.be.true();
return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
).to.be.rejectedWith(constants.REVERT);
});
it('should execute removeAuthorizedAddress for valid tokenTransferProxy if fully confirmed', async () => {
@ -147,12 +150,12 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
const txId = log.args.transactionId.toString();
await multiSig.confirmTransaction(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed.call(txId);
const txId = log.args.transactionId;
await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed(txId);
expect(isConfirmed).to.be.true();
await multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] });
const isAuthorized = await tokenTransferProxy.authorized.call(authorizedAddress);
await multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] });
const isAuthorized = await tokenTransferProxy.authorized(authorizedAddress);
expect(isAuthorized).to.be.false();
});
@ -165,17 +168,17 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
const res = await zeroEx.awaitTransactionMinedAsync(txHash);
const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
const txId = log.args.transactionId.toString();
await multiSig.confirmTransaction(txId, { from: owners[1] });
const txId = log.args.transactionId;
await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
const isConfirmed = await multiSig.isConfirmed(txId);
expect(isConfirmed).to.be.true();
await multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] });
await multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] });
const tx = await multiSig.transactions(txId);
const isExecuted = tx[3];
expect(isExecuted).to.be.true();
return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
).to.be.rejectedWith(constants.REVERT);
});
});
});

55
packages/contracts/test/token_registry.ts
View File

@ -1,11 +1,13 @@
import { ZeroEx } from '0x.js';
import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
import { BigNumber } from '@0xproject/utils';
import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import ethUtil = require('ethereumjs-util');
import * as _ from 'lodash';
import * as Web3 from 'web3';
import { TokenRegistryContract } from '../src/contract_wrappers/generated/token_registry';
import { constants } from '../util/constants';
import { TokenRegWrapper } from '../util/token_registry_wrapper';
import { ContractName } from '../util/types';
@ -22,13 +24,14 @@ const blockchainLifecycle = new BlockchainLifecycle();
describe('TokenRegistry', () => {
let owner: string;
let notOwner: string;
let tokenReg: Web3.ContractInstance;
let tokenReg: TokenRegistryContract;
let tokenRegWrapper: TokenRegWrapper;
before(async () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
owner = accounts[0];
notOwner = accounts[1];
tokenReg = await deployer.deployAsync(ContractName.TokenRegistry);
const tokenRegInstance = await deployer.deployAsync(ContractName.TokenRegistry);
tokenReg = new TokenRegistryContract(tokenRegInstance);
tokenRegWrapper = new TokenRegWrapper(tokenReg);
});
beforeEach(async () => {
@ -132,12 +135,12 @@ describe('TokenRegistry', () => {
describe('setTokenName', () => {
it('should throw when not called by owner', async () => {
return expect(
tokenReg.setTokenName(token1.address, token2.name, { from: notOwner }),
tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: notOwner }),
).to.be.rejectedWith(constants.REVERT);
});
it('should change the token name when called by owner', async () => {
await tokenReg.setTokenName(token1.address, token2.name, {
await tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, {
from: owner,
});
const [newData, oldData] = await Promise.all([
@ -154,14 +157,14 @@ describe('TokenRegistry', () => {
it('should throw if the name already exists', async () => {
await tokenRegWrapper.addTokenAsync(token2, owner);
return expect(tokenReg.setTokenName(token1.address, token2.name, { from: owner })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: owner }),
).to.be.rejectedWith(constants.REVERT);
});
it('should throw if token does not exist', async () => {
return expect(
tokenReg.setTokenName(nullToken.address, token2.name, { from: owner }),
tokenReg.setTokenName.sendTransactionAsync(nullToken.address, token2.name, { from: owner }),
).to.be.rejectedWith(constants.REVERT);
});
});
@ -169,14 +172,14 @@ describe('TokenRegistry', () => {
describe('setTokenSymbol', () => {
it('should throw when not called by owner', async () => {
return expect(
tokenReg.setTokenSymbol(token1.address, token2.symbol, {
tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, {
from: notOwner,
}),
).to.be.rejectedWith(constants.REVERT);
});
it('should change the token symbol when called by owner', async () => {
await tokenReg.setTokenSymbol(token1.address, token2.symbol, { from: owner });
await tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, { from: owner });
const [newData, oldData] = await Promise.all([
tokenRegWrapper.getTokenBySymbolAsync(token2.symbol),
tokenRegWrapper.getTokenBySymbolAsync(token1.symbol),
@ -192,7 +195,7 @@ describe('TokenRegistry', () => {
await tokenRegWrapper.addTokenAsync(token2, owner);
return expect(
tokenReg.setTokenSymbol(token1.address, token2.symbol, {
tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, {
from: owner,
}),
).to.be.rejectedWith(constants.REVERT);
@ -200,7 +203,7 @@ describe('TokenRegistry', () => {
it('should throw if token does not exist', async () => {
return expect(
tokenReg.setTokenSymbol(nullToken.address, token2.symbol, {
tokenReg.setTokenSymbol.sendTransactionAsync(nullToken.address, token2.symbol, {
from: owner,
}),
).to.be.rejectedWith(constants.REVERT);
@ -209,15 +212,15 @@ describe('TokenRegistry', () => {
describe('removeToken', () => {
it('should throw if not called by owner', async () => {
const index = 0;
return expect(tokenReg.removeToken(token1.address, index, { from: notOwner })).to.be.rejectedWith(
constants.REVERT,
);
const index = new BigNumber(0);
return expect(
tokenReg.removeToken.sendTransactionAsync(token1.address, index, { from: notOwner }),
).to.be.rejectedWith(constants.REVERT);
});
it('should remove token metadata when called by owner', async () => {
const index = 0;
await tokenReg.removeToken(token1.address, index, {
const index = new BigNumber(0);
await tokenReg.removeToken.sendTransactionAsync(token1.address, index, {
from: owner,
});
const tokenData = await tokenRegWrapper.getTokenMetaDataAsync(token1.address);
@ -225,18 +228,18 @@ describe('TokenRegistry', () => {
});
it('should throw if token does not exist', async () => {
const index = 0;
return expect(tokenReg.removeToken(nullToken.address, index, { from: owner })).to.be.rejectedWith(
constants.REVERT,
);
const index = new BigNumber(0);
return expect(
tokenReg.removeToken.sendTransactionAsync(nullToken.address, index, { from: owner }),
).to.be.rejectedWith(constants.REVERT);
});
it('should throw if token at given index does not match address', async () => {
await tokenRegWrapper.addTokenAsync(token2, owner);
const incorrectIndex = 0;
return expect(tokenReg.removeToken(token2.address, incorrectIndex, { from: owner })).to.be.rejectedWith(
constants.REVERT,
);
const incorrectIndex = new BigNumber(0);
return expect(
tokenReg.removeToken.sendTransactionAsync(token2.address, incorrectIndex, { from: owner }),
).to.be.rejectedWith(constants.REVERT);
});
});
});

36
packages/contracts/test/token_transfer_proxy/auth.ts
View File

@ -3,6 +3,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import * as Web3 from 'web3';
import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
import { constants } from '../../util/constants';
import { ContractName } from '../../util/types';
import { chaiSetup } from '../utils/chai_setup';
@ -18,12 +19,13 @@ describe('TokenTransferProxy', () => {
let owner: string;
let notOwner: string;
let address: string;
let tokenTransferProxy: Web3.ContractInstance;
let tokenTransferProxy: TokenTransferProxyContract;
before(async () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
owner = address = accounts[0];
notOwner = accounts[1];
tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
});
beforeEach(async () => {
await blockchainLifecycle.startAsync();
@ -33,36 +35,36 @@ describe('TokenTransferProxy', () => {
});
describe('addAuthorizedAddress', () => {
it('should throw if not called by owner', async () => {
return expect(tokenTransferProxy.addAuthorizedAddress(notOwner, { from: notOwner })).to.be.rejectedWith(
constants.REVERT,
);
return expect(
tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(notOwner, { from: notOwner }),
).to.be.rejectedWith(constants.REVERT);
});
it('should allow owner to add an authorized address', async () => {
await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
const isAuthorized = await tokenTransferProxy.authorized(address);
expect(isAuthorized).to.be.true();
});
it('should throw if owner attempts to authorize a duplicate address', async () => {
await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
return expect(tokenTransferProxy.addAuthorizedAddress(address, { from: owner })).to.be.rejectedWith(
constants.REVERT,
);
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
return expect(
tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
).to.be.rejectedWith(constants.REVERT);
});
});
describe('removeAuthorizedAddress', () => {
it('should throw if not called by owner', async () => {
await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
return expect(
tokenTransferProxy.removeAuthorizedAddress(address, {
tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
from: notOwner,
}),
).to.be.rejectedWith(constants.REVERT);
});
it('should allow owner to remove an authorized address', async () => {
await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
await tokenTransferProxy.removeAuthorizedAddress(address, {
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
await tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
from: owner,
});
const isAuthorized = await tokenTransferProxy.authorized(address);
@ -71,7 +73,7 @@ describe('TokenTransferProxy', () => {
it('should throw if owner attempts to remove an address that is not authorized', async () => {
return expect(
tokenTransferProxy.removeAuthorizedAddress(address, {
tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
from: owner,
}),
).to.be.rejectedWith(constants.REVERT);
@ -82,14 +84,14 @@ describe('TokenTransferProxy', () => {
it('should return all authorized addresses', async () => {
const initial = await tokenTransferProxy.getAuthorizedAddresses();
expect(initial).to.have.length(0);
await tokenTransferProxy.addAuthorizedAddress(address, {
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, {
from: owner,
});
const afterAdd = await tokenTransferProxy.getAuthorizedAddresses();
expect(afterAdd).to.have.length(1);
expect(afterAdd).to.include(address);
await tokenTransferProxy.removeAuthorizedAddress(address, {
await tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
from: owner,
});
const afterRemove = await tokenTransferProxy.getAuthorizedAddresses();

51
packages/contracts/test/token_transfer_proxy/transfer_from.ts
View File

@ -1,8 +1,11 @@
import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
import { BigNumber } from '@0xproject/utils';
import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import * as Web3 from 'web3';
import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
import { Balances } from '../../util/balances';
import { constants } from '../../util/constants';
import { ContractName } from '../../util/types';
@ -19,29 +22,31 @@ describe('TokenTransferProxy', () => {
let accounts: string[];
let owner: string;
let notAuthorized: string;
const INIT_BAL = 100000000;
const INIT_ALLOW = 100000000;
const INIT_BAL = new BigNumber(100000000);
const INIT_ALLOW = new BigNumber(100000000);
let tokenTransferProxy: Web3.ContractInstance;
let rep: Web3.ContractInstance;
let tokenTransferProxy: TokenTransferProxyContract;
let rep: DummyTokenContract;
let dmyBalances: Balances;
before(async () => {
accounts = await web3Wrapper.getAvailableAddressesAsync();
owner = notAuthorized = accounts[0];
tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
rep = await deployer.deployAsync(ContractName.DummyToken);
const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
const repInstance = await deployer.deployAsync(ContractName.DummyToken);
rep = new DummyTokenContract(repInstance);
dmyBalances = new Balances([rep], [accounts[0], accounts[1]]);
await Promise.all([
rep.approve(tokenTransferProxy.address, INIT_ALLOW, {
rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, {
from: accounts[0],
}),
rep.setBalance(accounts[0], INIT_BAL, { from: owner }),
rep.approve(tokenTransferProxy.address, INIT_ALLOW, {
rep.setBalance.sendTransactionAsync(accounts[0], INIT_BAL, { from: owner }),
rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, {
from: accounts[1],
}),
rep.setBalance(accounts[1], INIT_BAL, { from: owner }),
rep.setBalance.sendTransactionAsync(accounts[1], INIT_BAL, { from: owner }),
]);
});
beforeEach(async () => {
@ -54,20 +59,34 @@ describe('TokenTransferProxy', () => {
describe('transferFrom', () => {
it('should throw when called by an unauthorized address', async () => {
expect(
tokenTransferProxy.transferFrom(rep.address, accounts[0], accounts[1], 1000, { from: notAuthorized }),
tokenTransferProxy.transferFrom.sendTransactionAsync(
rep.address,
accounts[0],
accounts[1],
new BigNumber(1000),
{
from: notAuthorized,
},
),
).to.be.rejectedWith(constants.REVERT);
});
it('should allow an authorized address to transfer', async () => {
const balances = await dmyBalances.getAsync();
await tokenTransferProxy.addAuthorizedAddress(notAuthorized, {
await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(notAuthorized, {
from: owner,
});
const transferAmt = 10000;
await tokenTransferProxy.transferFrom(rep.address, accounts[0], accounts[1], transferAmt, {
from: notAuthorized,
});
const transferAmt = new BigNumber(10000);
await tokenTransferProxy.transferFrom.sendTransactionAsync(
rep.address,
accounts[0],
accounts[1],
transferAmt,
{
from: notAuthorized,
},
);
const newBalances = await dmyBalances.getAsync();
expect(newBalances[accounts[0]][rep.address]).to.be.bignumber.equal(

22
packages/contracts/test/unlimited_allowance_token.ts
View File

@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import * as Web3 from 'web3';
import { DummyTokenContract } from '../src/contract_wrappers/generated/dummy_token';
import { constants } from '../util/constants';
import { ContractName } from '../util/types';
@ -27,14 +28,15 @@ describe('UnlimitedAllowanceToken', () => {
const MAX_MINT_VALUE = new BigNumber(100000000000000000000);
let tokenAddress: string;
let token: Web3.ContractInstance;
let token: DummyTokenContract;
before(async () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
owner = accounts[0];
spender = accounts[1];
token = await deployer.deployAsync(ContractName.DummyToken);
await token.mint(MAX_MINT_VALUE, { from: owner });
const tokenInstance = await deployer.deployAsync(ContractName.DummyToken);
token = new DummyTokenContract(tokenInstance);
await token.mint.sendTransactionAsync(MAX_MINT_VALUE, { from: owner });
tokenAddress = token.address;
});
beforeEach(async () => {
@ -47,7 +49,7 @@ describe('UnlimitedAllowanceToken', () => {
it('should throw if owner has insufficient balance', async () => {
const ownerBalance = await zeroEx.token.getBalanceAsync(tokenAddress, owner);
const amountToTransfer = ownerBalance.plus(1);
return expect(token.transfer.call(spender, amountToTransfer, { from: owner })).to.be.rejectedWith(
return expect(token.transfer.callAsync(spender, amountToTransfer, { from: owner })).to.be.rejectedWith(
constants.REVERT,
);
});
@ -67,7 +69,7 @@ describe('UnlimitedAllowanceToken', () => {
});
it('should return true on a 0 value transfer', async () => {
const didReturnTrue = await token.transfer.call(spender, 0, {
const didReturnTrue = await token.transfer.callAsync(spender, new BigNumber(0), {
from: owner,
});
expect(didReturnTrue).to.be.true();
@ -80,7 +82,7 @@ describe('UnlimitedAllowanceToken', () => {
const amountToTransfer = ownerBalance.plus(1);
await zeroEx.token.setAllowanceAsync(tokenAddress, owner, spender, amountToTransfer);
return expect(
token.transferFrom.call(owner, spender, amountToTransfer, {
token.transferFrom.callAsync(owner, spender, amountToTransfer, {
from: spender,
}),
).to.be.rejectedWith(constants.REVERT);
@ -95,15 +97,17 @@ describe('UnlimitedAllowanceToken', () => {
expect(spenderAllowanceIsInsufficient).to.be.true();
return expect(
token.transferFrom.call(owner, spender, amountToTransfer, {
token.transferFrom.callAsync(owner, spender, amountToTransfer, {
from: spender,
}),
).to.be.rejectedWith(constants.REVERT);
});
it('should return true on a 0 value transfer', async () => {
const amountToTransfer = 0;
const didReturnTrue = await token.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
const amountToTransfer = new BigNumber(0);
const didReturnTrue = await token.transferFrom.callAsync(owner, spender, amountToTransfer, {
from: spender,
});
expect(didReturnTrue).to.be.true();
});

2
packages/contracts/test/utils/deployer.ts
View File

@ -5,7 +5,7 @@ import * as path from 'path';
import { constants } from '../../util/constants';
const deployerOpts = {
artifactsDir: path.resolve('artifacts'),
artifactsDir: path.resolve('src', 'artifacts'),
jsonrpcPort: devConstants.RPC_PORT,
networkId: constants.TESTRPC_NETWORK_ID,
defaults: {

16
packages/contracts/test/zrx_token.ts
View File

@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
import * as chai from 'chai';
import * as Web3 from 'web3';
import { ZRXTokenContract } from '../src/contract_wrappers/generated/zrx_token';
import { constants } from '../util/constants';
import { ContractName } from '../util/types';
@ -24,7 +25,7 @@ describe('ZRXToken', () => {
let MAX_UINT: BigNumber;
let zrx: Web3.ContractInstance;
let zrx: ZRXTokenContract;
let zrxAddress: string;
before(async () => {
@ -34,7 +35,8 @@ describe('ZRXToken', () => {
zeroEx = new ZeroEx(web3.currentProvider, {
networkId: constants.TESTRPC_NETWORK_ID,
});
zrx = await deployer.deployAsync(ContractName.ZRXToken);
const zrxInstance = await deployer.deployAsync(ContractName.ZRXToken);
zrx = new ZRXTokenContract(zrxInstance);
zrxAddress = zrx.address;
MAX_UINT = zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
});
@ -94,7 +96,7 @@ describe('ZRXToken', () => {
});
it('should return true on a 0 value transfer', async () => {
const didReturnTrue = await zrx.transfer.call(spender, 0, {
const didReturnTrue = await zrx.transfer.callAsync(spender, new BigNumber(0), {
from: owner,
});
expect(didReturnTrue).to.be.true();
@ -108,7 +110,7 @@ describe('ZRXToken', () => {
await zeroEx.token.setAllowanceAsync(zrxAddress, owner, spender, amountToTransfer, {
gasLimit: constants.MAX_TOKEN_APPROVE_GAS,
});
const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
expect(didReturnTrue).to.be.false();
});
@ -120,13 +122,13 @@ describe('ZRXToken', () => {
const spenderAllowanceIsInsufficient = spenderAllowance.cmp(amountToTransfer) < 0;
expect(spenderAllowanceIsInsufficient).to.be.true();
const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
expect(didReturnTrue).to.be.false();
});
it('should return true on a 0 value transfer', async () => {
const amountToTransfer = 0;
const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
const amountToTransfer = new BigNumber(0);
const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
expect(didReturnTrue).to.be.true();
});

5
packages/contracts/tsconfig.json
View File

@ -4,6 +4,7 @@
"outDir": "lib",
"baseUrl": ".",
"declaration": false,
"noImplicitThis": false,
"allowJs": true
},
"include": [
@ -14,10 +15,10 @@
"../../node_modules/types-ethereumjs-util/index.d.ts",
"../../node_modules/types-bn/index.d.ts",
"./globals.d.ts",
"./src/**/*",
"./util/**/*",
"./test/**/*",
"./migrations/**/*",
"./deploy/**/*"
"./migrations/**/*"
],
"exclude": ["./deploy/solc/solc_bin"]
}

20
packages/contracts/util/artifacts.ts
View File

@ -1,13 +1,13 @@
import * as DummyTokenArtifact from '../artifacts/DummyToken.json';
import * as ExchangeArtifact from '../artifacts/Exchange.json';
import * as MaliciousTokenArtifact from '../artifacts/MaliciousToken.json';
import * as MultiSigWalletWithTimeLockArtifact from '../artifacts/MultiSigWalletWithTimeLock.json';
import * as MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact from '../artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json';
import * as TokenArtifact from '../artifacts/Token.json';
import * as TokenRegistryArtifact from '../artifacts/TokenRegistry.json';
import * as TokenTransferProxyArtifact from '../artifacts/TokenTransferProxy.json';
import * as EtherTokenArtifact from '../artifacts/WETH9.json';
import * as ZRXArtifact from '../artifacts/ZRXToken.json';
import * as DummyTokenArtifact from '../src/artifacts/DummyToken.json';
import * as ExchangeArtifact from '../src/artifacts/Exchange.json';
import * as MaliciousTokenArtifact from '../src/artifacts/MaliciousToken.json';
import * as MultiSigWalletWithTimeLockArtifact from '../src/artifacts/MultiSigWalletWithTimeLock.json';
import * as MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact from '../src/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json';
import * as TokenArtifact from '../src/artifacts/Token.json';
import * as TokenRegistryArtifact from '../src/artifacts/TokenRegistry.json';
import * as TokenTransferProxyArtifact from '../src/artifacts/TokenTransferProxy.json';
import * as EtherTokenArtifact from '../src/artifacts/WETH9.json';
import * as ZRXArtifact from '../src/artifacts/ZRXToken.json';
import { Artifact } from './types';

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

@ -2,12 +2,14 @@ import { BigNumber } from '@0xproject/utils';
import * as _ from 'lodash';
import * as Web3 from 'web3';
import { DummyTokenContract } from '../src/contract_wrappers/generated/dummy_token';
import { BalancesByOwner } from './types';
export class Balances {
private _tokenContractInstances: Web3.ContractInstance[];
private _tokenContractInstances: DummyTokenContract[];
private _ownerAddresses: string[];
constructor(tokenContractInstances: Web3.ContractInstance[], ownerAddresses: string[]) {
constructor(tokenContractInstances: DummyTokenContract[], ownerAddresses: string[]) {
this._tokenContractInstances = tokenContractInstances;
this._ownerAddresses = ownerAddresses;
}

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

@ -3,14 +3,16 @@ import { BigNumber } from '@0xproject/utils';
import * as _ from 'lodash';
import * as Web3 from 'web3';
import { ExchangeContract } from '../src/contract_wrappers/generated/exchange';
import { formatters } from './formatters';
import { Order } from './order';
export class ExchangeWrapper {
private _exchange: Web3.ContractInstance;
private _exchange: ExchangeContract;
private _zeroEx: ZeroEx;
constructor(exchangeContractInstance: Web3.ContractInstance, zeroEx: ZeroEx) {
this._exchange = exchangeContractInstance;
constructor(exchangeContract: ExchangeContract, zeroEx: ZeroEx) {
this._exchange = exchangeContract;
this._zeroEx = zeroEx;
}
public async fillOrderAsync(
@ -23,14 +25,14 @@ export class ExchangeWrapper {
): Promise<TransactionReceiptWithDecodedLogs> {
const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
const txHash = await this._exchange.fillOrder(
const txHash = await this._exchange.fillOrder.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmount,
params.shouldThrowOnInsufficientBalanceOrAllowance,
params.v,
params.r,
params.s,
params.v as number,
params.r as string,
params.s as string,
{ from },
);
const tx = await this._zeroEx.awaitTransactionMinedAsync(txHash);
@ -44,7 +46,7 @@ export class ExchangeWrapper {
opts: { cancelTakerTokenAmount?: BigNumber } = {},
): Promise<TransactionReceiptWithDecodedLogs> {
const params = order.createCancel(opts.cancelTakerTokenAmount);
const txHash = await this._exchange.cancelOrder(
const txHash = await this._exchange.cancelOrder.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.cancelTakerTokenAmount,
@ -62,13 +64,13 @@ export class ExchangeWrapper {
): Promise<TransactionReceiptWithDecodedLogs> {
const shouldThrowOnInsufficientBalanceOrAllowance = true;
const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
const txHash = await this._exchange.fillOrKillOrder(
const txHash = await this._exchange.fillOrKillOrder.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmount,
params.v,
params.r,
params.s,
params.v as number,
params.r as string,
params.s as string,
{ from },
);
const tx = await this._zeroEx.awaitTransactionMinedAsync(txHash);
@ -90,7 +92,7 @@ export class ExchangeWrapper {
shouldThrowOnInsufficientBalanceOrAllowance,
opts.fillTakerTokenAmounts,
);
const txHash = await this._exchange.batchFillOrders(
const txHash = await this._exchange.batchFillOrders.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmounts,
@ -116,7 +118,7 @@ export class ExchangeWrapper {
shouldThrowOnInsufficientBalanceOrAllowance,
opts.fillTakerTokenAmounts,
);
const txHash = await this._exchange.batchFillOrKillOrders(
const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmounts,
@ -141,7 +143,7 @@ export class ExchangeWrapper {
shouldThrowOnInsufficientBalanceOrAllowance,
opts.fillTakerTokenAmount,
);
const txHash = await this._exchange.fillOrdersUpTo(
const txHash = await this._exchange.fillOrdersUpTo.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.fillTakerTokenAmount,
@ -162,7 +164,7 @@ export class ExchangeWrapper {
opts: { cancelTakerTokenAmounts?: BigNumber[] } = {},
): Promise<TransactionReceiptWithDecodedLogs> {
const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
const txHash = await this._exchange.batchCancelOrders(
const txHash = await this._exchange.batchCancelOrders.sendTransactionAsync(
params.orderAddresses,
params.orderValues,
params.cancelTakerTokenAmounts,
@ -182,10 +184,10 @@ export class ExchangeWrapper {
public async isValidSignatureAsync(order: Order): Promise<boolean> {
const isValidSignature = await this._exchange.isValidSignature(
order.params.maker,
order.params.orderHashHex,
order.params.v,
order.params.r,
order.params.s,
order.params.orderHashHex as string,
order.params.v as number,
order.params.r as string,
order.params.s as string,
);
return isValidSignature;
}

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

@ -1,12 +1,15 @@
import { BigNumber } from '@0xproject/utils';
import ABI = require('ethereumjs-abi');
import ethUtil = require('ethereumjs-util');
import * as _ from 'lodash';
import * as Web3 from 'web3';
import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet';
import { TransactionDataParams } from './types';
export class MultiSigWrapper {
private _multiSig: Web3.ContractInstance;
private _multiSig: MultiSigWalletContract;
public static encodeFnArgs(name: string, abi: Web3.AbiDefinition[], args: any[]) {
const abiEntity = _.find(abi, { name }) as Web3.MethodAbi;
if (_.isUndefined(abiEntity)) {
@ -21,18 +24,18 @@ export class MultiSigWrapper {
});
return funcSig + argsData.join('');
}
constructor(multiSigContractInstance: Web3.ContractInstance) {
this._multiSig = multiSigContractInstance;
constructor(multiSigContract: MultiSigWalletContract) {
this._multiSig = multiSigContract;
}
public async submitTransactionAsync(
destination: string,
from: string,
dataParams: TransactionDataParams,
value: number = 0,
value: BigNumber = new BigNumber(0),
) {
const { name, abi, args = [] } = dataParams;
const encoded = MultiSigWrapper.encodeFnArgs(name, abi, args);
return this._multiSig.submitTransaction(destination, value, encoded, {
return this._multiSig.submitTransaction.sendTransactionAsync(destination, value, encoded, {
from,
});
}

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

@ -1,15 +1,17 @@
import * as Web3 from 'web3';
import { TokenRegistryContract } from '../src/contract_wrappers/generated/token_registry';
import { Token } from './types';
export class TokenRegWrapper {
private _tokenReg: Web3.ContractInstance;
constructor(tokenRegContractInstance: Web3.ContractInstance) {
this._tokenReg = tokenRegContractInstance;
private _tokenReg: TokenRegistryContract;
constructor(tokenRegContract: TokenRegistryContract) {
this._tokenReg = tokenRegContract;
}
public addTokenAsync(token: Token, from: string) {
const tx = this._tokenReg.addToken(
token.address,
public async addTokenAsync(token: Token, from: string) {
const tx = this._tokenReg.addToken.sendTransactionAsync(
token.address as string,
token.name,
token.symbol,
token.decimals,

5
packages/testnet-faucets/src/ts/request_queue.ts
View File

@ -44,11 +44,6 @@ export class RequestQueue {
this._processNextRequestFireAndForgetAsync(recipientAddress);
}, this._queueIntervalMs);
}
protected _stop() {
if (!_.isUndefined(this._queueIntervalId)) {
clearInterval(this._queueIntervalId);
}
}
// tslint:disable-next-line:prefer-function-over-method
protected async _processNextRequestFireAndForgetAsync(recipientAddress: string) {
throw new Error('Expected processNextRequestFireAndForgetAsync to be implemented by a subclass');

3
packages/testnet-faucets/tsconfig.json
View File

@ -1,7 +1,8 @@
{
"extends": "../../tsconfig",
"compilerOptions": {
"outDir": "lib"
"outDir": "lib",
"strictPropertyInitialization": false
},
"include": [
"./src/ts/**/*",