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

Rename variables, create private validation methods in token wrappers

Browse Source
This commit is contained in:
Amir Bandeali
2018-04-23 23:23:01 -07:00
parent 32e77753b5
commit 27a44f0e77
8 changed files with 308 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
packages/contracts/src/utils/erc20_wrapper.ts
View File

@@ -14,57 +14,53 @@ export class ERC20Wrapper {
private _contractOwnerAddress: string; private _contractOwnerAddress: string;
private _deployer: Deployer; private _deployer: Deployer;
private _provider: Provider; private _provider: Provider;
private _dummyERC20TokenContracts?: DummyERC20TokenContract[]; private _dummyTokenContracts?: DummyERC20TokenContract[];
private _erc20ProxyContract?: ERC20ProxyContract; private _proxyContract?: ERC20ProxyContract;
constructor(deployer: Deployer, provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) { constructor(deployer: Deployer, provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
this._deployer = deployer; this._deployer = deployer;
this._provider = provider; this._provider = provider;
this._tokenOwnerAddresses = tokenOwnerAddresses; this._tokenOwnerAddresses = tokenOwnerAddresses;
this._contractOwnerAddress = contractOwnerAddress; this._contractOwnerAddress = contractOwnerAddress;
} }
public async deployDummyERC20TokensAsync(): Promise<DummyERC20TokenContract[]> { public async deployDummyTokensAsync(): Promise<DummyERC20TokenContract[]> {
const tokenContractInstances = await Promise.all( const tokenContractInstances = await Promise.all(
_.map(_.range(constants.NUM_DUMMY_ERC20_TO_DEPLOY), () => _.times(constants.NUM_DUMMY_ERC20_TO_DEPLOY, () =>
this._deployer.deployAsync(ContractName.DummyERC20Token, constants.DUMMY_ERC20_TOKEN_ARGS), this._deployer.deployAsync(ContractName.DummyERC20Token, constants.DUMMY_ERC20_TOKEN_ARGS),
), ),
); );
this._dummyERC20TokenContracts = _.map( this._dummyTokenContracts = _.map(
tokenContractInstances, tokenContractInstances,
tokenContractInstance => tokenContractInstance =>
new DummyERC20TokenContract(tokenContractInstance.abi, tokenContractInstance.address, this._provider), new DummyERC20TokenContract(tokenContractInstance.abi, tokenContractInstance.address, this._provider),
); );
return this._dummyERC20TokenContracts; return this._dummyTokenContracts;
} }
public async deployERC20ProxyAsync(): Promise<ERC20ProxyContract> { public async deployProxyAsync(): Promise<ERC20ProxyContract> {
const proxyContractInstance = await this._deployer.deployAsync(ContractName.ERC20Proxy); const proxyContractInstance = await this._deployer.deployAsync(ContractName.ERC20Proxy);
this._erc20ProxyContract = new ERC20ProxyContract( this._proxyContract = new ERC20ProxyContract(
proxyContractInstance.abi, proxyContractInstance.abi,
proxyContractInstance.address, proxyContractInstance.address,
this._provider, this._provider,
); );
return this._erc20ProxyContract; return this._proxyContract;
} }
public async setBalancesAndAllowancesAsync() { public async setBalancesAndAllowancesAsync() {
if (_.isUndefined(this._dummyERC20TokenContracts)) { this._validateDummyTokenContractsExistOrThrow();
throw new Error('Dummy ERC20 tokens not yet deployed, please call "deployDummyERC20TokensAsync"'); this._validateProxyContractExistsOrThrow();
} const setBalancePromises: Array<Promise<string>> = [];
if (_.isUndefined(this._erc20ProxyContract)) { const setAllowancePromises: Array<Promise<string>> = [];
throw new Error('ERC20 proxy contract not yet deployed, please call "deployERC20ProxyAsync"'); _.forEach(this._dummyTokenContracts, dummyTokenContract => {
}
const setBalancePromises: any[] = [];
const setAllowancePromises: any[] = [];
_.forEach(this._dummyERC20TokenContracts, dummyERC20TokenContract => {
_.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => { _.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => {
setBalancePromises.push( setBalancePromises.push(
dummyERC20TokenContract.setBalance.sendTransactionAsync( dummyTokenContract.setBalance.sendTransactionAsync(
tokenOwnerAddress, tokenOwnerAddress,
constants.INITIAL_ERC20_BALANCE, constants.INITIAL_ERC20_BALANCE,
{ from: this._contractOwnerAddress }, { from: this._contractOwnerAddress },
), ),
); );
setAllowancePromises.push( setAllowancePromises.push(
dummyERC20TokenContract.approve.sendTransactionAsync( dummyTokenContract.approve.sendTransactionAsync(
(this._erc20ProxyContract as ERC20ProxyContract).address, (this._proxyContract as ERC20ProxyContract).address,
constants.INITIAL_ERC20_ALLOWANCE, constants.INITIAL_ERC20_ALLOWANCE,
{ from: tokenOwnerAddress }, { from: tokenOwnerAddress },
), ),
@@ -74,18 +70,16 @@ export class ERC20Wrapper {
await Promise.all([...setBalancePromises, ...setAllowancePromises]); await Promise.all([...setBalancePromises, ...setAllowancePromises]);
} }
public async getBalancesAsync(): Promise<ERC20BalancesByOwner> { public async getBalancesAsync(): Promise<ERC20BalancesByOwner> {
if (_.isUndefined(this._dummyERC20TokenContracts)) { this._validateDummyTokenContractsExistOrThrow();
throw new Error('Dummy ERC20 tokens not yet deployed, please call "deployDummyTokensAsync"');
}
const balancesByOwner: ERC20BalancesByOwner = {}; const balancesByOwner: ERC20BalancesByOwner = {};
const balancePromises: any[] = []; const balancePromises: Array<Promise<BigNumber>> = [];
const balanceInfo: Array<{ tokenOwnerAddress: string; tokenAddress: string }> = []; const balanceInfo: Array<{ tokenOwnerAddress: string; tokenAddress: string }> = [];
_.forEach(this._dummyERC20TokenContracts, dummyERC20TokenContract => { _.forEach(this._dummyTokenContracts, dummyTokenContract => {
_.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => { _.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => {
balancePromises.push(dummyERC20TokenContract.balanceOf.callAsync(tokenOwnerAddress)); balancePromises.push(dummyTokenContract.balanceOf.callAsync(tokenOwnerAddress));
balanceInfo.push({ balanceInfo.push({
tokenOwnerAddress, tokenOwnerAddress,
tokenAddress: dummyERC20TokenContract.address, tokenAddress: dummyTokenContract.address,
}); });
}); });
}); });
@@ -105,10 +99,17 @@ export class ERC20Wrapper {
return this._tokenOwnerAddresses; return this._tokenOwnerAddresses;
} }
public getTokenAddresses(): string[] { public getTokenAddresses(): string[] {
const tokenAddresses = _.map( const tokenAddresses = _.map(this._dummyTokenContracts, dummyTokenContract => dummyTokenContract.address);
this._dummyERC20TokenContracts,
dummyERC20TokenContract => dummyERC20TokenContract.address,
);
return tokenAddresses; return tokenAddresses;
} }
private _validateDummyTokenContractsExistOrThrow() {
if (_.isUndefined(this._dummyTokenContracts)) {
throw new Error('Dummy ERC20 tokens not yet deployed, please call "deployDummyTokensAsync"');
}
}
private _validateProxyContractExistsOrThrow() {
if (_.isUndefined(this._proxyContract)) {
throw new Error('ERC20 proxy contract not yet deployed, please call "deployProxyAsync"');
}
}
} }

126
packages/contracts/src/utils/erc721_wrapper.ts
View File

@@ -8,84 +8,74 @@ import { DummyERC721TokenContract } from '../contract_wrappers/generated/dummy_e
import { ERC721ProxyContract } from '../contract_wrappers/generated/e_r_c721_proxy'; import { ERC721ProxyContract } from '../contract_wrappers/generated/e_r_c721_proxy';
import { constants } from './constants'; import { constants } from './constants';
import { ContractName, ERC721BalancesByOwner } from './types'; import { ContractName, ERC721TokenIdsByOwner } from './types';
export class ERC721Wrapper { export class ERC721Wrapper {
private _tokenOwnerAddresses: string[]; private _tokenOwnerAddresses: string[];
private _contractOwnerAddress: string; private _contractOwnerAddress: string;
private _deployer: Deployer; private _deployer: Deployer;
private _provider: Provider; private _provider: Provider;
private _dummyERC721TokenContracts?: DummyERC721TokenContract[]; private _dummyTokenContracts?: DummyERC721TokenContract[];
private _erc721ProxyContract?: ERC721ProxyContract; private _proxyContract?: ERC721ProxyContract;
private _initialERC721BalancesByOwner: ERC721BalancesByOwner = {}; private _initialTokenIdsByOwner: ERC721TokenIdsByOwner = {};
constructor(deployer: Deployer, provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) { constructor(deployer: Deployer, provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
this._deployer = deployer; this._deployer = deployer;
this._provider = provider; this._provider = provider;
this._tokenOwnerAddresses = tokenOwnerAddresses; this._tokenOwnerAddresses = tokenOwnerAddresses;
this._contractOwnerAddress = contractOwnerAddress; this._contractOwnerAddress = contractOwnerAddress;
} }
public async deployDummyERC721TokensAsync(): Promise<DummyERC721TokenContract[]> { public async deployDummyTokensAsync(): Promise<DummyERC721TokenContract[]> {
const tokenContractInstances = await Promise.all( const tokenContractInstances = await Promise.all(
_.map(_.range(constants.NUM_DUMMY_ERC721_TO_DEPLOY), () => _.times(constants.NUM_DUMMY_ERC721_TO_DEPLOY, () =>
this._deployer.deployAsync(ContractName.DummyERC721Token, constants.DUMMY_ERC721_TOKEN_ARGS), this._deployer.deployAsync(ContractName.DummyERC721Token, constants.DUMMY_ERC721_TOKEN_ARGS),
), ),
); );
this._dummyERC721TokenContracts = _.map( this._dummyTokenContracts = _.map(
tokenContractInstances, tokenContractInstances,
tokenContractInstance => tokenContractInstance =>
new DummyERC721TokenContract(tokenContractInstance.abi, tokenContractInstance.address, this._provider), new DummyERC721TokenContract(tokenContractInstance.abi, tokenContractInstance.address, this._provider),
); );
return this._dummyERC721TokenContracts; return this._dummyTokenContracts;
} }
public async deployERC721ProxyAsync(): Promise<ERC721ProxyContract> { public async deployProxyAsync(): Promise<ERC721ProxyContract> {
const proxyContractInstance = await this._deployer.deployAsync(ContractName.ERC721Proxy); const proxyContractInstance = await this._deployer.deployAsync(ContractName.ERC721Proxy);
this._erc721ProxyContract = new ERC721ProxyContract( this._proxyContract = new ERC721ProxyContract(
proxyContractInstance.abi, proxyContractInstance.abi,
proxyContractInstance.address, proxyContractInstance.address,
this._provider, this._provider,
); );
return this._erc721ProxyContract; return this._proxyContract;
} }
public async setBalancesAndAllowancesAsync() { public async setBalancesAndAllowancesAsync() {
if (_.isUndefined(this._dummyERC721TokenContracts)) { this._validateDummyTokenContractsExistOrThrow();
throw new Error('Dummy ERC721 tokens not yet deployed, please call "deployDummyERC721TokensAsync"'); this._validateProxyContractExistsOrThrow();
} const setBalancePromises: Array<Promise<string>> = [];
if (_.isUndefined(this._erc721ProxyContract)) { const setAllowancePromises: Array<Promise<string>> = [];
throw new Error('ERC721 proxy contract not yet deployed, please call "deployERC721ProxyAsync"'); this._initialTokenIdsByOwner = {};
} _.forEach(this._dummyTokenContracts, dummyTokenContract => {
const setBalancePromises: any[] = [];
const setAllowancePromises: any[] = [];
this._initialERC721BalancesByOwner = {};
_.forEach(this._dummyERC721TokenContracts, dummyERC721TokenContract => {
_.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => { _.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => {
_.forEach(_.range(constants.NUM_ERC721_TOKENS_TO_MINT), () => { _.forEach(_.range(constants.NUM_ERC721_TOKENS_TO_MINT), () => {
const tokenId = ZeroEx.generatePseudoRandomSalt(); const tokenId = ZeroEx.generatePseudoRandomSalt();
setBalancePromises.push( setBalancePromises.push(
dummyERC721TokenContract.mint.sendTransactionAsync(tokenOwnerAddress, tokenId, { dummyTokenContract.mint.sendTransactionAsync(tokenOwnerAddress, tokenId, {
from: this._contractOwnerAddress, from: this._contractOwnerAddress,
}), }),
); );
if (_.isUndefined(this._initialERC721BalancesByOwner[tokenOwnerAddress])) { if (_.isUndefined(this._initialTokenIdsByOwner[tokenOwnerAddress])) {
this._initialERC721BalancesByOwner[tokenOwnerAddress] = { this._initialTokenIdsByOwner[tokenOwnerAddress] = {
[dummyERC721TokenContract.address]: [], [dummyTokenContract.address]: [],
}; };
} }
if ( if (_.isUndefined(this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address])) {
_.isUndefined( this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address] = [];
this._initialERC721BalancesByOwner[tokenOwnerAddress][dummyERC721TokenContract.address],
)
) {
this._initialERC721BalancesByOwner[tokenOwnerAddress][dummyERC721TokenContract.address] = [];
} }
this._initialERC721BalancesByOwner[tokenOwnerAddress][dummyERC721TokenContract.address].push( this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address].push(tokenId);
tokenId,
);
}); });
const approval = true; const shouldApprove = true;
setAllowancePromises.push( setAllowancePromises.push(
dummyERC721TokenContract.setApprovalForAll.sendTransactionAsync( dummyTokenContract.setApprovalForAll.sendTransactionAsync(
(this._erc721ProxyContract as ERC721ProxyContract).address, (this._proxyContract as ERC721ProxyContract).address,
approval, shouldApprove,
{ from: tokenOwnerAddress }, { from: tokenOwnerAddress },
), ),
); );
@@ -93,28 +83,22 @@ export class ERC721Wrapper {
}); });
await Promise.all([...setBalancePromises, ...setAllowancePromises]); await Promise.all([...setBalancePromises, ...setAllowancePromises]);
} }
public async getBalancesAsync(): Promise<ERC721BalancesByOwner> { public async getBalancesAsync(): Promise<ERC721TokenIdsByOwner> {
if (_.isUndefined(this._dummyERC721TokenContracts)) { this._validateDummyTokenContractsExistOrThrow();
throw new Error('Dummy ERC721 tokens not yet deployed, please call "deployDummyERC721TokensAsync"'); this._validateBalancesAndAllowancesSetOrThrow();
} const tokenIdsByOwner: ERC721TokenIdsByOwner = {};
if (_.keys(this._initialERC721BalancesByOwner).length === 0) { const tokenOwnerPromises: Array<Promise<string>> = [];
throw new Error(
'Dummy ERC721 balances and allowances not yet set, please call "setBalancesAndAllowancesAsync"',
);
}
const balancesByOwner: ERC721BalancesByOwner = {};
const tokenOwnerPromises: any[] = [];
const tokenInfo: Array<{ tokenId: BigNumber; tokenAddress: string }> = []; const tokenInfo: Array<{ tokenId: BigNumber; tokenAddress: string }> = [];
_.forEach(this._dummyERC721TokenContracts, dummyERC721TokenContract => { _.forEach(this._dummyTokenContracts, dummyTokenContract => {
_.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => { _.forEach(this._tokenOwnerAddresses, tokenOwnerAddress => {
const initialTokenOwnerIds = this._initialERC721BalancesByOwner[tokenOwnerAddress][ const initialTokenOwnerIds = this._initialTokenIdsByOwner[tokenOwnerAddress][
dummyERC721TokenContract.address dummyTokenContract.address
]; ];
_.forEach(initialTokenOwnerIds, tokenId => { _.forEach(initialTokenOwnerIds, tokenId => {
tokenOwnerPromises.push(dummyERC721TokenContract.ownerOf.callAsync(tokenId)); tokenOwnerPromises.push(dummyTokenContract.ownerOf.callAsync(tokenId));
tokenInfo.push({ tokenInfo.push({
tokenId, tokenId,
tokenAddress: dummyERC721TokenContract.address, tokenAddress: dummyTokenContract.address,
}); });
}); });
}); });
@@ -123,26 +107,40 @@ export class ERC721Wrapper {
_.forEach(tokenOwnerAddresses, (tokenOwnerAddress, ownerIndex) => { _.forEach(tokenOwnerAddresses, (tokenOwnerAddress, ownerIndex) => {
const tokenAddress = tokenInfo[ownerIndex].tokenAddress; const tokenAddress = tokenInfo[ownerIndex].tokenAddress;
const tokenId = tokenInfo[ownerIndex].tokenId; const tokenId = tokenInfo[ownerIndex].tokenId;
if (_.isUndefined(balancesByOwner[tokenOwnerAddress])) { if (_.isUndefined(tokenIdsByOwner[tokenOwnerAddress])) {
balancesByOwner[tokenOwnerAddress] = { tokenIdsByOwner[tokenOwnerAddress] = {
[tokenAddress]: [], [tokenAddress]: [],
}; };
} }
if (_.isUndefined(balancesByOwner[tokenOwnerAddress][tokenAddress])) { if (_.isUndefined(tokenIdsByOwner[tokenOwnerAddress][tokenAddress])) {
balancesByOwner[tokenOwnerAddress][tokenAddress] = []; tokenIdsByOwner[tokenOwnerAddress][tokenAddress] = [];
} }
balancesByOwner[tokenOwnerAddress][tokenAddress].push(tokenId); tokenIdsByOwner[tokenOwnerAddress][tokenAddress].push(tokenId);
}); });
return balancesByOwner; return tokenIdsByOwner;
} }
public getTokenOwnerAddresses(): string[] { public getTokenOwnerAddresses(): string[] {
return this._tokenOwnerAddresses; return this._tokenOwnerAddresses;
} }
public getTokenAddresses(): string[] { public getTokenAddresses(): string[] {
const tokenAddresses = _.map( const tokenAddresses = _.map(this._dummyTokenContracts, dummyTokenContract => dummyTokenContract.address);
this._dummyERC721TokenContracts,
dummyERC721TokenContract => dummyERC721TokenContract.address,
);
return tokenAddresses; return tokenAddresses;
} }
private _validateDummyTokenContractsExistOrThrow() {
if (_.isUndefined(this._dummyTokenContracts)) {
throw new Error('Dummy ERC721 tokens not yet deployed, please call "deployDummyTokensAsync"');
}
}
private _validateProxyContractExistsOrThrow() {
if (_.isUndefined(this._proxyContract)) {
throw new Error('ERC721 proxy contract not yet deployed, please call "deployProxyAsync"');
}
}
private _validateBalancesAndAllowancesSetOrThrow() {
if (_.keys(this._initialTokenIdsByOwner).length === 0) {
throw new Error(
'Dummy ERC721 balances and allowances not yet set, please call "setBalancesAndAllowancesAsync"',
);
}
}
} }

2
packages/contracts/src/utils/types.ts
View File

@@ -7,7 +7,7 @@ export interface ERC20BalancesByOwner {
}; };
} }
export interface ERC721BalancesByOwner { export interface ERC721TokenIdsByOwner {
[ownerAddress: string]: { [ownerAddress: string]: {
[tokenAddress: string]: BigNumber[]; [tokenAddress: string]: BigNumber[];
}; };

22
packages/contracts/test/asset_proxy_dispatcher/dispatcher.ts
View File

@@ -29,7 +29,7 @@ describe('AssetProxyDispatcher', () => {
let makerAddress: string; let makerAddress: string;
let takerAddress: string; let takerAddress: string;
let zrx: DummyERC20TokenContract; let zrxToken: DummyERC20TokenContract;
let erc20Proxy: ERC20ProxyContract; let erc20Proxy: ERC20ProxyContract;
let erc721Proxy: ERC721ProxyContract; let erc721Proxy: ERC721ProxyContract;
let assetProxyDispatcher: AssetProxyDispatcherContract; let assetProxyDispatcher: AssetProxyDispatcherContract;
@@ -46,11 +46,11 @@ describe('AssetProxyDispatcher', () => {
erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner); erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner);
erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner); erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner);
[zrx] = await erc20Wrapper.deployDummyERC20TokensAsync(); [zrxToken] = await erc20Wrapper.deployDummyTokensAsync();
erc20Proxy = await erc20Wrapper.deployERC20ProxyAsync(); erc20Proxy = await erc20Wrapper.deployProxyAsync();
await erc20Wrapper.setBalancesAndAllowancesAsync(); await erc20Wrapper.setBalancesAndAllowancesAsync();
erc721Proxy = await erc721Wrapper.deployERC721ProxyAsync(); erc721Proxy = await erc721Wrapper.deployProxyAsync();
const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher); const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
assetProxyDispatcher = new AssetProxyDispatcherContract( assetProxyDispatcher = new AssetProxyDispatcherContract(
@@ -230,7 +230,7 @@ describe('AssetProxyDispatcher', () => {
{ from: owner }, { from: owner },
); );
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Perform a transfer from makerAddress to takerAddress // Perform a transfer from makerAddress to takerAddress
const erc20Balances = await erc20Wrapper.getBalancesAsync(); const erc20Balances = await erc20Wrapper.getBalancesAsync();
const amount = new BigNumber(10); const amount = new BigNumber(10);
@@ -243,17 +243,17 @@ describe('AssetProxyDispatcher', () => {
); );
// Verify transfer was successful // Verify transfer was successful
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(amount), erc20Balances[makerAddress][zrxToken.address].minus(amount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].add(amount), erc20Balances[takerAddress][zrxToken.address].add(amount),
); );
}); });
it('should throw if dispatching to unregistered proxy', async () => { it('should throw if dispatching to unregistered proxy', async () => {
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Perform a transfer from makerAddress to takerAddress // Perform a transfer from makerAddress to takerAddress
const erc20Balances = await erc20Wrapper.getBalancesAsync(); const erc20Balances = await erc20Wrapper.getBalancesAsync();
const amount = new BigNumber(10); const amount = new BigNumber(10);
@@ -278,7 +278,7 @@ describe('AssetProxyDispatcher', () => {
{ from: owner }, { from: owner },
); );
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Perform a transfer from makerAddress to takerAddress // Perform a transfer from makerAddress to takerAddress
const erc20Balances = await erc20Wrapper.getBalancesAsync(); const erc20Balances = await erc20Wrapper.getBalancesAsync();
const amount = new BigNumber(10); const amount = new BigNumber(10);

36
packages/contracts/test/asset_proxy_dispatcher/proxies.ts
View File

@@ -29,7 +29,7 @@ describe('Asset Transfer Proxies', () => {
let makerAddress: string; let makerAddress: string;
let takerAddress: string; let takerAddress: string;
let zrx: DummyERC20TokenContract; let zrxToken: DummyERC20TokenContract;
let erc721Token: DummyERC721TokenContract; let erc721Token: DummyERC721TokenContract;
let erc20Proxy: ERC20ProxyContract; let erc20Proxy: ERC20ProxyContract;
let erc721Proxy: ERC721ProxyContract; let erc721Proxy: ERC721ProxyContract;
@@ -51,15 +51,15 @@ describe('Asset Transfer Proxies', () => {
erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner); erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner);
erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner); erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner);
[zrx] = await erc20Wrapper.deployDummyERC20TokensAsync(); [zrxToken] = await erc20Wrapper.deployDummyTokensAsync();
erc20Proxy = await erc20Wrapper.deployERC20ProxyAsync(); erc20Proxy = await erc20Wrapper.deployProxyAsync();
await erc20Wrapper.setBalancesAndAllowancesAsync(); await erc20Wrapper.setBalancesAndAllowancesAsync();
await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcherAddress, { await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcherAddress, {
from: owner, from: owner,
}); });
[erc721Token] = await erc721Wrapper.deployDummyERC721TokensAsync(); [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
erc721Proxy = await erc721Wrapper.deployERC721ProxyAsync(); erc721Proxy = await erc721Wrapper.deployProxyAsync();
await erc721Wrapper.setBalancesAndAllowancesAsync(); await erc721Wrapper.setBalancesAndAllowancesAsync();
const erc721Balances = await erc721Wrapper.getBalancesAsync(); const erc721Balances = await erc721Wrapper.getBalancesAsync();
erc721MakerTokenId = erc721Balances[makerAddress][erc721Token.address][0]; erc721MakerTokenId = erc721Balances[makerAddress][erc721Token.address][0];
@@ -76,7 +76,7 @@ describe('Asset Transfer Proxies', () => {
describe('Transfer Proxy - ERC20', () => { describe('Transfer Proxy - ERC20', () => {
it('should successfully transfer tokens', async () => { it('should successfully transfer tokens', async () => {
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Perform a transfer from makerAddress to takerAddress // Perform a transfer from makerAddress to takerAddress
const erc20Balances = await erc20Wrapper.getBalancesAsync(); const erc20Balances = await erc20Wrapper.getBalancesAsync();
const amount = new BigNumber(10); const amount = new BigNumber(10);
@@ -89,17 +89,17 @@ describe('Asset Transfer Proxies', () => {
); );
// Verify transfer was successful // Verify transfer was successful
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(amount), erc20Balances[makerAddress][zrxToken.address].minus(amount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].add(amount), erc20Balances[takerAddress][zrxToken.address].add(amount),
); );
}); });
it('should do nothing if transferring 0 amount of a token', async () => { it('should do nothing if transferring 0 amount of a token', async () => {
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Perform a transfer from makerAddress to takerAddress // Perform a transfer from makerAddress to takerAddress
const erc20Balances = await erc20Wrapper.getBalancesAsync(); const erc20Balances = await erc20Wrapper.getBalancesAsync();
const amount = new BigNumber(0); const amount = new BigNumber(0);
@@ -112,21 +112,21 @@ describe('Asset Transfer Proxies', () => {
); );
// Verify transfer was successful // Verify transfer was successful
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address], erc20Balances[makerAddress][zrxToken.address],
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address], erc20Balances[takerAddress][zrxToken.address],
); );
}); });
it('should throw if allowances are too low', async () => { it('should throw if allowances are too low', async () => {
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Create allowance less than transfer amount. Set allowance on proxy. // Create allowance less than transfer amount. Set allowance on proxy.
const allowance = new BigNumber(0); const allowance = new BigNumber(0);
const transferAmount = new BigNumber(10); const transferAmount = new BigNumber(10);
await zrx.approve.sendTransactionAsync(erc20Proxy.address, allowance, { await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
from: makerAddress, from: makerAddress,
}); });
// Perform a transfer; expect this to fail. // Perform a transfer; expect this to fail.
@@ -143,7 +143,7 @@ describe('Asset Transfer Proxies', () => {
it('should throw if requesting address is not authorized', async () => { it('should throw if requesting address is not authorized', async () => {
// Construct metadata for ERC20 proxy // Construct metadata for ERC20 proxy
const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrx.address); const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
// Perform a transfer from makerAddress to takerAddress // Perform a transfer from makerAddress to takerAddress
const amount = new BigNumber(10); const amount = new BigNumber(10);
return expect( return expect(

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

@@ -28,7 +28,6 @@ import {
AssetProxyId, AssetProxyId,
ContractName, ContractName,
ERC20BalancesByOwner, ERC20BalancesByOwner,
ERC721BalancesByOwner,
ExchangeContractErrs, ExchangeContractErrs,
SignedOrder, SignedOrder,
} from '../../src/utils/types'; } from '../../src/utils/types';
@@ -48,7 +47,7 @@ describe('Exchange core', () => {
let erc20TokenA: DummyERC20TokenContract; let erc20TokenA: DummyERC20TokenContract;
let erc20TokenB: DummyERC20TokenContract; let erc20TokenB: DummyERC20TokenContract;
let zrx: DummyERC20TokenContract; let zrxToken: DummyERC20TokenContract;
let erc721Token: DummyERC721TokenContract; let erc721Token: DummyERC721TokenContract;
let exchange: ExchangeContract; let exchange: ExchangeContract;
let assetProxyDispatcher: AssetProxyDispatcherContract; let assetProxyDispatcher: AssetProxyDispatcherContract;
@@ -77,12 +76,12 @@ describe('Exchange core', () => {
erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner); erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner);
erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner); erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner);
[erc20TokenA, erc20TokenB, zrx] = await erc20Wrapper.deployDummyERC20TokensAsync(); [erc20TokenA, erc20TokenB, zrxToken] = await erc20Wrapper.deployDummyTokensAsync();
erc20Proxy = await erc20Wrapper.deployERC20ProxyAsync(); erc20Proxy = await erc20Wrapper.deployProxyAsync();
await erc20Wrapper.setBalancesAndAllowancesAsync(); await erc20Wrapper.setBalancesAndAllowancesAsync();
[erc721Token] = await erc721Wrapper.deployDummyERC721TokensAsync(); [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
erc721Proxy = await erc721Wrapper.deployERC721ProxyAsync(); erc721Proxy = await erc721Wrapper.deployProxyAsync();
await erc721Wrapper.setBalancesAndAllowancesAsync(); await erc721Wrapper.setBalancesAndAllowancesAsync();
const erc721Balances = await erc721Wrapper.getBalancesAsync(); const erc721Balances = await erc721Wrapper.getBalancesAsync();
erc721MakerAssetIds = erc721Balances[makerAddress][erc721Token.address]; erc721MakerAssetIds = erc721Balances[makerAddress][erc721Token.address];
@@ -117,7 +116,7 @@ describe('Exchange core', () => {
const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [ const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
assetProxyDispatcher.address, assetProxyDispatcher.address,
assetProxyUtils.encodeERC20ProxyData(zrx.address), assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
]); ]);
exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider); exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: owner }); await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: owner });
@@ -227,8 +226,8 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFeePaid), erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -236,11 +235,11 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFeePaid), erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFeePaid.add(takerFeePaid)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
); );
}); });
@@ -280,8 +279,8 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFeePaid), erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -289,11 +288,11 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFeePaid), erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFeePaid.add(takerFeePaid)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
); );
}); });
@@ -333,8 +332,8 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFeePaid), erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -342,11 +341,11 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFeePaid), erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFeePaid.add(takerFeePaid)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
); );
}); });
@@ -388,8 +387,8 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFeePaid), erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -397,11 +396,11 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFeePaid), erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFeePaid.add(takerFeePaid)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
); );
}); });
@@ -424,8 +423,8 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(signedOrder.takerAssetAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(signedOrder.takerAssetAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(signedOrder.makerFee), erc20Balances[makerAddress][zrxToken.address].minus(signedOrder.makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(signedOrder.takerAssetAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(signedOrder.takerAssetAmount),
@@ -433,11 +432,13 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(signedOrder.makerAssetAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(signedOrder.makerAssetAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(signedOrder.takerFee), erc20Balances[takerAddress][zrxToken.address].minus(signedOrder.takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(signedOrder.makerFee.add(signedOrder.takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(
signedOrder.makerFee.add(signedOrder.takerFee),
),
); );
}); });
@@ -768,8 +769,8 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(fillTakerAssetAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(fillTakerAssetAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(fillTakerAssetAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(fillTakerAssetAmount),
@@ -777,11 +778,11 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(fillMakerAssetAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(fillMakerAssetAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
}); });
@@ -949,14 +950,16 @@ describe('Exchange core', () => {
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(signedOrder.makerFee), erc20Balances[makerAddress][zrxToken.address].minus(signedOrder.makerFee),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(signedOrder.takerFee), erc20Balances[takerAddress][zrxToken.address].minus(signedOrder.takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(signedOrder.makerFee.add(signedOrder.takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(
signedOrder.makerFee.add(signedOrder.takerFee),
),
); );
}); });
@@ -987,14 +990,16 @@ describe('Exchange core', () => {
expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultMakerAssetAddress].minus(signedOrder.makerAssetAmount), erc20Balances[makerAddress][defaultMakerAssetAddress].minus(signedOrder.makerAssetAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(signedOrder.makerFee), erc20Balances[makerAddress][zrxToken.address].minus(signedOrder.makerFee),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(signedOrder.takerFee), erc20Balances[takerAddress][zrxToken.address].minus(signedOrder.takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(signedOrder.makerFee.add(signedOrder.takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(
signedOrder.makerFee.add(signedOrder.takerFee),
),
); );
}); });
}); });

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

@@ -19,13 +19,7 @@ import { ERC20Wrapper } from '../../src/utils/erc20_wrapper';
import { ERC721Wrapper } from '../../src/utils/erc721_wrapper'; import { ERC721Wrapper } from '../../src/utils/erc721_wrapper';
import { ExchangeWrapper } from '../../src/utils/exchange_wrapper'; import { ExchangeWrapper } from '../../src/utils/exchange_wrapper';
import { OrderFactory } from '../../src/utils/order_factory'; import { OrderFactory } from '../../src/utils/order_factory';
import { import { AssetProxyId, ContractName, ERC20BalancesByOwner, SignedOrder } from '../../src/utils/types';
AssetProxyId,
ContractName,
ERC20BalancesByOwner,
ERC721BalancesByOwner,
SignedOrder,
} from '../../src/utils/types';
import { chaiSetup } from '../utils/chai_setup'; import { chaiSetup } from '../utils/chai_setup';
import { deployer } from '../utils/deployer'; import { deployer } from '../utils/deployer';
import { provider, web3Wrapper } from '../utils/web3_wrapper'; import { provider, web3Wrapper } from '../utils/web3_wrapper';
@@ -42,7 +36,7 @@ describe('Exchange wrappers', () => {
let erc20TokenA: DummyERC20TokenContract; let erc20TokenA: DummyERC20TokenContract;
let erc20TokenB: DummyERC20TokenContract; let erc20TokenB: DummyERC20TokenContract;
let zrx: DummyERC20TokenContract; let zrxToken: DummyERC20TokenContract;
let erc721Token: DummyERC721TokenContract; let erc721Token: DummyERC721TokenContract;
let exchange: ExchangeContract; let exchange: ExchangeContract;
let assetProxyDispatcher: AssetProxyDispatcherContract; let assetProxyDispatcher: AssetProxyDispatcherContract;
@@ -70,12 +64,12 @@ describe('Exchange wrappers', () => {
erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner); erc20Wrapper = new ERC20Wrapper(deployer, provider, usedAddresses, owner);
erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner); erc721Wrapper = new ERC721Wrapper(deployer, provider, usedAddresses, owner);
[erc20TokenA, erc20TokenB, zrx] = await erc20Wrapper.deployDummyERC20TokensAsync(); [erc20TokenA, erc20TokenB, zrxToken] = await erc20Wrapper.deployDummyTokensAsync();
erc20Proxy = await erc20Wrapper.deployERC20ProxyAsync(); erc20Proxy = await erc20Wrapper.deployProxyAsync();
await erc20Wrapper.setBalancesAndAllowancesAsync(); await erc20Wrapper.setBalancesAndAllowancesAsync();
[erc721Token] = await erc721Wrapper.deployDummyERC721TokensAsync(); [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
erc721Proxy = await erc721Wrapper.deployERC721ProxyAsync(); erc721Proxy = await erc721Wrapper.deployProxyAsync();
await erc721Wrapper.setBalancesAndAllowancesAsync(); await erc721Wrapper.setBalancesAndAllowancesAsync();
const erc721Balances = await erc721Wrapper.getBalancesAsync(); const erc721Balances = await erc721Wrapper.getBalancesAsync();
erc721MakerAssetId = erc721Balances[makerAddress][erc721Token.address][0]; erc721MakerAssetId = erc721Balances[makerAddress][erc721Token.address][0];
@@ -110,7 +104,7 @@ describe('Exchange wrappers', () => {
const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [ const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
assetProxyDispatcher.address, assetProxyDispatcher.address,
assetProxyUtils.encodeERC20ProxyData(zrx.address), assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
]); ]);
exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider); exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: owner }); await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: owner });
@@ -169,8 +163,8 @@ describe('Exchange wrappers', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -178,11 +172,11 @@ describe('Exchange wrappers', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
@@ -237,8 +231,8 @@ describe('Exchange wrappers', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -246,11 +240,11 @@ describe('Exchange wrappers', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
@@ -303,11 +297,11 @@ describe('Exchange wrappers', () => {
}); });
it('should not change erc20Balances if makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker balance', async () => { it('should not change erc20Balances if makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker balance', async () => {
const makerZRXBalance = new BigNumber(erc20Balances[makerAddress][zrx.address]); const makerZRXBalance = new BigNumber(erc20Balances[makerAddress][zrxToken.address]);
const signedOrder = orderFactory.newSignedOrder({ const signedOrder = orderFactory.newSignedOrder({
makerAssetAmount: makerZRXBalance, makerAssetAmount: makerZRXBalance,
makerFee: new BigNumber(1), makerFee: new BigNumber(1),
makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address), makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}); });
await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress); await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
@@ -315,11 +309,11 @@ describe('Exchange wrappers', () => {
}); });
it('should not change erc20Balances if makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker allowance', async () => { it('should not change erc20Balances if makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker allowance', async () => {
const makerZRXAllowance = await zrx.allowance.callAsync(makerAddress, erc20Proxy.address); const makerZRXAllowance = await zrxToken.allowance.callAsync(makerAddress, erc20Proxy.address);
const signedOrder = orderFactory.newSignedOrder({ const signedOrder = orderFactory.newSignedOrder({
makerAssetAmount: new BigNumber(makerZRXAllowance), makerAssetAmount: new BigNumber(makerZRXAllowance),
makerFee: new BigNumber(1), makerFee: new BigNumber(1),
makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address), makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}); });
await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress); await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
@@ -327,11 +321,11 @@ describe('Exchange wrappers', () => {
}); });
it('should not change erc20Balances if takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker balance', async () => { it('should not change erc20Balances if takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker balance', async () => {
const takerZRXBalance = new BigNumber(erc20Balances[takerAddress][zrx.address]); const takerZRXBalance = new BigNumber(erc20Balances[takerAddress][zrxToken.address]);
const signedOrder = orderFactory.newSignedOrder({ const signedOrder = orderFactory.newSignedOrder({
takerAssetAmount: takerZRXBalance, takerAssetAmount: takerZRXBalance,
takerFee: new BigNumber(1), takerFee: new BigNumber(1),
takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address), takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}); });
await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress); await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
@@ -339,11 +333,11 @@ describe('Exchange wrappers', () => {
}); });
it('should not change erc20Balances if takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker allowance', async () => { it('should not change erc20Balances if takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker allowance', async () => {
const takerZRXAllowance = await zrx.allowance.callAsync(takerAddress, erc20Proxy.address); const takerZRXAllowance = await zrxToken.allowance.callAsync(takerAddress, erc20Proxy.address);
const signedOrder = orderFactory.newSignedOrder({ const signedOrder = orderFactory.newSignedOrder({
takerAssetAmount: new BigNumber(takerZRXAllowance), takerAssetAmount: new BigNumber(takerZRXAllowance),
takerFee: new BigNumber(1), takerFee: new BigNumber(1),
takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address), takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}); });
await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress); await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
@@ -409,16 +403,20 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add( erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add(
takerAssetFillAmount, takerAssetFillAmount,
); );
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus(makerFee); erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
makerFee,
);
erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add( erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add(
makerAssetFilledAmount, makerAssetFilledAmount,
); );
erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][
takerAssetAddress takerAssetAddress
].minus(takerAssetFillAmount); ].minus(takerAssetFillAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus(takerFee); erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ takerFee,
zrx.address );
erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrxToken.address
].add(makerFee.add(takerFee)); ].add(makerFee.add(takerFee));
}); });
@@ -454,16 +452,20 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add( erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add(
takerAssetFillAmount, takerAssetFillAmount,
); );
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus(makerFee); erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
makerFee,
);
erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add( erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add(
makerAssetFilledAmount, makerAssetFilledAmount,
); );
erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][
takerAssetAddress takerAssetAddress
].minus(takerAssetFillAmount); ].minus(takerAssetFillAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus(takerFee); erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ takerFee,
zrx.address );
erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrxToken.address
].add(makerFee.add(takerFee)); ].add(makerFee.add(takerFee));
}); });
@@ -515,16 +517,20 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add( erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add(
takerAssetFillAmount, takerAssetFillAmount,
); );
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus(makerFee); erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
makerFee,
);
erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add( erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add(
makerAssetFilledAmount, makerAssetFilledAmount,
); );
erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][
takerAssetAddress takerAssetAddress
].minus(takerAssetFillAmount); ].minus(takerAssetFillAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus(takerFee); erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ takerFee,
zrx.address );
erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrxToken.address
].add(makerFee.add(takerFee)); ].add(makerFee.add(takerFee));
}); });
@@ -566,16 +572,20 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add( erc20Balances[makerAddress][takerAssetAddress] = erc20Balances[makerAddress][takerAssetAddress].add(
takerAssetFillAmount, takerAssetFillAmount,
); );
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus(makerFee); erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
makerFee,
);
erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add( erc20Balances[takerAddress][makerAssetAddress] = erc20Balances[takerAddress][makerAssetAddress].add(
makerAssetFilledAmount, makerAssetFilledAmount,
); );
erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][takerAssetAddress] = erc20Balances[takerAddress][
takerAssetAddress takerAssetAddress
].minus(takerAssetFillAmount); ].minus(takerAssetFillAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus(takerFee); erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ takerFee,
zrx.address );
erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrxToken.address
].add(makerFee.add(takerFee)); ].add(makerFee.add(takerFee));
}); });
@@ -611,8 +621,8 @@ describe('Exchange wrappers', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -620,11 +630,11 @@ describe('Exchange wrappers', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
@@ -637,7 +647,7 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][ erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].add(signedOrder.takerAssetAmount); ].add(signedOrder.takerAssetAmount);
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus( erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
signedOrder.makerFee, signedOrder.makerFee,
); );
erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][
@@ -646,11 +656,11 @@ describe('Exchange wrappers', () => {
erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].minus(signedOrder.takerAssetAmount); ].minus(signedOrder.takerAssetAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus( erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
signedOrder.takerFee, signedOrder.takerFee,
); );
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrx.address zrxToken.address
].add(signedOrder.makerFee.add(signedOrder.takerFee)); ].add(signedOrder.makerFee.add(signedOrder.takerFee));
}); });
await exchangeWrapper.marketSellOrdersAsync(signedOrders, takerAddress, { await exchangeWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
@@ -664,7 +674,9 @@ describe('Exchange wrappers', () => {
it('should throw when an signedOrder does not use the same takerAssetAddress', async () => { it('should throw when an signedOrder does not use the same takerAssetAddress', async () => {
signedOrders = [ signedOrders = [
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
orderFactory.newSignedOrder({ takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address) }), orderFactory.newSignedOrder({
takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}),
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
]; ];
@@ -698,8 +710,8 @@ describe('Exchange wrappers', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount), erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
@@ -707,11 +719,11 @@ describe('Exchange wrappers', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
@@ -724,7 +736,7 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][ erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].add(signedOrder.takerAssetAmount); ].add(signedOrder.takerAssetAmount);
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus( erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
signedOrder.makerFee, signedOrder.makerFee,
); );
erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][
@@ -733,11 +745,11 @@ describe('Exchange wrappers', () => {
erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].minus(signedOrder.takerAssetAmount); ].minus(signedOrder.takerAssetAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus( erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
signedOrder.takerFee, signedOrder.takerFee,
); );
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrx.address zrxToken.address
].add(signedOrder.makerFee.add(signedOrder.takerFee)); ].add(signedOrder.makerFee.add(signedOrder.takerFee));
}); });
await exchangeWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, { await exchangeWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
@@ -751,7 +763,9 @@ describe('Exchange wrappers', () => {
it('should throw when a signedOrder does not use the same takerAssetAddress', async () => { it('should throw when a signedOrder does not use the same takerAssetAddress', async () => {
signedOrders = [ signedOrders = [
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
orderFactory.newSignedOrder({ takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address) }), orderFactory.newSignedOrder({
takerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}),
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
]; ];
@@ -785,8 +799,8 @@ describe('Exchange wrappers', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(makerAmountBought), erc20Balances[makerAddress][defaultTakerAssetAddress].add(makerAmountBought),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(makerAmountBought), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(makerAmountBought),
@@ -794,11 +808,11 @@ describe('Exchange wrappers', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFillAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFillAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
@@ -811,7 +825,7 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][ erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].add(signedOrder.takerAssetAmount); ].add(signedOrder.takerAssetAmount);
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus( erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
signedOrder.makerFee, signedOrder.makerFee,
); );
erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][
@@ -820,11 +834,11 @@ describe('Exchange wrappers', () => {
erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].minus(signedOrder.takerAssetAmount); ].minus(signedOrder.takerAssetAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus( erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
signedOrder.takerFee, signedOrder.takerFee,
); );
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrx.address zrxToken.address
].add(signedOrder.makerFee.add(signedOrder.takerFee)); ].add(signedOrder.makerFee.add(signedOrder.takerFee));
}); });
await exchangeWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, { await exchangeWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, {
@@ -838,7 +852,9 @@ describe('Exchange wrappers', () => {
it('should throw when an signedOrder does not use the same makerAssetAddress', async () => { it('should throw when an signedOrder does not use the same makerAssetAddress', async () => {
signedOrders = [ signedOrders = [
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
orderFactory.newSignedOrder({ makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address) }), orderFactory.newSignedOrder({
makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}),
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
]; ];
@@ -872,8 +888,8 @@ describe('Exchange wrappers', () => {
expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[makerAddress][defaultTakerAssetAddress].add(makerAmountBought), erc20Balances[makerAddress][defaultTakerAssetAddress].add(makerAmountBought),
); );
expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[makerAddress][zrx.address].minus(makerFee), erc20Balances[makerAddress][zrxToken.address].minus(makerFee),
); );
expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultTakerAssetAddress].minus(makerAmountBought), erc20Balances[takerAddress][defaultTakerAssetAddress].minus(makerAmountBought),
@@ -881,11 +897,11 @@ describe('Exchange wrappers', () => {
expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal( expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFillAmount), erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFillAmount),
); );
expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[takerAddress][zrx.address].minus(takerFee), erc20Balances[takerAddress][zrxToken.address].minus(takerFee),
); );
expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFee.add(takerFee)),
); );
}); });
@@ -898,7 +914,7 @@ describe('Exchange wrappers', () => {
erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][ erc20Balances[makerAddress][defaultTakerAssetAddress] = erc20Balances[makerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].add(signedOrder.takerAssetAmount); ].add(signedOrder.takerAssetAmount);
erc20Balances[makerAddress][zrx.address] = erc20Balances[makerAddress][zrx.address].minus( erc20Balances[makerAddress][zrxToken.address] = erc20Balances[makerAddress][zrxToken.address].minus(
signedOrder.makerFee, signedOrder.makerFee,
); );
erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultMakerAssetAddress] = erc20Balances[takerAddress][
@@ -907,11 +923,11 @@ describe('Exchange wrappers', () => {
erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][ erc20Balances[takerAddress][defaultTakerAssetAddress] = erc20Balances[takerAddress][
defaultTakerAssetAddress defaultTakerAssetAddress
].minus(signedOrder.takerAssetAmount); ].minus(signedOrder.takerAssetAmount);
erc20Balances[takerAddress][zrx.address] = erc20Balances[takerAddress][zrx.address].minus( erc20Balances[takerAddress][zrxToken.address] = erc20Balances[takerAddress][zrxToken.address].minus(
signedOrder.takerFee, signedOrder.takerFee,
); );
erc20Balances[feeRecipientAddress][zrx.address] = erc20Balances[feeRecipientAddress][ erc20Balances[feeRecipientAddress][zrxToken.address] = erc20Balances[feeRecipientAddress][
zrx.address zrxToken.address
].add(signedOrder.makerFee.add(signedOrder.takerFee)); ].add(signedOrder.makerFee.add(signedOrder.takerFee));
}); });
await exchangeWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, { await exchangeWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
@@ -925,7 +941,9 @@ describe('Exchange wrappers', () => {
it('should throw when a signedOrder does not use the same makerAssetAddress', async () => { it('should throw when a signedOrder does not use the same makerAssetAddress', async () => {
signedOrders = [ signedOrders = [
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
orderFactory.newSignedOrder({ makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrx.address) }), orderFactory.newSignedOrder({
makerAssetData: assetProxyUtils.encodeERC20ProxyData(zrxToken.address),
}),
orderFactory.newSignedOrder(), orderFactory.newSignedOrder(),
]; ];

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

@@ -24,7 +24,7 @@ describe('ZRXToken', () => {
let MAX_UINT: BigNumber; let MAX_UINT: BigNumber;
let zrx: ZRXTokenContract; let zrxToken: ZRXTokenContract;
let zrxAddress: string; let zrxAddress: string;
before(async () => { before(async () => {
@@ -35,8 +35,8 @@ describe('ZRXToken', () => {
networkId: constants.TESTRPC_NETWORK_ID, networkId: constants.TESTRPC_NETWORK_ID,
}); });
const zrxInstance = await deployer.deployAsync(ContractName.ZRXToken); const zrxInstance = await deployer.deployAsync(ContractName.ZRXToken);
zrx = new ZRXTokenContract(zrxInstance.abi, zrxInstance.address, provider); zrxToken = new ZRXTokenContract(zrxInstance.abi, zrxInstance.address, provider);
zrxAddress = zrx.address; zrxAddress = zrxToken.address;
MAX_UINT = zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS; MAX_UINT = zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
}); });
beforeEach(async () => { beforeEach(async () => {
@@ -47,25 +47,25 @@ describe('ZRXToken', () => {
}); });
describe('constants', () => { describe('constants', () => {
it('should have 18 decimals', async () => { it('should have 18 decimals', async () => {
const decimals = new BigNumber(await zrx.decimals.callAsync()); const decimals = new BigNumber(await zrxToken.decimals.callAsync());
const expectedDecimals = 18; const expectedDecimals = 18;
expect(decimals).to.be.bignumber.equal(expectedDecimals); expect(decimals).to.be.bignumber.equal(expectedDecimals);
}); });
it('should have a total supply of 1 billion tokens', async () => { it('should have a total supply of 1 billion tokens', async () => {
const totalSupply = new BigNumber(await zrx.totalSupply.callAsync()); const totalSupply = new BigNumber(await zrxToken.totalSupply.callAsync());
const expectedTotalSupply = 1000000000; const expectedTotalSupply = 1000000000;
expect(ZeroEx.toUnitAmount(totalSupply, 18)).to.be.bignumber.equal(expectedTotalSupply); expect(ZeroEx.toUnitAmount(totalSupply, 18)).to.be.bignumber.equal(expectedTotalSupply);
}); });
it('should be named 0x Protocol Token', async () => { it('should be named 0x Protocol Token', async () => {
const name = await zrx.name.callAsync(); const name = await zrxToken.name.callAsync();
const expectedName = '0x Protocol Token'; const expectedName = '0x Protocol Token';
expect(name).to.be.equal(expectedName); expect(name).to.be.equal(expectedName);
}); });
it('should have the symbol ZRX', async () => { it('should have the symbol ZRX', async () => {
const symbol = await zrx.symbol.callAsync(); const symbol = await zrxToken.symbol.callAsync();
const expectedSymbol = 'ZRX'; const expectedSymbol = 'ZRX';
expect(symbol).to.be.equal(expectedSymbol); expect(symbol).to.be.equal(expectedSymbol);
}); });
@@ -74,7 +74,7 @@ describe('ZRXToken', () => {
describe('constructor', () => { describe('constructor', () => {
it('should initialize owner balance to totalSupply', async () => { it('should initialize owner balance to totalSupply', async () => {
const ownerBalance = await zeroEx.token.getBalanceAsync(zrxAddress, owner); const ownerBalance = await zeroEx.token.getBalanceAsync(zrxAddress, owner);
const totalSupply = new BigNumber(await zrx.totalSupply.callAsync()); const totalSupply = new BigNumber(await zrxToken.totalSupply.callAsync());
expect(totalSupply).to.be.bignumber.equal(ownerBalance); expect(totalSupply).to.be.bignumber.equal(ownerBalance);
}); });
}); });
@@ -95,7 +95,7 @@ describe('ZRXToken', () => {
}); });
it('should return true on a 0 value transfer', async () => { it('should return true on a 0 value transfer', async () => {
const didReturnTrue = await zrx.transfer.callAsync(spender, new BigNumber(0), { const didReturnTrue = await zrxToken.transfer.callAsync(spender, new BigNumber(0), {
from: owner, from: owner,
}); });
expect(didReturnTrue).to.be.true(); expect(didReturnTrue).to.be.true();
@@ -109,7 +109,7 @@ describe('ZRXToken', () => {
await zeroEx.token.setAllowanceAsync(zrxAddress, owner, spender, amountToTransfer, { await zeroEx.token.setAllowanceAsync(zrxAddress, owner, spender, amountToTransfer, {
gasLimit: constants.MAX_TOKEN_APPROVE_GAS, gasLimit: constants.MAX_TOKEN_APPROVE_GAS,
}); });
const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender }); const didReturnTrue = await zrxToken.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
expect(didReturnTrue).to.be.false(); expect(didReturnTrue).to.be.false();
}); });
@@ -121,13 +121,13 @@ describe('ZRXToken', () => {
const spenderAllowanceIsInsufficient = spenderAllowance.cmp(amountToTransfer) < 0; const spenderAllowanceIsInsufficient = spenderAllowance.cmp(amountToTransfer) < 0;
expect(spenderAllowanceIsInsufficient).to.be.true(); expect(spenderAllowanceIsInsufficient).to.be.true();
const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender }); const didReturnTrue = await zrxToken.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
expect(didReturnTrue).to.be.false(); expect(didReturnTrue).to.be.false();
}); });
it('should return true on a 0 value transfer', async () => { it('should return true on a 0 value transfer', async () => {
const amountToTransfer = new BigNumber(0); const amountToTransfer = new BigNumber(0);
const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender }); const didReturnTrue = await zrxToken.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
expect(didReturnTrue).to.be.true(); expect(didReturnTrue).to.be.true();
}); });