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

Style improvements to the Asset Proxy tests

Browse Source
This commit is contained in:
Greg Hysen
2018-04-12 18:26:59 -07:00
committed by Amir Bandeali
parent 8374a51e6a
commit 10707ebc3a
2 changed files with 140 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -32,13 +32,14 @@ describe('Asset Transfer Proxies', () => {
let makerAddress: string;
let takerAddress: string;
let zrx: DummyTokenContract;
let ck: DummyERC721TokenContract;
let erc721Token: DummyERC721TokenContract;
let dmyBalances: Balances;
let tokenTransferProxy: TokenTransferProxyContract;
let erc20TransferProxyV1: ERC20Proxy_v1Contract;
let erc20TransferProxy: ERC20ProxyContract;
let erc721TransferProxy: ERC721ProxyContract;
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const testAddressPaddedWithZeros = '0x0000000000000000056000000000000000000010';
const INITIAL_BALANCE = new BigNumber(10000);
before(async () => {
@@ -109,12 +110,19 @@ describe('Asset Transfer Proxies', () => {
await zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_BALANCE, {
from: makerAddress,
});
// Deploy ck and set initial balances
const ckInstance = await deployer.deployAsync(ContractName.DummyERC721Token, constants.DUMMY_ERC721TOKEN_ARGS);
ck = new DummyERC721TokenContract(ckInstance.abi, ckInstance.address, provider);
await ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: makerAddress });
await ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: takerAddress });
await ck.mint.sendTransactionAsync(makerAddress, makerTokenId, { from: tokenOwner });
// Deploy erc721Token and set initial balances
const erc721TokenInstance = await deployer.deployAsync(
ContractName.DummyERC721Token,
constants.DUMMY_ERC721TOKEN_ARGS,
);
erc721Token = new DummyERC721TokenContract(erc721TokenInstance.abi, erc721TokenInstance.address, provider);
await erc721Token.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, {
from: makerAddress,
});
await erc721Token.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, {
from: takerAddress,
});
await erc721Token.mint.sendTransactionAsync(makerAddress, makerTokenId, { from: tokenOwner });
});
beforeEach(async () => {
await blockchainLifecycle.startAsync();
@@ -136,17 +144,18 @@ describe('Asset Transfer Proxies', () => {
});
it('should successfully encode/decode metadata padded with zeros', async () => {
const testAddress = '0x0000000000000000056000000000000000000010';
const metadata = await erc20TransferProxyV1.encodeMetadata.callAsync(AssetProxyId.ERC20V1, testAddress);
const metadata = await erc20TransferProxyV1.encodeMetadata.callAsync(
AssetProxyId.ERC20V1,
testAddressPaddedWithZeros,
);
const address = await erc20TransferProxyV1.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(testAddress);
expect(address).to.be.equal(testAddressPaddedWithZeros);
});
it('should successfully decode metadata encoded padded with zeros by typescript helpers', async () => {
const testAddress = '0x0000000000000000056000000000000000000010';
const metadata = encodeERC20V1ProxyData(testAddress);
const metadata = encodeERC20V1ProxyData(testAddressPaddedWithZeros);
const address = await erc20TransferProxyV1.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(testAddress);
expect(address).to.be.equal(testAddressPaddedWithZeros);
});
it('should successfully transfer tokens', async () => {
@@ -204,17 +213,18 @@ describe('Asset Transfer Proxies', () => {
});
it('should successfully encode/decode metadata padded with zeros', async () => {
const testAddress = '0x0000000000000000056000000000000000000010';
const metadata = await erc20TransferProxy.encodeMetadata.callAsync(AssetProxyId.ERC20, testAddress);
const metadata = await erc20TransferProxy.encodeMetadata.callAsync(
AssetProxyId.ERC20,
testAddressPaddedWithZeros,
);
const address = await erc20TransferProxy.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(testAddress);
expect(address).to.be.equal(testAddressPaddedWithZeros);
});
it('should successfully decode metadata encoded padded with zeros by typescript helpers', async () => {
const testAddress = '0x0000000000000000056000000000000000000010';
const metadata = encodeERC20ProxyData(testAddress);
const metadata = encodeERC20ProxyData(testAddressPaddedWithZeros);
const address = await erc20TransferProxy.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(testAddress);
expect(address).to.be.equal(testAddressPaddedWithZeros);
});
it('should successfully transfer tokens', async () => {
@@ -262,46 +272,44 @@ describe('Asset Transfer Proxies', () => {
it('should successfully encode/decode metadata', async () => {
const metadata = await erc721TransferProxy.encodeMetadata.callAsync(
AssetProxyId.ERC721,
ck.address,
erc721Token.address,
makerTokenId,
);
const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(ck.address);
expect(address).to.be.equal(erc721Token.address);
expect(tokenId).to.be.bignumber.equal(makerTokenId);
});
it('should successfully decode metadata encoded by typescript helpers', async () => {
const metadata = encodeERC721ProxyData(ck.address, makerTokenId);
const metadata = encodeERC721ProxyData(erc721Token.address, makerTokenId);
const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(ck.address);
expect(address).to.be.equal(erc721Token.address);
expect(tokenId).to.be.bignumber.equal(makerTokenId);
});
it('should successfully encode/decode metadata padded with zeros', async () => {
const testAddress = '0x0000000000000000056000000000000000000010';
const metadata = await erc721TransferProxy.encodeMetadata.callAsync(
AssetProxyId.ERC721,
testAddress,
testAddressPaddedWithZeros,
makerTokenId,
);
const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(testAddress);
expect(address).to.be.equal(testAddressPaddedWithZeros);
expect(tokenId).to.be.bignumber.equal(makerTokenId);
});
it('should successfully decode metadata encoded padded with zeros by typescript helpers', async () => {
const testAddress = '0x0000000000000000056000000000000000000010';
const metadata = encodeERC721ProxyData(testAddress, makerTokenId);
const metadata = encodeERC721ProxyData(testAddressPaddedWithZeros, makerTokenId);
const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
expect(address).to.be.equal(testAddress);
expect(address).to.be.equal(testAddressPaddedWithZeros);
expect(tokenId).to.be.bignumber.equal(makerTokenId);
});
it('should successfully transfer tokens', async () => {
// Construct metadata for ERC20 proxy
const encodedProxyMetadata = encodeERC721ProxyData(ck.address, makerTokenId);
const encodedProxyMetadata = encodeERC721ProxyData(erc721Token.address, makerTokenId);
// Verify pre-condition
const ownerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
// Perform a transfer from makerAddress to takerAddress
const balances = await dmyBalances.getAsync();
@@ -314,15 +322,15 @@ describe('Asset Transfer Proxies', () => {
{ from: assetProxyDispatcherAddress },
);
// Verify transfer was successful
const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
});
it('should throw if transferring 0 amount of a token', async () => {
// Construct metadata for ERC20 proxy
const encodedProxyMetadata = encodeERC721ProxyData(ck.address, makerTokenId);
const encodedProxyMetadata = encodeERC721ProxyData(erc721Token.address, makerTokenId);
// Verify pre-condition
const ownerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
// Perform a transfer from makerAddress to takerAddress
const balances = await dmyBalances.getAsync();
@@ -333,16 +341,16 @@ describe('Asset Transfer Proxies', () => {
makerAddress,
takerAddress,
amount,
{ from: notOwner },
{ from: assetProxyDispatcherAddress },
),
).to.be.rejectedWith(constants.REVERT);
});
it('should throw if transferring >1 amount of a token', async () => {
it('should throw if transferring > 1 amount of a token', async () => {
// Construct metadata for ERC20 proxy
const encodedProxyMetadata = encodeERC721ProxyData(ck.address, makerTokenId);
const encodedProxyMetadata = encodeERC721ProxyData(erc721Token.address, makerTokenId);
// Verify pre-condition
const ownerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
// Perform a transfer from makerAddress to takerAddress
const balances = await dmyBalances.getAsync();
@@ -353,7 +361,7 @@ describe('Asset Transfer Proxies', () => {
makerAddress,
takerAddress,
amount,
{ from: notOwner },
{ from: assetProxyDispatcherAddress },
),
).to.be.rejectedWith(constants.REVERT);
});

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

@@ -54,7 +54,7 @@ describe('Exchange', () => {
let rep: DummyTokenContract;
let dgd: DummyTokenContract;
let zrx: DummyTokenContract;
let ck: DummyERC721TokenContract;
let erc721Token: DummyERC721TokenContract;
let exchange: ExchangeContract;
let tokenTransferProxy: TokenTransferProxyContract;
let assetProxyDispatcher: AssetProxyDispatcherContract;
@@ -68,6 +68,16 @@ describe('Exchange', () => {
let dmyBalances: Balances;
let orderFactory: OrderFactory;
const erc721MakerTokenIds = [
new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010'),
new BigNumber('0x2020202020202020202020202020202020202020202020202020202020202020'),
];
const erc721TakerTokenIds = [
new BigNumber('0x3030303030303030303030303030303030303030303030303030303030303030'),
new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040'),
];
let zeroEx: ZeroEx;
before(async () => {
@@ -75,7 +85,7 @@ describe('Exchange', () => {
makerAddress = accounts[0];
[tokenOwner, takerAddress, feeRecipientAddress] = accounts;
const owner = tokenOwner;
const [repInstance, dgdInstance, zrxInstance, ckInstance] = await Promise.all([
const [repInstance, dgdInstance, zrxInstance, erc721TokenInstance] = await Promise.all([
deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
@@ -85,7 +95,7 @@ describe('Exchange', () => {
rep = new DummyTokenContract(repInstance.abi, repInstance.address, provider);
dgd = new DummyTokenContract(dgdInstance.abi, dgdInstance.address, provider);
zrx = new DummyTokenContract(zrxInstance.abi, zrxInstance.address, provider);
ck = new DummyERC721TokenContract(ckInstance.abi, ckInstance.address, provider);
erc721Token = new DummyERC721TokenContract(erc721TokenInstance.abi, erc721TokenInstance.address, provider);
// Deploy Asset Proxy Dispatcher
const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
assetProxyDispatcher = new AssetProxyDispatcherContract(
@@ -226,28 +236,16 @@ describe('Exchange', () => {
}),
zrx.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
zrx.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: makerAddress }),
ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: takerAddress }),
ck.mint.sendTransactionAsync(
makerAddress,
new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010'),
{ from: tokenOwner },
),
ck.mint.sendTransactionAsync(
makerAddress,
new BigNumber('0x2020202020202020202020202020202020202020202020202020202020202020'),
{ from: tokenOwner },
),
ck.mint.sendTransactionAsync(
takerAddress,
new BigNumber('0x3030303030303030303030303030303030303030303030303030303030303030'),
{ from: tokenOwner },
),
ck.mint.sendTransactionAsync(
takerAddress,
new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040'),
{ from: tokenOwner },
),
erc721Token.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, {
from: makerAddress,
}),
erc721Token.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, {
from: takerAddress,
}),
erc721Token.mint.sendTransactionAsync(makerAddress, erc721MakerTokenIds[0], { from: tokenOwner }),
erc721Token.mint.sendTransactionAsync(makerAddress, erc721MakerTokenIds[1], { from: tokenOwner }),
erc721Token.mint.sendTransactionAsync(takerAddress, erc721TakerTokenIds[0], { from: tokenOwner }),
erc721Token.mint.sendTransactionAsync(takerAddress, erc721TakerTokenIds[1], { from: tokenOwner }),
]);
});
beforeEach(async () => {
@@ -880,74 +878,74 @@ describe('Exchange', () => {
describe('Testing Exchange of ERC721 Tokens', () => {
it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const makerTokenId = erc721MakerTokenIds[0];
const takerTokenId = erc721TakerTokenIds[1];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: new BigNumber(1),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
// Verify post-conditions
const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
const newOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
});
it('should successfully exchange a single token between the maker and taker (via filleOrderNoThrow)', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const makerTokenId = erc721MakerTokenIds[0];
const takerTokenId = erc721TakerTokenIds[1];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: new BigNumber(1),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { takerTokenFillAmount });
// Verify post-conditions
const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
const newOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
});
it('should throw when maker does not own the token with id makerTokenId', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x3030303030303030303030303030303030303030303030303030303030303030');
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const makerTokenId = erc721TakerTokenIds[0];
const takerTokenId = erc721TakerTokenIds[1];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: new BigNumber(1),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.not.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
@@ -958,20 +956,20 @@ describe('Exchange', () => {
it('should throw when taker does not own the token with id takerTokenId', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const takerTokenId = new BigNumber('0x2020202020202020202020202020202020202020202020202020202020202020');
const makerTokenId = erc721MakerTokenIds[0];
const takerTokenId = erc721MakerTokenIds[1];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: new BigNumber(1),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.not.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
@@ -982,20 +980,20 @@ describe('Exchange', () => {
it('should throw when makerTokenAmount is greater than 1', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const makerTokenId = erc721MakerTokenIds[0];
const takerTokenId = erc721TakerTokenIds[0];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(2),
takerTokenAmount: new BigNumber(1),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
@@ -1006,20 +1004,20 @@ describe('Exchange', () => {
it('should throw when takerTokenAmount is greater than 1', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const makerTokenId = erc721MakerTokenIds[0];
const takerTokenId = erc721TakerTokenIds[0];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: new BigNumber(500),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
@@ -1030,20 +1028,20 @@ describe('Exchange', () => {
it('should throw on partial fill', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const makerTokenId = erc721MakerTokenIds[0];
const takerTokenId = erc721TakerTokenIds[0];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
takerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: erc721Token.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: new BigNumber(0),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
const takerTokenFillAmount = signedOrder.takerTokenAmount;
@@ -1054,24 +1052,24 @@ describe('Exchange', () => {
it('should successfully fill order when makerToken is ERC721 and takerToken is ERC20', async () => {
// Construct Exchange parameters
const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
const makerTokenId = erc721MakerTokenIds[0];
signedOrder = orderFactory.newSignedOrder({
makerTokenAddress: ck.address,
makerTokenAddress: erc721Token.address,
takerTokenAddress: dgd.address,
makerTokenAmount: new BigNumber(1),
takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
makerAssetData: encodeERC721ProxyData(ck.address, makerTokenId),
makerAssetData: encodeERC721ProxyData(erc721Token.address, makerTokenId),
takerAssetData: encodeERC20ProxyData(dgd.address),
});
// Verify pre-conditions
const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
// Call Exchange
balances = await dmyBalances.getAsync();
const takerTokenFillAmount = signedOrder.takerTokenAmount;
await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
// Verify ERC721 token was transferred from Maker to Taker
const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
// Verify ERC20 tokens were transferred from Taker to Maker & fees were paid correctly
const newBalances = await dmyBalances.getAsync();
@@ -1094,24 +1092,24 @@ describe('Exchange', () => {
it('should successfully fill order when makerToken is ERC20 and takerToken is ERC721', async () => {
// Construct Exchange parameters
const takerTokenId = new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040');
const takerTokenId = erc721TakerTokenIds[0];
signedOrder = orderFactory.newSignedOrder({
takerTokenAddress: ck.address,
takerTokenAddress: erc721Token.address,
makerTokenAddress: dgd.address,
takerTokenAmount: new BigNumber(1),
makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
takerAssetData: encodeERC721ProxyData(ck.address, takerTokenId),
takerAssetData: encodeERC721ProxyData(erc721Token.address, takerTokenId),
makerAssetData: encodeERC20ProxyData(dgd.address),
});
// Verify pre-conditions
const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
// Call Exchange
balances = await dmyBalances.getAsync();
const takerTokenFillAmount = signedOrder.takerTokenAmount;
await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
// Verify ERC721 token was transferred from Taker to Maker
const newOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
// Verify ERC20 tokens were transferred from Maker to Taker & fees were paid correctly
const newBalances = await dmyBalances.getAsync();