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

Ran prettier / linter

Browse Source
This commit is contained in:
Greg Hysen 2019-03-05 08:02:52 -08:00
parent 888c17353b
commit 55c4fc9aca
5 changed files with 228 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contracts/asset-proxy/package.json
View File

@ -70,6 +70,7 @@
"@0x/base-contract": "^5.0.2", "@0x/base-contract": "^5.0.2",
"@0x/contracts-erc20": "^1.0.9", "@0x/contracts-erc20": "^1.0.9",
"@0x/contracts-erc721": "^1.0.9", "@0x/contracts-erc721": "^1.0.9",
"@0x/contracts-erc1155": "^1.0.0",
"@0x/contracts-utils": "2.0.1", "@0x/contracts-utils": "2.0.1",
"@0x/order-utils": "^7.0.2", "@0x/order-utils": "^7.0.2",
"@0x/types": "^2.1.1", "@0x/types": "^2.1.1",

207
contracts/asset-proxy/test/erc1155_proxy.ts
View File

@ -16,17 +16,16 @@ import * as chai from 'chai';
import { LogWithDecodedArgs } from 'ethereum-types'; import { LogWithDecodedArgs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { Erc1155Wrapper } from '../../erc1155/lib/src';
import { import {
artifacts, artifacts,
ERC721ProxyContract,
ERC1155ProxyWrapper,
IAssetDataContract,
IAssetProxyContract,
ERC1155MintableContract,
DummyERC1155ReceiverContract,
DummyERC1155ReceiverBatchTokenReceivedEventArgs, DummyERC1155ReceiverBatchTokenReceivedEventArgs,
DummyERC1155ReceiverContract,
ERC1155MintableContract,
ERC1155ProxyWrapper,
ERC721ProxyContract,
IAssetProxyContract,
} from '../src'; } from '../src';
import { Erc1155Wrapper } from '../../erc1155/lib/src';
chaiSetup.configure(); chaiSetup.configure();
const expect = chai.expect; const expect = chai.expect;
@ -91,7 +90,7 @@ describe.only('ERC1155Proxy', () => {
from: owner, from: owner,
}), }),
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
);; );
// deploy & configure ERC1155 tokens and receiver // deploy & configure ERC1155 tokens and receiver
[erc1155Wrapper] = await erc1155ProxyWrapper.deployDummyTokensAsync(); [erc1155Wrapper] = await erc1155ProxyWrapper.deployDummyTokensAsync();
erc1155Contract = erc1155Wrapper.getContract(); erc1155Contract = erc1155Wrapper.getContract();
@ -108,7 +107,8 @@ describe.only('ERC1155Proxy', () => {
nonFungibleTokensOwnedBySpender = []; nonFungibleTokensOwnedBySpender = [];
_.each(nonFungibleTokens, (nonFungibleToken: BigNumber) => { _.each(nonFungibleTokens, (nonFungibleToken: BigNumber) => {
const nonFungibleTokenAsString = nonFungibleToken.toString(); const nonFungibleTokenAsString = nonFungibleToken.toString();
const nonFungibleTokenHeldBySpender = tokenBalances.nonFungible[spender][erc1155Contract.address][nonFungibleTokenAsString][0]; const nonFungibleTokenHeldBySpender =
tokenBalances.nonFungible[spender][erc1155Contract.address][nonFungibleTokenAsString][0];
nonFungibleTokensOwnedBySpender.push(nonFungibleTokenHeldBySpender); nonFungibleTokensOwnedBySpender.push(nonFungibleTokenHeldBySpender);
}); });
}); });
@ -147,7 +147,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,
@ -175,7 +180,11 @@ describe.only('ERC1155Proxy', () => {
const tokenHolders = [spender, receiver]; const tokenHolders = [spender, receiver];
const tokenToTransfer = fungibleTokens[0]; const tokenToTransfer = fungibleTokens[0];
const tokensToTransfer = [tokenToTransfer, tokenToTransfer, tokenToTransfer]; const tokensToTransfer = [tokenToTransfer, tokenToTransfer, tokenToTransfer];
const valuesToTransfer = [fungibleValueToTransferSmall.plus(10), fungibleValueToTransferSmall.plus(20), fungibleValueToTransferSmall.plus(30)]; const valuesToTransfer = [
fungibleValueToTransferSmall.plus(10),
fungibleValueToTransferSmall.plus(20),
fungibleValueToTransferSmall.plus(30),
];
const perUnitValue = perUnitValueSmall; const perUnitValue = perUnitValueSmall;
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
@ -190,7 +199,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -207,7 +216,9 @@ describe.only('ERC1155Proxy', () => {
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
); );
// check balances after transfer // check balances after transfer
let totalValueTransferred = _.reduce(valuesToTransfer, (sum: BigNumber, value: BigNumber) => {return sum.plus(value)}) as BigNumber; let totalValueTransferred = _.reduce(valuesToTransfer, (sum: BigNumber, value: BigNumber) => {
return sum.plus(value);
}) as BigNumber;
totalValueTransferred = totalValueTransferred.times(perUnitValue); totalValueTransferred = totalValueTransferred.times(perUnitValue);
const expectedFinalBalances = [ const expectedFinalBalances = [
// spender // spender
@ -221,7 +232,11 @@ describe.only('ERC1155Proxy', () => {
// setup test parameters // setup test parameters
const tokenHolders = [spender, receiver]; const tokenHolders = [spender, receiver];
const tokensToTransfer = fungibleTokens.slice(0, 3); const tokensToTransfer = fungibleTokens.slice(0, 3);
const valuesToTransfer = [fungibleValueToTransferSmall.plus(10), fungibleValueToTransferSmall.plus(20), fungibleValueToTransferSmall.plus(30)]; const valuesToTransfer = [
fungibleValueToTransferSmall.plus(10),
fungibleValueToTransferSmall.plus(20),
fungibleValueToTransferSmall.plus(30),
];
const perUnitValue = perUnitValueSmall; const perUnitValue = perUnitValueSmall;
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
@ -240,7 +255,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -257,7 +272,9 @@ describe.only('ERC1155Proxy', () => {
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
); );
// check balances after transfer // check balances after transfer
const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {return value.times(perUnitValue)}); const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {
return value.times(perUnitValue);
});
const expectedFinalBalances = [ const expectedFinalBalances = [
// spender // spender
spenderInitialFungibleBalance.minus(totalValuesTransferred[0]), spenderInitialFungibleBalance.minus(totalValuesTransferred[0]),
@ -289,7 +306,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -318,7 +335,11 @@ describe.only('ERC1155Proxy', () => {
// setup test parameters // setup test parameters
const tokenHolders = [spender, receiver]; const tokenHolders = [spender, receiver];
const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 3); const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 3);
const valuesToTransfer = [nonFungibleValueToTransfer, nonFungibleValueToTransfer, nonFungibleValueToTransfer]; const valuesToTransfer = [
nonFungibleValueToTransfer,
nonFungibleValueToTransfer,
nonFungibleValueToTransfer,
];
const perUnitValue = perUnitValueNft; const perUnitValue = perUnitValueNft;
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
@ -337,7 +358,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -401,7 +422,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -418,7 +439,9 @@ describe.only('ERC1155Proxy', () => {
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
); );
// check balances after transfer // check balances after transfer
const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {return value.times(perUnitValue)}); const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {
return value.times(perUnitValue);
});
const expectedFinalBalances = [ const expectedFinalBalances = [
// spender // spender
expectedInitialBalances[0].minus(totalValuesTransferred[0]), expectedInitialBalances[0].minus(totalValuesTransferred[0]),
@ -441,12 +464,19 @@ describe.only('ERC1155Proxy', () => {
const tokensToTransfer = fungibleTokens.slice(0, 1); const tokensToTransfer = fungibleTokens.slice(0, 1);
const valuesToTransfer = [fungibleValueToTransferLarge]; const valuesToTransfer = [fungibleValueToTransferLarge];
const perUnitValue = perUnitValueSmall; const perUnitValue = perUnitValueSmall;
const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {return value.times(perUnitValue)}); const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {
return value.times(perUnitValue);
});
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,
@ -459,11 +489,13 @@ describe.only('ERC1155Proxy', () => {
to: erc1155Proxy.address, to: erc1155Proxy.address,
data, data,
from: authorized, from: authorized,
}) }),
); );
// check receiver log ignored extra asset data // check receiver log ignored extra asset data
expect(txReceipt.logs.length).to.be.equal(2); expect(txReceipt.logs.length).to.be.equal(2);
const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>; const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<
DummyERC1155ReceiverBatchTokenReceivedEventArgs
>;
expect(receiverLog.args.operator).to.be.equal(erc1155Proxy.address); expect(receiverLog.args.operator).to.be.equal(erc1155Proxy.address);
expect(receiverLog.args.from).to.be.equal(spender); expect(receiverLog.args.from).to.be.equal(spender);
expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1); expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1);
@ -485,12 +517,19 @@ describe.only('ERC1155Proxy', () => {
const tokensToTransfer = fungibleTokens.slice(0, 1); const tokensToTransfer = fungibleTokens.slice(0, 1);
const valuesToTransfer = [fungibleValueToTransferLarge]; const valuesToTransfer = [fungibleValueToTransferLarge];
const perUnitValue = perUnitValueSmall; const perUnitValue = perUnitValueSmall;
const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {return value.times(perUnitValue)}); const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {
return value.times(perUnitValue);
});
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const extraData = '0102030405060708'; const extraData = '0102030405060708';
const encodedAssetDataPlusExtraData = `${encodedAssetData}${extraData}`; const encodedAssetDataPlusExtraData = `${encodedAssetData}${extraData}`;
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@ -505,11 +544,13 @@ describe.only('ERC1155Proxy', () => {
to: erc1155Proxy.address, to: erc1155Proxy.address,
data, data,
from: authorized, from: authorized,
}) }),
); );
// check receiver log ignored extra asset data // check receiver log ignored extra asset data
expect(txReceipt.logs.length).to.be.equal(2); expect(txReceipt.logs.length).to.be.equal(2);
const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>; const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<
DummyERC1155ReceiverBatchTokenReceivedEventArgs
>;
expect(receiverLog.args.operator).to.be.equal(erc1155Proxy.address); expect(receiverLog.args.operator).to.be.equal(erc1155Proxy.address);
expect(receiverLog.args.from).to.be.equal(spender); expect(receiverLog.args.from).to.be.equal(spender);
expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1); expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1);
@ -541,14 +582,19 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,
receiverContract, receiverContract,
perUnitValue, perUnitValue,
); );
return await expectTransactionFailedAsync( await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({ web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address, to: erc1155Proxy.address,
data, data,
@ -579,7 +625,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -619,7 +665,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -640,7 +686,7 @@ describe.only('ERC1155Proxy', () => {
// setup test parameters // setup test parameters
const tokenHolders = [spender, receiver]; const tokenHolders = [spender, receiver];
const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 3); const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 3);
const maxUintValue = (new BigNumber(2)).pow(256).minus(1); const maxUintValue = new BigNumber(2).pow(256).minus(1);
const valuesToTransfer = [nonFungibleValueToTransfer, maxUintValue, nonFungibleValueToTransfer]; const valuesToTransfer = [nonFungibleValueToTransfer, maxUintValue, nonFungibleValueToTransfer];
const perUnitValue = new BigNumber(2); const perUnitValue = new BigNumber(2);
// check balances before transfer // check balances before transfer
@ -661,7 +707,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -679,32 +725,32 @@ describe.only('ERC1155Proxy', () => {
); );
}); });
it('should revert if transferring > 1 instances of a non-fungible token (perUnitValue field >1)', async () => { it('should revert if transferring > 1 instances of a non-fungible token (perUnitValue field >1)', async () => {
// setup test parameters // setup test parameters
const tokenHolders = [spender, receiver]; const tokenHolders = [spender, receiver];
const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 1); const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 1);
const valuesToTransfer = [nonFungibleValueToTransfer]; const valuesToTransfer = [nonFungibleValueToTransfer];
const perUnitValue = new BigNumber(2); const perUnitValue = new BigNumber(2);
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
// spender // spender
nftOwnerBalance, nftOwnerBalance,
// receiver // receiver
nftNotOwnerBalance, nftNotOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData( const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,
receiver, receiver,
perUnitValue, perUnitValue,
); );
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({ web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address, to: erc1155Proxy.address,
@ -733,7 +779,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address, erc1155Contract.address,
tokensToTransfer, tokensToTransfer,
valuesToTransfer, valuesToTransfer,
receiverCallbackData receiverCallbackData,
); );
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
@ -741,14 +787,14 @@ describe.only('ERC1155Proxy', () => {
receiver, receiver,
perUnitValue, perUnitValue,
); );
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({ web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address, to: erc1155Proxy.address,
data, data,
from: authorized, from: authorized,
}), }),
RevertReason.amountEqualToOneRequired, RevertReason.amountEqualToOneRequired,
); );
}); });
it('should revert if sender balance is insufficient', async () => { it('should revert if sender balance is insufficient', async () => {
// setup test parameters // setup test parameters
@ -761,7 +807,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,
@ -793,7 +844,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,
@ -819,7 +875,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance]; const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances); await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer // execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData); const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData( const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData, encodedAssetData,
spender, spender,

120
contracts/asset-proxy/test/utils/erc1155_proxy_wrapper.ts
View File

@ -1,22 +1,28 @@
import { constants, ERC1155HoldingsByOwner, ERC1155FungibleHoldingsByOwner, ERC1155NonFungibleHoldingsByOwner, LogDecoder, txDefaults } from '@0x/contracts-test-utils'; import { Erc1155Wrapper } from '@0x/contracts-erc1155';
import { generatePseudoRandomSalt } from '@0x/order-utils'; import {
constants,
ERC1155FungibleHoldingsByOwner,
ERC1155HoldingsByOwner,
ERC1155NonFungibleHoldingsByOwner,
LogDecoder,
txDefaults,
} from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import { Web3Wrapper } from '@0x/web3-wrapper'; import { Web3Wrapper } from '@0x/web3-wrapper';
import { Provider } from 'ethereum-types'; import { Provider } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { Erc1155Wrapper } from '@0x/contracts-erc1155'; import {
artifacts,
import { LogWithDecodedArgs } from 'ethereum-types'; ERC1155MintableContract,
ERC1155ProxyContract,
import { artifacts, ERC1155MintableContract, ERC1155ProxyContract, ERC1155MintableTransferSingleEventArgs } from '../../src'; } from '../../src';
export class ERC1155ProxyWrapper { export class ERC1155ProxyWrapper {
private readonly _tokenOwnerAddresses: string[]; private readonly _tokenOwnerAddresses: string[];
private readonly _fungibleTokenIds: string[]; private readonly _fungibleTokenIds: string[];
private readonly _nonFungibleTokenIds: string[]; private readonly _nonFungibleTokenIds: string[];
private readonly _nfts: {id: BigNumber, tokenId: BigNumber}[]; private readonly _nfts: Array<{ id: BigNumber; tokenId: BigNumber }>;
private readonly _contractOwnerAddress: string; private readonly _contractOwnerAddress: string;
private readonly _web3Wrapper: Web3Wrapper; private readonly _web3Wrapper: Web3Wrapper;
private readonly _provider: Provider; private readonly _provider: Provider;
@ -24,7 +30,7 @@ export class ERC1155ProxyWrapper {
private readonly _dummyTokenWrappers: Erc1155Wrapper[]; private readonly _dummyTokenWrappers: Erc1155Wrapper[];
private _proxyContract?: ERC1155ProxyContract; private _proxyContract?: ERC1155ProxyContract;
private _proxyIdIfExists?: string; private _proxyIdIfExists?: string;
private _initialTokenIdsByOwner: ERC1155HoldingsByOwner = {fungible: {}, nonFungible: {}}; private _initialTokenIdsByOwner: ERC1155HoldingsByOwner = { fungible: {}, nonFungible: {} };
constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) { constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
this._web3Wrapper = new Web3Wrapper(provider); this._web3Wrapper = new Web3Wrapper(provider);
this._provider = provider; this._provider = provider;
@ -44,7 +50,6 @@ export class ERC1155ProxyWrapper {
this._provider, this._provider,
txDefaults, txDefaults,
); );
console.log(erc1155Contract.address);
const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress); const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress);
this._dummyTokenWrappers.push(erc1155Wrapper); this._dummyTokenWrappers.push(erc1155Wrapper);
} }
@ -67,17 +72,22 @@ export class ERC1155ProxyWrapper {
this._validateDummyTokenContractsExistOrThrow(); this._validateDummyTokenContractsExistOrThrow();
this._validateProxyContractExistsOrThrow(); this._validateProxyContractExistsOrThrow();
this._initialTokenIdsByOwner = { this._initialTokenIdsByOwner = {
fungible: {} as ERC1155FungibleHoldingsByOwner, fungible: {},
nonFungible: {} nonFungible: {},
}; };
const fungibleHoldingsByOwner: ERC1155FungibleHoldingsByOwner = {}; const fungibleHoldingsByOwner: ERC1155FungibleHoldingsByOwner = {};
const nonFungibleHoldingsByOwner: ERC1155NonFungibleHoldingsByOwner = {}; const nonFungibleHoldingsByOwner: ERC1155NonFungibleHoldingsByOwner = {};
// set balances accordingly // Set balances accordingly
const fungibleTokensToMintRange = _.range(0, constants.NUM_ERC1155_FUNGIBLE_TOKENS_MINT);
const nonFungibleTokensToMintRange = _.range(0, constants.NUM_ERC1155_NONFUNGIBLE_TOKENS_MINT);
for (const dummyWrapper of this._dummyTokenWrappers) { for (const dummyWrapper of this._dummyTokenWrappers) {
const dummyAddress = dummyWrapper.getContract().address; const dummyAddress = dummyWrapper.getContract().address;
for (const i of _.times(constants.NUM_ERC1155_FUNGIBLE_TOKENS_MINT)) { _.each(fungibleTokensToMintRange, async () => {
// Create a fungible token // Create a fungible token
const tokenId = await dummyWrapper.mintFungibleTokensAsync(this._tokenOwnerAddresses, constants.INITIAL_ERC1155_FUNGIBLE_BALANCE); const tokenId = await dummyWrapper.mintFungibleTokensAsync(
this._tokenOwnerAddresses,
constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
);
const tokenIdAsString = tokenId.toString(); const tokenIdAsString = tokenId.toString();
this._fungibleTokenIds.push(tokenIdAsString); this._fungibleTokenIds.push(tokenIdAsString);
// Mint tokens for each owner for this token // Mint tokens for each owner for this token
@ -89,35 +99,44 @@ export class ERC1155ProxyWrapper {
if (_.isUndefined(fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) { if (_.isUndefined(fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) {
fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {}; fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {};
} }
fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] = constants.INITIAL_ERC1155_FUNGIBLE_BALANCE; fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] =
await dummyWrapper.setApprovalForAllAsync(tokenOwnerAddress, (this._proxyContract as ERC1155ProxyContract).address, true); constants.INITIAL_ERC1155_FUNGIBLE_BALANCE;
await dummyWrapper.setApprovalForAllAsync(
tokenOwnerAddress,
(this._proxyContract as ERC1155ProxyContract).address,
true,
);
} }
} });
// Non-Fungible Tokens // Non-fungible tokens
for (const i of _.times(constants.NUM_ERC1155_NONFUNGIBLE_TOKENS_MINT)) { _.each(nonFungibleTokensToMintRange, async () => {
const [tokenId, nftIds] = await dummyWrapper.mintNonFungibleTokensAsync(this._tokenOwnerAddresses); const [tokenId, nftIds] = await dummyWrapper.mintNonFungibleTokensAsync(this._tokenOwnerAddresses);
const tokenIdAsString = tokenId.toString(); const tokenIdAsString = tokenId.toString();
this._nonFungibleTokenIds.push(tokenIdAsString); this._nonFungibleTokenIds.push(tokenIdAsString);
_.each(this._tokenOwnerAddresses, async (tokenOwnerAddress: string, i: number) => { _.each(this._tokenOwnerAddresses, async (tokenOwnerAddress: string, i: number) => {
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress])) { if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress] = {}; nonFungibleHoldingsByOwner[tokenOwnerAddress] = {};
} }
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) { if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {}; nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {};
} }
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString])) { if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] = []; nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] = [];
} }
this._nfts.push({id: nftIds[i], tokenId}); this._nfts.push({ id: nftIds[i], tokenId });
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString].push(nftIds[i]); nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString].push(nftIds[i]);
await dummyWrapper.setApprovalForAllAsync(tokenOwnerAddress, (this._proxyContract as ERC1155ProxyContract).address, true); await dummyWrapper.setApprovalForAllAsync(
tokenOwnerAddress,
(this._proxyContract as ERC1155ProxyContract).address,
true,
);
}); });
} });
} }
this._initialTokenIdsByOwner = { this._initialTokenIdsByOwner = {
fungible: fungibleHoldingsByOwner, fungible: fungibleHoldingsByOwner,
nonFungible: nonFungibleHoldingsByOwner, nonFungible: nonFungibleHoldingsByOwner,
} };
return this._initialTokenIdsByOwner; return this._initialTokenIdsByOwner;
} }
public async ownerOfNonFungibleAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> { public async ownerOfNonFungibleAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> {
@ -125,7 +144,11 @@ export class ERC1155ProxyWrapper {
const owner = await tokenContract.ownerOf.callAsync(tokenId); const owner = await tokenContract.ownerOf.callAsync(tokenId);
return owner; return owner;
} }
public async isNonFungibleOwnerAsync(userAddress: string, tokenAddress: string, tokenId: BigNumber): Promise<boolean> { public async isNonFungibleOwnerAsync(
userAddress: string,
tokenAddress: string,
tokenId: BigNumber,
): Promise<boolean> {
const tokenContract = this._getTokenContractFromAssetData(tokenAddress); const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
const tokenOwner = await tokenContract.ownerOf.callAsync(tokenId); const tokenOwner = await tokenContract.ownerOf.callAsync(tokenId);
const isOwner = tokenOwner === userAddress; const isOwner = tokenOwner === userAddress;
@ -181,12 +204,18 @@ export class ERC1155ProxyWrapper {
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress])) { if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress] = {}; nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress] = {};
} }
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()])) { if (
_.isUndefined(
nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()],
)
) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()] = []; nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()] = [];
} }
const isOwner = balances[i++]; const isOwner = balances[i++];
if (isOwner.isEqualTo(1)) { if (isOwner.isEqualTo(1)) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()].push(nft.id); nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()].push(
nft.id,
);
} }
} }
} }
@ -194,22 +223,28 @@ export class ERC1155ProxyWrapper {
const holdingsByOwner = { const holdingsByOwner = {
fungible: tokenHoldingsByOwner, fungible: tokenHoldingsByOwner,
nonFungible: nonFungibleHoldingsByOwner, nonFungible: nonFungibleHoldingsByOwner,
} };
return holdingsByOwner; return holdingsByOwner;
} }
public getFungibleTokenIds(): BigNumber[] { public getFungibleTokenIds(): BigNumber[] {
const fungibleTokenIds = _.map(this._fungibleTokenIds, (tokenIdAsString: string) => {return new BigNumber(tokenIdAsString)}); const fungibleTokenIds = _.map(this._fungibleTokenIds, (tokenIdAsString: string) => {
return new BigNumber(tokenIdAsString);
});
return fungibleTokenIds; return fungibleTokenIds;
} }
public getNonFungibleTokenIds(): BigNumber[] { public getNonFungibleTokenIds(): BigNumber[] {
const nonFungibleTokenIds = _.map(this._nonFungibleTokenIds, (tokenIdAsString: string) => {return new BigNumber(tokenIdAsString)}); const nonFungibleTokenIds = _.map(this._nonFungibleTokenIds, (tokenIdAsString: string) => {
return new BigNumber(tokenIdAsString);
});
return nonFungibleTokenIds; return nonFungibleTokenIds;
} }
public getTokenOwnerAddresses(): string[] { public getTokenOwnerAddresses(): string[] {
return this._tokenOwnerAddresses; return this._tokenOwnerAddresses;
} }
public getTokenWrapper(tokenAddress: string): Erc1155Wrapper { public getTokenWrapper(tokenAddress: string): Erc1155Wrapper {
const tokenWrapper = _.find(this._dummyTokenWrappers, (wrapper: Erc1155Wrapper) => {return wrapper.getContract().address === tokenAddress}); const tokenWrapper = _.find(this._dummyTokenWrappers, (wrapper: Erc1155Wrapper) => {
return wrapper.getContract().address === tokenAddress;
});
if (_.isUndefined(tokenWrapper)) { if (_.isUndefined(tokenWrapper)) {
throw new Error(`Token: ${tokenAddress} was not deployed through ERC1155Wrapper`); throw new Error(`Token: ${tokenAddress} was not deployed through ERC1155Wrapper`);
} }
@ -239,7 +274,10 @@ export class ERC1155ProxyWrapper {
} }
} }
private _validateBalancesAndAllowancesSetOrThrow(): void { private _validateBalancesAndAllowancesSetOrThrow(): void {
if (_.keys(this._initialTokenIdsByOwner.fungible).length === 0 || _.keys(this._initialTokenIdsByOwner.nonFungible).length === 0) { if (
_.keys(this._initialTokenIdsByOwner.fungible).length === 0 ||
_.keys(this._initialTokenIdsByOwner.nonFungible).length === 0
) {
throw new Error( throw new Error(
'Dummy ERC1155 balances and allowances not yet set, please call "setBalancesAndAllowancesAsync"', 'Dummy ERC1155 balances and allowances not yet set, please call "setBalancesAndAllowancesAsync"',
); );

12
contracts/test-utils/src/types.ts
View File

@ -17,22 +17,22 @@ export interface ERC721TokenIdsByOwner {
export interface ERC1155FungibleHoldingsByOwner { export interface ERC1155FungibleHoldingsByOwner {
[ownerAddress: string]: { [ownerAddress: string]: {
[tokenAddress: string]: { [tokenAddress: string]: {
[tokenId: string]: BigNumber [tokenId: string]: BigNumber;
} };
}; };
} }
export interface ERC1155NonFungibleHoldingsByOwner { export interface ERC1155NonFungibleHoldingsByOwner {
[ownerAddress: string]: { [ownerAddress: string]: {
[tokenAddress: string]: { [tokenAddress: string]: {
[tokenId: string]: BigNumber[] [tokenId: string]: BigNumber[];
} };
}; };
} }
export interface ERC1155HoldingsByOwner { export interface ERC1155HoldingsByOwner {
fungible: ERC1155FungibleHoldingsByOwner, fungible: ERC1155FungibleHoldingsByOwner;
nonFungible: ERC1155NonFungibleHoldingsByOwner, nonFungible: ERC1155NonFungibleHoldingsByOwner;
} }
export interface SubmissionContractEventArgs { export interface SubmissionContractEventArgs {

11
packages/order-utils/src/asset_data_utils.ts
View File

@ -100,8 +100,13 @@ export const assetDataUtils = {
* @return The hex encoded assetData string * @return The hex encoded assetData string
*/ */
encodeERC1155AssetData(tokenAddress: string, tokenIds: BigNumber[], tokenValues: BigNumber[], callbackData: string): string { encodeERC1155AssetData(
const abiEncoder = AbiEncoder.createMethod('ERC1155Token', ['address','uint256[]','uint256[]','bytes']); tokenAddress: string,
tokenIds: BigNumber[],
tokenValues: BigNumber[],
callbackData: string,
): string {
const abiEncoder = AbiEncoder.createMethod('ERC1155Token', ['address', 'uint256[]', 'uint256[]', 'bytes']);
const args = [tokenAddress, tokenIds, tokenValues, callbackData]; const args = [tokenAddress, tokenIds, tokenValues, callbackData];
const assetData = abiEncoder.encode(args, encodingRules); const assetData = abiEncoder.encode(args, encodingRules);
return assetData; return assetData;
@ -186,7 +191,7 @@ export const assetDataUtils = {
if ( if (
assetProxyId !== AssetProxyId.ERC20 && assetProxyId !== AssetProxyId.ERC20 &&
assetProxyId !== AssetProxyId.ERC721 && assetProxyId !== AssetProxyId.ERC721 &&
assetProxyId !== AssetProxyId.ERC1155 && assetProxyId !== AssetProxyId.ERC1155 &&
assetProxyId !== AssetProxyId.MultiAsset assetProxyId !== AssetProxyId.MultiAsset
) { ) {
throw new Error(`Invalid assetProxyId: ${assetProxyId}`); throw new Error(`Invalid assetProxyId: ${assetProxyId}`);