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/contracts-erc20": "^1.0.9",
"@0x/contracts-erc721": "^1.0.9",
"@0x/contracts-erc1155": "^1.0.0",
"@0x/contracts-utils": "2.0.1",
"@0x/order-utils": "^7.0.2",
"@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 * as _ from 'lodash';
import { Erc1155Wrapper } from '../../erc1155/lib/src';
import {
artifacts,
ERC721ProxyContract,
ERC1155ProxyWrapper,
IAssetDataContract,
IAssetProxyContract,
ERC1155MintableContract,
DummyERC1155ReceiverContract,
DummyERC1155ReceiverBatchTokenReceivedEventArgs,
DummyERC1155ReceiverContract,
ERC1155MintableContract,
ERC1155ProxyWrapper,
ERC721ProxyContract,
IAssetProxyContract,
} from '../src';
import { Erc1155Wrapper } from '../../erc1155/lib/src';
chaiSetup.configure();
const expect = chai.expect;
@ -91,7 +90,7 @@ describe.only('ERC1155Proxy', () => {
from: owner,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);;
);
// deploy & configure ERC1155 tokens and receiver
[erc1155Wrapper] = await erc1155ProxyWrapper.deployDummyTokensAsync();
erc1155Contract = erc1155Wrapper.getContract();
@ -108,7 +107,8 @@ describe.only('ERC1155Proxy', () => {
nonFungibleTokensOwnedBySpender = [];
_.each(nonFungibleTokens, (nonFungibleToken: BigNumber) => {
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);
});
});
@ -147,7 +147,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// 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(
encodedAssetData,
spender,
@ -175,7 +180,11 @@ describe.only('ERC1155Proxy', () => {
const tokenHolders = [spender, receiver];
const tokenToTransfer = fungibleTokens[0];
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;
// check balances before transfer
const expectedInitialBalances = [
@ -190,7 +199,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -207,7 +216,9 @@ describe.only('ERC1155Proxy', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
// 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);
const expectedFinalBalances = [
// spender
@ -221,7 +232,11 @@ describe.only('ERC1155Proxy', () => {
// setup test parameters
const tokenHolders = [spender, receiver];
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;
// check balances before transfer
const expectedInitialBalances = [
@ -240,7 +255,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -257,7 +272,9 @@ describe.only('ERC1155Proxy', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
// 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 = [
// spender
spenderInitialFungibleBalance.minus(totalValuesTransferred[0]),
@ -289,7 +306,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -318,7 +335,11 @@ describe.only('ERC1155Proxy', () => {
// setup test parameters
const tokenHolders = [spender, receiver];
const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 3);
const valuesToTransfer = [nonFungibleValueToTransfer, nonFungibleValueToTransfer, nonFungibleValueToTransfer];
const valuesToTransfer = [
nonFungibleValueToTransfer,
nonFungibleValueToTransfer,
nonFungibleValueToTransfer,
];
const perUnitValue = perUnitValueNft;
// check balances before transfer
const expectedInitialBalances = [
@ -337,7 +358,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -401,7 +422,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -418,7 +439,9 @@ describe.only('ERC1155Proxy', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
// 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 = [
// spender
expectedInitialBalances[0].minus(totalValuesTransferred[0]),
@ -441,12 +464,19 @@ describe.only('ERC1155Proxy', () => {
const tokensToTransfer = fungibleTokens.slice(0, 1);
const valuesToTransfer = [fungibleValueToTransferLarge];
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
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// 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(
encodedAssetData,
spender,
@ -459,11 +489,13 @@ describe.only('ERC1155Proxy', () => {
to: erc1155Proxy.address,
data,
from: authorized,
})
}),
);
// check receiver log ignored extra asset data
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.from).to.be.equal(spender);
expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1);
@ -485,12 +517,19 @@ describe.only('ERC1155Proxy', () => {
const tokensToTransfer = fungibleTokens.slice(0, 1);
const valuesToTransfer = [fungibleValueToTransferLarge];
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
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(erc1155Contract.address, tokensToTransfer, valuesToTransfer, receiverCallbackData);
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const extraData = '0102030405060708';
const encodedAssetDataPlusExtraData = `${encodedAssetData}${extraData}`;
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@ -505,11 +544,13 @@ describe.only('ERC1155Proxy', () => {
to: erc1155Proxy.address,
data,
from: authorized,
})
}),
);
// check receiver log ignored extra asset data
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.from).to.be.equal(spender);
expect(receiverLog.args.tokenIds.length).to.be.deep.equal(1);
@ -541,14 +582,19 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverContractInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// 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(
encodedAssetData,
spender,
receiverContract,
perUnitValue,
);
return await expectTransactionFailedAsync(
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
@ -579,7 +625,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -619,7 +665,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -640,7 +686,7 @@ describe.only('ERC1155Proxy', () => {
// setup test parameters
const tokenHolders = [spender, receiver];
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 perUnitValue = new BigNumber(2);
// check balances before transfer
@ -661,7 +707,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -679,32 +725,32 @@ describe.only('ERC1155Proxy', () => {
);
});
it('should revert if transferring > 1 instances of a non-fungible token (perUnitValue field >1)', async () => {
// setup test parameters
const tokenHolders = [spender, receiver];
const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 1);
const valuesToTransfer = [nonFungibleValueToTransfer];
const perUnitValue = new BigNumber(2);
// check balances before transfer
const expectedInitialBalances = [
// spender
nftOwnerBalance,
// receiver
nftNotOwnerBalance,
];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
spender,
receiver,
perUnitValue,
);
// setup test parameters
const tokenHolders = [spender, receiver];
const tokensToTransfer = nonFungibleTokensOwnedBySpender.slice(0, 1);
const valuesToTransfer = [nonFungibleValueToTransfer];
const perUnitValue = new BigNumber(2);
// check balances before transfer
const expectedInitialBalances = [
// spender
nftOwnerBalance,
// receiver
nftNotOwnerBalance,
];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// execute transfer
const encodedAssetData = assetDataUtils.encodeERC1155AssetData(
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
spender,
receiver,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
@ -733,7 +779,7 @@ describe.only('ERC1155Proxy', () => {
erc1155Contract.address,
tokensToTransfer,
valuesToTransfer,
receiverCallbackData
receiverCallbackData,
);
const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
encodedAssetData,
@ -741,14 +787,14 @@ describe.only('ERC1155Proxy', () => {
receiver,
perUnitValue,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.amountEqualToOneRequired,
);
await expectTransactionFailedAsync(
web3Wrapper.sendTransactionAsync({
to: erc1155Proxy.address,
data,
from: authorized,
}),
RevertReason.amountEqualToOneRequired,
);
});
it('should revert if sender balance is insufficient', async () => {
// setup test parameters
@ -761,7 +807,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// 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(
encodedAssetData,
spender,
@ -793,7 +844,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// 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(
encodedAssetData,
spender,
@ -819,7 +875,12 @@ describe.only('ERC1155Proxy', () => {
const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
// 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(
encodedAssetData,
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 { generatePseudoRandomSalt } from '@0x/order-utils';
import { Erc1155Wrapper } from '@0x/contracts-erc1155';
import {
constants,
ERC1155FungibleHoldingsByOwner,
ERC1155HoldingsByOwner,
ERC1155NonFungibleHoldingsByOwner,
LogDecoder,
txDefaults,
} from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils';
import { Web3Wrapper } from '@0x/web3-wrapper';
import { Provider } from 'ethereum-types';
import * as _ from 'lodash';
import { Erc1155Wrapper } from '@0x/contracts-erc1155';
import { LogWithDecodedArgs } from 'ethereum-types';
import { artifacts, ERC1155MintableContract, ERC1155ProxyContract, ERC1155MintableTransferSingleEventArgs } from '../../src';
import {
artifacts,
ERC1155MintableContract,
ERC1155ProxyContract,
} from '../../src';
export class ERC1155ProxyWrapper {
private readonly _tokenOwnerAddresses: string[];
private readonly _fungibleTokenIds: 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 _web3Wrapper: Web3Wrapper;
private readonly _provider: Provider;
@ -24,7 +30,7 @@ export class ERC1155ProxyWrapper {
private readonly _dummyTokenWrappers: Erc1155Wrapper[];
private _proxyContract?: ERC1155ProxyContract;
private _proxyIdIfExists?: string;
private _initialTokenIdsByOwner: ERC1155HoldingsByOwner = {fungible: {}, nonFungible: {}};
private _initialTokenIdsByOwner: ERC1155HoldingsByOwner = { fungible: {}, nonFungible: {} };
constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
this._web3Wrapper = new Web3Wrapper(provider);
this._provider = provider;
@ -44,7 +50,6 @@ export class ERC1155ProxyWrapper {
this._provider,
txDefaults,
);
console.log(erc1155Contract.address);
const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress);
this._dummyTokenWrappers.push(erc1155Wrapper);
}
@ -67,17 +72,22 @@ export class ERC1155ProxyWrapper {
this._validateDummyTokenContractsExistOrThrow();
this._validateProxyContractExistsOrThrow();
this._initialTokenIdsByOwner = {
fungible: {} as ERC1155FungibleHoldingsByOwner,
nonFungible: {}
fungible: {},
nonFungible: {},
};
const fungibleHoldingsByOwner: ERC1155FungibleHoldingsByOwner = {};
const fungibleHoldingsByOwner: ERC1155FungibleHoldingsByOwner = {};
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) {
const dummyAddress = dummyWrapper.getContract().address;
for (const i of _.times(constants.NUM_ERC1155_FUNGIBLE_TOKENS_MINT)) {
_.each(fungibleTokensToMintRange, async () => {
// 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();
this._fungibleTokenIds.push(tokenIdAsString);
// Mint tokens for each owner for this token
@ -89,35 +99,44 @@ export class ERC1155ProxyWrapper {
if (_.isUndefined(fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) {
fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {};
}
fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] = constants.INITIAL_ERC1155_FUNGIBLE_BALANCE;
await dummyWrapper.setApprovalForAllAsync(tokenOwnerAddress, (this._proxyContract as ERC1155ProxyContract).address, true);
fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] =
constants.INITIAL_ERC1155_FUNGIBLE_BALANCE;
await dummyWrapper.setApprovalForAllAsync(
tokenOwnerAddress,
(this._proxyContract as ERC1155ProxyContract).address,
true,
);
}
}
// Non-Fungible Tokens
for (const i of _.times(constants.NUM_ERC1155_NONFUNGIBLE_TOKENS_MINT)) {
});
// Non-fungible tokens
_.each(nonFungibleTokensToMintRange, async () => {
const [tokenId, nftIds] = await dummyWrapper.mintNonFungibleTokensAsync(this._tokenOwnerAddresses);
const tokenIdAsString = tokenId.toString();
this._nonFungibleTokenIds.push(tokenIdAsString);
_.each(this._tokenOwnerAddresses, async (tokenOwnerAddress: string, i: number) => {
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress])) {
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress] = {};
}
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) {
}
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {};
}
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString])) {
}
if (_.isUndefined(nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString])) {
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] = [];
}
this._nfts.push({id: nftIds[i], tokenId});
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString].push(nftIds[i]);
await dummyWrapper.setApprovalForAllAsync(tokenOwnerAddress, (this._proxyContract as ERC1155ProxyContract).address, true);
}
this._nfts.push({ id: nftIds[i], tokenId });
nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString].push(nftIds[i]);
await dummyWrapper.setApprovalForAllAsync(
tokenOwnerAddress,
(this._proxyContract as ERC1155ProxyContract).address,
true,
);
});
}
});
}
this._initialTokenIdsByOwner = {
fungible: fungibleHoldingsByOwner,
nonFungible: nonFungibleHoldingsByOwner,
}
};
return this._initialTokenIdsByOwner;
}
public async ownerOfNonFungibleAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> {
@ -125,7 +144,11 @@ export class ERC1155ProxyWrapper {
const owner = await tokenContract.ownerOf.callAsync(tokenId);
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 tokenOwner = await tokenContract.ownerOf.callAsync(tokenId);
const isOwner = tokenOwner === userAddress;
@ -181,12 +204,18 @@ export class ERC1155ProxyWrapper {
if (_.isUndefined(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()] = [];
}
const isOwner = balances[i++];
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 = {
fungible: tokenHoldingsByOwner,
nonFungible: nonFungibleHoldingsByOwner,
}
};
return holdingsByOwner;
}
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;
}
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;
}
public getTokenOwnerAddresses(): string[] {
return this._tokenOwnerAddresses;
}
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)) {
throw new Error(`Token: ${tokenAddress} was not deployed through ERC1155Wrapper`);
}
@ -239,7 +274,10 @@ export class ERC1155ProxyWrapper {
}
}
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(
'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 {
[ownerAddress: string]: {
[tokenAddress: string]: {
[tokenId: string]: BigNumber
}
[tokenId: string]: BigNumber;
};
};
}
export interface ERC1155NonFungibleHoldingsByOwner {
[ownerAddress: string]: {
[tokenAddress: string]: {
[tokenId: string]: BigNumber[]
}
[tokenId: string]: BigNumber[];
};
};
}
export interface ERC1155HoldingsByOwner {
fungible: ERC1155FungibleHoldingsByOwner,
nonFungible: ERC1155NonFungibleHoldingsByOwner,
fungible: ERC1155FungibleHoldingsByOwner;
nonFungible: ERC1155NonFungibleHoldingsByOwner;
}
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
*/
encodeERC1155AssetData(tokenAddress: string, tokenIds: BigNumber[], tokenValues: BigNumber[], callbackData: string): string {
const abiEncoder = AbiEncoder.createMethod('ERC1155Token', ['address','uint256[]','uint256[]','bytes']);
encodeERC1155AssetData(
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 assetData = abiEncoder.encode(args, encodingRules);
return assetData;
@ -186,7 +191,7 @@ export const assetDataUtils = {
if (
assetProxyId !== AssetProxyId.ERC20 &&
assetProxyId !== AssetProxyId.ERC721 &&
assetProxyId !== AssetProxyId.ERC1155 &&
assetProxyId !== AssetProxyId.ERC1155 &&
assetProxyId !== AssetProxyId.MultiAsset
) {
throw new Error(`Invalid assetProxyId: ${assetProxyId}`);