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

removed erc1155 proxy tests from general proxy test file

Browse Source
This commit is contained in:
Greg Hysen
2019-03-04 13:28:10 -08:00
parent 4dfb610eba
commit 054c0e91a3
2 changed files with 4 additions and 752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -11,33 +11,21 @@ import {
import { BlockchainLifecycle } from '@0x/dev-utils';
import { assetDataUtils } from '@0x/order-utils';
import { RevertReason } from '@0x/types';
import { BigNumber, AbiEncoder } from '@0x/utils';
import { BigNumber } from '@0x/utils';
import * as chai from 'chai';
import { LogWithDecodedArgs } from 'ethereum-types';
import * as _ from 'lodash';
import {
artifacts,
DummyERC20TokenContract,
DummyERC20TokenTransferEventArgs,
DummyERC721ReceiverContract,
DummyERC721TokenContract,
DummyMultipleReturnERC20TokenContract,
DummyNoReturnERC20TokenContract,
ERC20ProxyContract,
ERC20Wrapper,
ERC721ProxyContract,
ERC721Wrapper,
ERC1155ProxyWrapper,
ERC1155ProxyContract,
IAssetDataContract,
IAssetProxyContract,
MultiAssetProxyContract,
ERC1155MintableContract,
DummyERC1155ReceiverContract,
DummyERC1155ReceiverBatchTokenReceivedEventArgs,
} from '../src';
import values from 'ramda/es/values';
import { Erc1155Wrapper } from '../../erc1155/lib/src';
chaiSetup.configure();
@@ -48,11 +36,6 @@ const assetProxyInterface = new IAssetProxyContract(
constants.NULL_ADDRESS,
provider,
);
const assetDataInterface = new IAssetDataContract(
artifacts.IAssetData.compilerOutput.abi,
constants.NULL_ADDRESS,
provider,
);
// tslint:disable:no-unnecessary-type-assertion
describe.only('ERC1155Proxy', () => {

737
contracts/asset-proxy/test/proxies.ts
View File

@@ -23,7 +23,7 @@ import {
import { BlockchainLifecycle } from '@0x/dev-utils';
import { assetDataUtils } from '@0x/order-utils';
import { RevertReason } from '@0x/types';
import { BigNumber, AbiEncoder } from '@0x/utils';
import { BigNumber } from '@0x/utils';
import * as chai from 'chai';
import { LogWithDecodedArgs } from 'ethereum-types';
import * as _ from 'lodash';
@@ -34,16 +34,10 @@ import {
ERC20Wrapper,
ERC721ProxyContract,
ERC721Wrapper,
ERC1155ProxyWrapper,
ERC1155ProxyContract,
IAssetDataContract,
IAssetProxyContract,
MultiAssetProxyContract,
ERC1155MintableContract,
DummyERC1155ReceiverContract,
DummyERC1155ReceiverBatchTokenReceivedEventArgs,
} from '../src';
import values from 'ramda/es/values';
chaiSetup.configure();
const expect = chai.expect;
@@ -74,22 +68,15 @@ describe('Asset Transfer Proxies', () => {
let erc721Receiver: DummyERC721ReceiverContract;
let erc20Proxy: ERC20ProxyContract;
let erc721Proxy: ERC721ProxyContract;
let erc1155Proxy: ERC721ProxyContract;
let erc1155Receiver: DummyERC1155ReceiverContract;
let noReturnErc20Token: DummyNoReturnERC20TokenContract;
let multipleReturnErc20Token: DummyMultipleReturnERC20TokenContract;
let multiAssetProxy: MultiAssetProxyContract;
let erc20Wrapper: ERC20Wrapper;
let erc721Wrapper: ERC721Wrapper;
let erc1155ProxyWrapper: ERC1155ProxyWrapper;
let erc721AFromTokenId: BigNumber;
let erc721BFromTokenId: BigNumber;
let erc1155Token: ERC1155MintableContract;
let erc1155FungibleTokenIds: BigNumber[];
let erc1155NonFungibleTokenIds: BigNumber[];
before(async () => {
await blockchainLifecycle.startAsync();
});
@@ -102,12 +89,10 @@ describe('Asset Transfer Proxies', () => {
erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
erc721Wrapper = new ERC721Wrapper(provider, usedAddresses, owner);
erc1155ProxyWrapper = new ERC1155ProxyWrapper(provider, usedAddresses, owner);
// Deploy AssetProxies
erc20Proxy = await erc20Wrapper.deployProxyAsync();
erc721Proxy = await erc721Wrapper.deployProxyAsync();
erc1155Proxy = await erc1155ProxyWrapper.deployProxyAsync();
multiAssetProxy = await MultiAssetProxyContract.deployFrom0xArtifactAsync(
artifacts.MultiAssetProxy,
provider,
@@ -142,20 +127,6 @@ describe('Asset Transfer Proxies', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Configure ERC1155Proxy
await web3Wrapper.awaitTransactionSuccessAsync(
await erc1155Proxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
from: owner,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await erc1155Proxy.addAuthorizedAddress.sendTransactionAsync(multiAssetProxy.address, {
from: owner,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Configure MultiAssetProxy
await web3Wrapper.awaitTransactionSuccessAsync(
await multiAssetProxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
@@ -237,22 +208,11 @@ describe('Asset Transfer Proxies', () => {
provider,
txDefaults,
);
await erc721Wrapper.setBalancesAndAllowancesAsync();
const erc721Balances = await erc721Wrapper.getBalancesAsync();
erc721AFromTokenId = erc721Balances[fromAddress][erc721TokenA.address][0];
erc721BFromTokenId = erc721Balances[fromAddress][erc721TokenB.address][0];
// Deploy and configure ERC1155 tokens and receiver
const [erc1155Wrapper] = await erc1155ProxyWrapper.deployDummyTokensAsync();
erc1155Token = erc1155Wrapper.getContract();
erc1155Receiver = await DummyERC1155ReceiverContract.deployFrom0xArtifactAsync(
artifacts.DummyERC1155Receiver,
provider,
txDefaults,
);
await erc1155ProxyWrapper.setBalancesAndAllowancesAsync();
erc1155FungibleTokenIds = erc1155ProxyWrapper.getFungibleTokenIds();
erc1155NonFungibleTokenIds = erc1155ProxyWrapper.getNonFungibleTokenIds();
});
beforeEach(async () => {
await blockchainLifecycle.startAsync();
@@ -517,6 +477,7 @@ describe('Asset Transfer Proxies', () => {
});
});
});
describe('ERC721Proxy', () => {
it('should revert if undefined function is called', async () => {
const undefinedSelector = '0x01020304';
@@ -1325,698 +1286,6 @@ describe('Asset Transfer Proxies', () => {
});
});
});
describe('ERC1155Proxy', () => {
it('should revert if undefined function is called', async () => {
const undefinedSelector = '0x01020304';
await expectTransactionFailedWithoutReasonAsync(
web3Wrapper.sendTransactionAsync({
from: owner,
to: erc1155Proxy.address,
value: constants.ZERO_AMOUNT,
data: undefinedSelector,
}),
);
});
it('should have an id of 0x9645780d', async () => {
const proxyId = await erc1155Proxy.getProxyId.callAsync();
// proxy computed using -- bytes4(keccak256("ERC1155Token(address,uint256[],uint256[],bytes)"));
const expectedProxyId = '0x9645780d';
expect(proxyId).to.equal(expectedProxyId);
});
describe('transferFrom', () => {
it('should successfully transfer value for a single token', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const tokenIdsToTransfer = [fungibleTokenIdToTransfer];
const tokenValuesToTransfer = [new BigNumber(10)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify pre-condition
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const initialSenderBalance = initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const initialReceiverBalance = initialHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1000);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Verify transfer was successful
const totalValueTransferred = tokenValuesToTransfer[0].times(perUnitValue);
const newHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const newSenderBalance = newHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewSenderBalance = initialSenderBalance.minus(totalValueTransferred);
const newReceiverBalance = newHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewReceiverBalance = initialReceiverBalance.plus(totalValueTransferred);
expect(newSenderBalance).to.be.bignumber.equal(expectedNewSenderBalance);
expect(newReceiverBalance).to.be.bignumber.equal(expectedNewReceiverBalance);
});
it('should successfully transfer value for a collection of fungible tokens of the same id', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const tokenIdsToTransfer = [fungibleTokenIdToTransfer, fungibleTokenIdToTransfer, fungibleTokenIdToTransfer];
const tokenValuesToTransfer = [new BigNumber(10), new BigNumber(20), new BigNumber(30)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify pre-condition
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const initialSenderBalance = initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const initialReceiverBalance = initialHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1000);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Verify transfer was successful
const totalValueTransferred = _.reduce(tokenValuesToTransfer, (sum: BigNumber, value: BigNumber) => {return sum.plus(value)}, new BigNumber(0)).times(perUnitValue);
const newHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const newSenderBalance = newHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewSenderBalance = initialSenderBalance.minus(totalValueTransferred);
const newReceiverBalance = newHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewReceiverBalance = initialReceiverBalance.plus(totalValueTransferred);
expect(newSenderBalance).to.be.bignumber.equal(expectedNewSenderBalance);
expect(newReceiverBalance).to.be.bignumber.equal(expectedNewReceiverBalance);
});
it('should successfully transfer value for a collection of fungible tokens of different ids', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const tokenIdsToTransfer = erc1155FungibleTokenIds.slice(0, 2);
const tokenValuesToTransfer = [new BigNumber(10), new BigNumber(20)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify pre-condition
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const initialSenderBalances: BigNumber[] = [];
const initialReceiverBalances: BigNumber[] = [];
_.each(tokenIdsToTransfer, (tokenIdToTransfer: BigNumber) => {
initialSenderBalances.push(initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][tokenIdToTransfer.toString()]);
initialReceiverBalances.push(initialHoldingsByOwner.fungible[toAddress][erc1155Token.address][tokenIdToTransfer.toString()]);
});
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1000);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Verify transfer was successful
const newHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
_.each(tokenIdsToTransfer, (tokenIdToTransfer: BigNumber, i: number) => {
const totalValueTransferred = tokenValuesToTransfer[i].times(perUnitValue);
const newSenderBalance = newHoldingsByOwner.fungible[fromAddress][erc1155Token.address][tokenIdToTransfer.toString()];
const expectedNewSenderBalance = initialSenderBalances[i].minus(totalValueTransferred);
const newReceiverBalance = newHoldingsByOwner.fungible[toAddress][erc1155Token.address][tokenIdToTransfer.toString()];
const expectedNewReceiverBalance = initialReceiverBalances[i].plus(totalValueTransferred);
expect(newSenderBalance).to.be.bignumber.equal(expectedNewSenderBalance);
expect(newReceiverBalance).to.be.bignumber.equal(expectedNewReceiverBalance);
});
});
it('should successfully transfer a non-fungible token', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify precondition
const nftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(nftHolder).to.be.equal(fromAddress);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Verify transfer was successful
const newNftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(newNftHolder).to.be.equal(toAddress);
// Verify balances updated successfully
const newHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const newNftsForFromAddress = newHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()];
const newNftsForToAddress = newHoldingsByOwner.nonFungible[toAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()];
expect(_.find(newNftsForFromAddress, nftToTransfer)).to.be.undefined();
expect(_.find(newNftsForToAddress, nftToTransfer)).to.be.not.undefined();
});
it('should successfully transfer value for a combination of fungible/non-fungible tokens', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [fungibleTokenIdToTransfer, nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(10), new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify precondition
const initialSenderBalance = initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const initialReceiverBalance = initialHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const nftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(nftHolder).to.be.equal(fromAddress);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Verify non-fungible transfer was successful
const newNftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(newNftHolder).to.be.equal(toAddress);
// Verify non-fungible balances updated successfully
const newHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const newNftsForFromAddress = newHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()];
const newNftsForToAddress = newHoldingsByOwner.nonFungible[toAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()];
expect(_.find(newNftsForFromAddress, nftToTransfer)).to.be.undefined();
expect(_.find(newNftsForToAddress, nftToTransfer)).to.be.not.undefined();
// Verify fungible transfer was successful
const totalValueTransferred = tokenValuesToTransfer[0].times(perUnitValue);
const newSenderBalance = newHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewSenderBalance = initialSenderBalance.minus(totalValueTransferred);
const newReceiverBalance = newHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewReceiverBalance = initialReceiverBalance.plus(totalValueTransferred);
expect(newSenderBalance).to.be.bignumber.equal(expectedNewSenderBalance);
expect(newReceiverBalance).to.be.bignumber.equal(expectedNewReceiverBalance);
});
it('should successfully transfer value for a combination of several fungible/non-fungible tokens', async () => {
// Check inital balances and construct asset data
const erc1155Wrapper = erc1155ProxyWrapper.getTokenWrapper(erc1155Token.address);
const spenderInitialFungibleBalance = constants.INITIAL_ERC1155_FUNGIBLE_BALANCE;
const receiverInitialFungibleBalance = constants.INITIAL_ERC1155_FUNGIBLE_BALANCE;
const expectedInitialBalances = [
// spender balances
spenderInitialFungibleBalance,
spenderInitialFungibleBalance,
spenderInitialFungibleBalance,
new BigNumber(1),
new BigNumber(1),
// receiver balances
receiverInitialFungibleBalance,
receiverInitialFungibleBalance,
receiverInitialFungibleBalance,
new BigNumber(0),
new BigNumber(0),
];
const tokenHolders = [
fromAddress,
toAddress,
];
const fungibleTokenIdsToTransfer = erc1155FungibleTokenIds.slice(0, 3);
const nonFungibleTokenIdsToTransfer = erc1155NonFungibleTokenIds.slice(0, 2);
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftsToTransfer = [
initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdsToTransfer[0].toString()][0],
initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdsToTransfer[1].toString()][0],
];
const tokenIdsToTransfer = fungibleTokenIdsToTransfer.concat(nftsToTransfer);
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokenIdsToTransfer, expectedInitialBalances);
const callbackData = "0x";
const tokenValuesToTransfer = [spenderInitialFungibleBalance, spenderInitialFungibleBalance, spenderInitialFungibleBalance, new BigNumber(1),new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Check final balances
const expectedFinalBalances = [
// spender balances
new BigNumber(0),
new BigNumber(0),
new BigNumber(0),
new BigNumber(0),
new BigNumber(0),
// receiver balances
receiverInitialFungibleBalance.plus(spenderInitialFungibleBalance),
receiverInitialFungibleBalance.plus(spenderInitialFungibleBalance),
receiverInitialFungibleBalance.plus(spenderInitialFungibleBalance),
new BigNumber(1),
new BigNumber(1),
];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokenIdsToTransfer, expectedFinalBalances);
});
it('should successfully transfer value and ignore extra assetData', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const tokenIdsToTransfer = [fungibleTokenIdToTransfer];
const tokenValuesToTransfer = [new BigNumber(10)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
const extraData = '0102030405060708';
const encodedAssetDataPlusExtraData = `${encodedAssetData}${extraData}`;
// Verify pre-condition
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const initialSenderBalance = initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const initialReceiverBalance = initialHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1000);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetDataPlusExtraData,
fromAddress,
toAddress,
perUnitValue,
);
await web3Wrapper.awaitTransactionSuccessAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Verify transfer was successful
const totalValueTransferred = tokenValuesToTransfer[0].times(perUnitValue);
const newHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const newSenderBalance = newHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewSenderBalance = initialSenderBalance.minus(totalValueTransferred);
const newReceiverBalance = newHoldingsByOwner.fungible[toAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
const expectedNewReceiverBalance = initialReceiverBalance.plus(totalValueTransferred);
expect(newSenderBalance).to.be.bignumber.equal(expectedNewSenderBalance);
expect(newReceiverBalance).to.be.bignumber.equal(expectedNewReceiverBalance);
});
it('should successfully execute callback when transferring to a smart contract', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify precondition
const nftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(nftHolder).to.be.equal(fromAddress);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
erc1155Receiver.address,
perUnitValue,
);
const logDecoder = new LogDecoder(web3Wrapper, artifacts);
const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
})
);
// Verify logs
expect(txReceipt.logs.length).to.be.equal(2);
const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>;
expect(receiverLog.args.operator).to.be.equal(erc1155Proxy.address);
expect(receiverLog.args.from).to.be.equal(fromAddress);
expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1);
expect(receiverLog.args.tokenIds[0]).to.be.bignumber.equal(tokenIdsToTransfer[0]);
expect(receiverLog.args.tokenValues.length).to.be.deep.equal(1);
expect(receiverLog.args.tokenValues[0]).to.be.bignumber.equal(tokenValuesToTransfer[0]);
expect(receiverLog.args.data).to.be.deep.equal(callbackData);
// Verify transfer was successful
const newNftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(newNftHolder).to.be.equal(erc1155Receiver.address);
});
it('should successfully execute callback when transferring to a smart contract when there is callback data', async () => {
// Construct ERC1155 asset data
const callbackData = "0x12345678";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify precondition
const nftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(nftHolder).to.be.equal(fromAddress);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
erc1155Receiver.address,
perUnitValue,
);
const logDecoder = new LogDecoder(web3Wrapper, artifacts);
const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
await web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
})
);
// Verify logs
expect(txReceipt.logs.length).to.be.equal(2);
const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>;
expect(receiverLog.args.operator).to.be.equal(erc1155Proxy.address);
expect(receiverLog.args.from).to.be.equal(fromAddress);
expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1);
expect(receiverLog.args.tokenIds[0]).to.be.bignumber.equal(tokenIdsToTransfer[0]);
expect(receiverLog.args.tokenValues.length).to.be.deep.equal(1);
expect(receiverLog.args.tokenValues[0]).to.be.bignumber.equal(tokenValuesToTransfer[0]);
expect(receiverLog.args.data).to.be.deep.equal(callbackData);
// Verify transfer was successful
const newNftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(newNftHolder).to.be.equal(erc1155Receiver.address);
});
it('should propagate revert reason from erc1155 contract failure', async () => {
// Disable transfers
const shouldRejectTransfer = true;
await web3Wrapper.awaitTransactionSuccessAsync(
await erc1155Receiver.setRejectTransferFlag.sendTransactionAsync(shouldRejectTransfer),
constants.AWAIT_TRANSACTION_MINED_MS,
);
// Construct ERC1155 asset data
const callbackData = "0x12345678";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
erc1155Receiver.address,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.TransferRejected,
);
});
it('should revert if transferring the same non-fungible token more than once', async () => {
// Construct ERC1155 asset data
const callbackData = "0x12345678";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer, nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1), new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Verify precondition
const nftHolder = await erc1155ProxyWrapper.ownerOfNonFungibleAsync(erc1155Token.address, nftToTransfer);
expect(nftHolder).to.be.equal(fromAddress);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
erc1155Receiver.address,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.nftNotOwnedByFromAddress,
);
});
it('should revert if tansferring 0 amount of any token', async () => {
// Construct ERC1155 asset data
const callbackData = "0x12345678";
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const tokenIdsToTransfer = [
initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][erc1155NonFungibleTokenIds[0].toString()][0],
initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][erc1155NonFungibleTokenIds[1].toString()][0],
initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][erc1155NonFungibleTokenIds[2].toString()][0],
];
const tokenValuesToTransfer = [new BigNumber(1), new BigNumber(0), new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
erc1155Receiver.address,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.transferGreaterThanZeroRequired,
);
});
it('should revert if there is a multiplication overflow', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const tokenIdsToTransfer = [fungibleTokenIdToTransfer];
const maxUintValue = (new BigNumber(2)).pow(256).minus(1);
const tokenValuesToTransfer = [maxUintValue];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(2);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.Uint256Overflow,
);
});
it('should revert if there is a multiplication overflow, when transferring multiple tokens', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const tokenIdsToTransfer = erc1155FungibleTokenIds.slice(3);
const maxUintValue = (new BigNumber(2)).pow(256).minus(1);
// Note - the second token will fail
const tokenValuesToTransfer = [new BigNumber(1), maxUintValue, new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(2);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.Uint256Overflow,
);
});
it('should revert if transferring > 1 instances of a non-fungible token (amount field >1)', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(2);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.amountEqualToOneRequired,
);
});
it('should revert if transferring > 1 instances of a non-fungible token (value field >1)', async () => {
// Construct ERC1155 asset data
const callbackData = "0x";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(2)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.amountEqualToOneRequired,
);
});
it('should revert if sender balance is insufficient', async () => {
// Verify pre-condition
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const initialSenderBalance = initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
// Construct ERC1155 asset data
const callbackData = "0x";
const tokenIdsToTransfer = [fungibleTokenIdToTransfer];
const tokenValuesToTransfer = [initialSenderBalance.plus(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.Uint256Underflow,
);
});
it('should revert if sender allowance is insufficient', async () => {
// Unapprove ERC1155 proxy
const wrapper = erc1155ProxyWrapper.getTokenWrapper(erc1155Token.address);
const isApproved = false;
await wrapper.setApprovalForAllAsync(fromAddress, erc1155Proxy.address, isApproved);
const isApprovedActualValue = await wrapper.isApprovedForAllAsync(fromAddress, erc1155Proxy.address);
expect(isApprovedActualValue).to.be.equal(isApproved);
// Verify pre-condition
const fungibleTokenIdToTransfer = erc1155FungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const initialSenderBalance = initialHoldingsByOwner.fungible[fromAddress][erc1155Token.address][fungibleTokenIdToTransfer.toString()];
// Construct ERC1155 asset data
const callbackData = "0x";
const tokenIdsToTransfer = [fungibleTokenIdToTransfer];
const tokenValuesToTransfer = [initialSenderBalance];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
toAddress,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.InsufficientAllowance,
);
});
it('should revert if caller is not authorized', async () => {
// Construct ERC1155 asset data
const callbackData = "0x12345678";
const nonFungibleTokenIdToTransfer = erc1155NonFungibleTokenIds[0];
const initialHoldingsByOwner = await erc1155ProxyWrapper.getBalancesAsync();
const nftToTransfer = initialHoldingsByOwner.nonFungible[fromAddress][erc1155Token.address][nonFungibleTokenIdToTransfer.toString()][0];
const tokenIdsToTransfer = [nftToTransfer];
const tokenValuesToTransfer = [new BigNumber(1)];
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Token.address, tokenIdsToTransfer, tokenValuesToTransfer, callbackData);
// Perform a transfer from fromAddress to toAddress
const perUnitValue = new BigNumber(1);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
fromAddress,
erc1155Receiver.address,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: notAuthorized,
}),
RevertReason.SenderNotAuthorized,
);
});
});
});
});
// tslint:enable:no-unnecessary-type-assertion
// tslint:disable:max-file-line-count