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

ran prettier

Browse Source
This commit is contained in:
Greg Hysen 2019-02-27 12:47:48 -08:00
parent 28209e9413
commit a8d58aeac4
2 changed files with 102 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
contracts/erc1155/test/erc1155_token.ts
View File

@ -31,9 +31,9 @@ describe('ERC1155Token', () => {
// constant values used in transfer tests // constant values used in transfer tests
const nftOwnerBalance = new BigNumber(1); const nftOwnerBalance = new BigNumber(1);
const nftNotOwnerBalance = new BigNumber(0); const nftNotOwnerBalance = new BigNumber(0);
const spenderInitialBalance = new BigNumber(500); const spenderInitialFungibleBalance = new BigNumber(500);
const receiverInitialBalance = new BigNumber(0); const receiverInitialFungibleBalance = new BigNumber(0);
const fungibleValueToTransfer = spenderInitialBalance.div(2); const fungibleValueToTransfer = spenderInitialFungibleBalance.div(2);
const nonFungibleValueToTransfer = nftOwnerBalance; const nonFungibleValueToTransfer = nftOwnerBalance;
const receiverCallbackData = '0x01020304'; const receiverCallbackData = '0x01020304';
// tokens & addresses // tokens & addresses
@ -71,7 +71,7 @@ describe('ERC1155Token', () => {
receiver = erc1155Receiver.address; receiver = erc1155Receiver.address;
// create wrapper & mint erc1155 tokens // create wrapper & mint erc1155 tokens
erc1155Wrapper = new Erc1155Wrapper(token, provider, owner); erc1155Wrapper = new Erc1155Wrapper(token, provider, owner);
fungibleToken = await erc1155Wrapper.mintFungibleTokenAsync(spender, spenderInitialBalance); fungibleToken = await erc1155Wrapper.mintFungibleTokenAsync(spender, spenderInitialFungibleBalance);
[, nonFungibleToken] = await erc1155Wrapper.mintNonFungibleTokenAsync(spender); [, nonFungibleToken] = await erc1155Wrapper.mintNonFungibleTokenAsync(spender);
}); });
beforeEach(async () => { beforeEach(async () => {
@ -87,15 +87,8 @@ describe('ERC1155Token', () => {
const tokenToTransfer = fungibleToken; const tokenToTransfer = fungibleToken;
const valueToTransfer = fungibleValueToTransfer; const valueToTransfer = fungibleValueToTransfer;
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
spenderInitialBalance, await erc1155Wrapper.assertBalancesAsync(tokenHolders, [tokenToTransfer], expectedInitialBalances);
receiverInitialBalance,
];
await erc1155Wrapper.assertBalancesAsync(
tokenHolders,
[tokenToTransfer],
expectedInitialBalances
);
// execute transfer // execute transfer
await erc1155Wrapper.safeTransferFromAsync( await erc1155Wrapper.safeTransferFromAsync(
spender, spender,
@ -106,14 +99,10 @@ describe('ERC1155Token', () => {
); );
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [
spenderInitialBalance.minus(valueToTransfer), spenderInitialFungibleBalance.minus(valueToTransfer),
receiverInitialBalance.plus(valueToTransfer), receiverInitialFungibleBalance.plus(valueToTransfer),
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, [tokenToTransfer], expectedFinalBalances);
tokenHolders,
[tokenToTransfer],
expectedFinalBalances
);
}); });
it('should transfer non-fungible token if called by token owner', async () => { it('should transfer non-fungible token if called by token owner', async () => {
// setup test parameters // setup test parameters
@ -121,15 +110,8 @@ describe('ERC1155Token', () => {
const tokenToTransfer = nonFungibleToken; const tokenToTransfer = nonFungibleToken;
const valueToTransfer = nonFungibleValueToTransfer; const valueToTransfer = nonFungibleValueToTransfer;
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [nftOwnerBalance, nftNotOwnerBalance];
nftOwnerBalance, await erc1155Wrapper.assertBalancesAsync(tokenHolders, [tokenToTransfer], expectedInitialBalances);
nftNotOwnerBalance
];
await erc1155Wrapper.assertBalancesAsync(
tokenHolders,
[tokenToTransfer],
expectedInitialBalances
);
// execute transfer // execute transfer
await erc1155Wrapper.safeTransferFromAsync( await erc1155Wrapper.safeTransferFromAsync(
spender, spender,
@ -139,15 +121,8 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
); );
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [nftNotOwnerBalance, nftOwnerBalance];
nftNotOwnerBalance, await erc1155Wrapper.assertBalancesAsync(tokenHolders, [tokenToTransfer], expectedFinalBalances);
nftOwnerBalance
];
await erc1155Wrapper.assertBalancesAsync(
tokenHolders,
[tokenToTransfer],
expectedFinalBalances
);
}); });
it('should trigger callback if transferring to a contract', async () => { it('should trigger callback if transferring to a contract', async () => {
// setup test parameters // setup test parameters
@ -156,16 +131,12 @@ describe('ERC1155Token', () => {
const valueToTransfer = fungibleValueToTransfer; const valueToTransfer = fungibleValueToTransfer;
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
spenderInitialBalance, spenderInitialFungibleBalance,
receiverInitialBalance, receiverInitialFungibleBalance,
nftOwnerBalance, nftOwnerBalance,
nftNotOwnerBalance nftNotOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, [tokenToTransfer], expectedInitialBalances);
tokenHolders,
[tokenToTransfer],
expectedInitialBalances
);
// execute transfer // execute transfer
const tx = await erc1155Wrapper.safeTransferFromAsync( const tx = await erc1155Wrapper.safeTransferFromAsync(
spender, spender,
@ -175,17 +146,15 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
); );
expect(tx.logs.length).to.be.equal(2); expect(tx.logs.length).to.be.equal(2);
const receiverLog = tx.logs[1] as LogWithDecodedArgs< const receiverLog = tx.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>;
DummyERC1155ReceiverBatchTokenReceivedEventArgs
>;
// check callback logs // check callback logs
const expectedCallbackLog = { const expectedCallbackLog = {
operator: spender, operator: spender,
from: spender, from: spender,
tokenId: tokenToTransfer, tokenId: tokenToTransfer,
tokenValue: valueToTransfer, tokenValue: valueToTransfer,
data: receiverCallbackData data: receiverCallbackData,
} };
expect(receiverLog.args.operator).to.be.equal(expectedCallbackLog.operator); expect(receiverLog.args.operator).to.be.equal(expectedCallbackLog.operator);
expect(receiverLog.args.from).to.be.equal(expectedCallbackLog.from); expect(receiverLog.args.from).to.be.equal(expectedCallbackLog.from);
expect(receiverLog.args.tokenId).to.be.bignumber.equal(expectedCallbackLog.tokenId); expect(receiverLog.args.tokenId).to.be.bignumber.equal(expectedCallbackLog.tokenId);
@ -193,19 +162,15 @@ describe('ERC1155Token', () => {
expect(receiverLog.args.data).to.be.deep.equal(expectedCallbackLog.data); expect(receiverLog.args.data).to.be.deep.equal(expectedCallbackLog.data);
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [
spenderInitialBalance.minus(valueToTransfer), spenderInitialFungibleBalance.minus(valueToTransfer),
receiverInitialBalance.plus(valueToTransfer), receiverInitialFungibleBalance.plus(valueToTransfer),
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, [tokenToTransfer], expectedFinalBalances);
tokenHolders,
[tokenToTransfer],
expectedFinalBalances
);
}); });
it('should throw if transfer reverts', async () => { it('should throw if transfer reverts', async () => {
// setup test parameters // setup test parameters
const tokenToTransfer = fungibleToken; const tokenToTransfer = fungibleToken;
const valueToTransfer = spenderInitialBalance.plus(1); const valueToTransfer = spenderInitialFungibleBalance.plus(1);
// execute transfer // execute transfer
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
token.safeTransferFrom.sendTransactionAsync( token.safeTransferFrom.sendTransactionAsync(
@ -216,7 +181,7 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
{ from: spender }, { from: spender },
), ),
RevertReason.Uint256Underflow RevertReason.Uint256Underflow,
); );
}); });
it('should throw if callback reverts', async () => { it('should throw if callback reverts', async () => {
@ -226,14 +191,11 @@ describe('ERC1155Token', () => {
// set receiver to reject balances // set receiver to reject balances
const shouldRejectTransfer = true; const shouldRejectTransfer = true;
await web3Wrapper.awaitTransactionSuccessAsync( await web3Wrapper.awaitTransactionSuccessAsync(
await erc1155Receiver.setRejectTransferFlag.sendTransactionAsync( await erc1155Receiver.setRejectTransferFlag.sendTransactionAsync(shouldRejectTransfer),
shouldRejectTransfer,
),
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
); );
// execute transfer // execute transfer
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
token.safeTransferFrom.sendTransactionAsync( token.safeTransferFrom.sendTransactionAsync(
spender, spender,
receiver, receiver,
@ -242,7 +204,7 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
{ from: spender }, { from: spender },
), ),
RevertReason.TransferRejected RevertReason.TransferRejected,
); );
}); });
}); });
@ -253,15 +215,8 @@ describe('ERC1155Token', () => {
const tokensToTransfer = [fungibleToken]; const tokensToTransfer = [fungibleToken];
const valuesToTransfer = [fungibleValueToTransfer]; const valuesToTransfer = [fungibleValueToTransfer];
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [spenderInitialFungibleBalance, receiverInitialFungibleBalance];
spenderInitialBalance, await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
receiverInitialBalance,
];
await erc1155Wrapper.assertBalancesAsync(
tokenHolders,
tokensToTransfer,
expectedInitialBalances
);
// execute transfer // execute transfer
await erc1155Wrapper.safeBatchTransferFromAsync( await erc1155Wrapper.safeBatchTransferFromAsync(
spender, spender,
@ -272,14 +227,10 @@ describe('ERC1155Token', () => {
); );
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [
spenderInitialBalance.minus(valuesToTransfer[0]), spenderInitialFungibleBalance.minus(valuesToTransfer[0]),
receiverInitialBalance.plus(valuesToTransfer[0]), receiverInitialFungibleBalance.plus(valuesToTransfer[0]),
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
tokenHolders,
tokensToTransfer,
expectedFinalBalances
);
}); });
it('should transfer non-fungible token if called by token owner', async () => { it('should transfer non-fungible token if called by token owner', async () => {
// setup test parameters // setup test parameters
@ -288,16 +239,12 @@ describe('ERC1155Token', () => {
const valuesToTransfer = [nonFungibleValueToTransfer]; const valuesToTransfer = [nonFungibleValueToTransfer];
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
spenderInitialBalance, spenderInitialFungibleBalance,
receiverInitialBalance, receiverInitialFungibleBalance,
nftOwnerBalance, nftOwnerBalance,
nftNotOwnerBalance nftNotOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
tokenHolders,
tokensToTransfer,
expectedInitialBalances
);
// execute transfer // execute transfer
await erc1155Wrapper.safeBatchTransferFromAsync( await erc1155Wrapper.safeBatchTransferFromAsync(
spender, spender,
@ -307,15 +254,8 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
); );
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [nftNotOwnerBalance, nftOwnerBalance];
nftNotOwnerBalance, await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
nftOwnerBalance
];
await erc1155Wrapper.assertBalancesAsync(
tokenHolders,
tokensToTransfer,
expectedFinalBalances
);
}); });
it('should transfer mix of fungible / non-fungible tokens if called by token owner', async () => { it('should transfer mix of fungible / non-fungible tokens if called by token owner', async () => {
// setup test parameters // setup test parameters
@ -324,16 +264,12 @@ describe('ERC1155Token', () => {
const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer]; const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer];
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
spenderInitialBalance, spenderInitialFungibleBalance,
receiverInitialBalance, receiverInitialFungibleBalance,
nftOwnerBalance, nftOwnerBalance,
nftNotOwnerBalance nftNotOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
tokenHolders,
tokensToTransfer,
expectedInitialBalances
);
// execute transfer // execute transfer
await erc1155Wrapper.safeBatchTransferFromAsync( await erc1155Wrapper.safeBatchTransferFromAsync(
spender, spender,
@ -344,16 +280,12 @@ describe('ERC1155Token', () => {
); );
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [
spenderInitialBalance.minus(valuesToTransfer[0]), spenderInitialFungibleBalance.minus(valuesToTransfer[0]),
receiverInitialBalance.plus(valuesToTransfer[0]), receiverInitialFungibleBalance.plus(valuesToTransfer[0]),
nftNotOwnerBalance, nftNotOwnerBalance,
nftOwnerBalance nftOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
tokenHolders,
tokensToTransfer,
expectedFinalBalances
);
}); });
it('should trigger callback if transferring to a contract', async () => { it('should trigger callback if transferring to a contract', async () => {
// setup test parameters // setup test parameters
@ -362,16 +294,12 @@ describe('ERC1155Token', () => {
const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer]; const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer];
// check balances before transfer // check balances before transfer
const expectedInitialBalances = [ const expectedInitialBalances = [
spenderInitialBalance, spenderInitialFungibleBalance,
receiverInitialBalance, receiverInitialFungibleBalance,
nftOwnerBalance, nftOwnerBalance,
nftNotOwnerBalance nftNotOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
tokenHolders,
tokensToTransfer,
expectedInitialBalances
);
// execute transfer // execute transfer
const tx = await erc1155Wrapper.safeBatchTransferFromAsync( const tx = await erc1155Wrapper.safeBatchTransferFromAsync(
spender, spender,
@ -381,17 +309,15 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
); );
expect(tx.logs.length).to.be.equal(2); expect(tx.logs.length).to.be.equal(2);
const receiverLog = tx.logs[1] as LogWithDecodedArgs< const receiverLog = tx.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>;
DummyERC1155ReceiverBatchTokenReceivedEventArgs
>;
// check callback logs // check callback logs
const expectedCallbackLog = { const expectedCallbackLog = {
operator: spender, operator: spender,
from: spender, from: spender,
tokenIds: tokensToTransfer, tokenIds: tokensToTransfer,
tokenValues: valuesToTransfer, tokenValues: valuesToTransfer,
data: receiverCallbackData data: receiverCallbackData,
} };
expect(receiverLog.args.operator).to.be.equal(expectedCallbackLog.operator); expect(receiverLog.args.operator).to.be.equal(expectedCallbackLog.operator);
expect(receiverLog.args.from).to.be.equal(expectedCallbackLog.from); expect(receiverLog.args.from).to.be.equal(expectedCallbackLog.from);
expect(receiverLog.args.tokenIds.length).to.be.equal(2); expect(receiverLog.args.tokenIds.length).to.be.equal(2);
@ -403,21 +329,17 @@ describe('ERC1155Token', () => {
expect(receiverLog.args.data).to.be.deep.equal(expectedCallbackLog.data); expect(receiverLog.args.data).to.be.deep.equal(expectedCallbackLog.data);
// check balances after transfer // check balances after transfer
const expectedFinalBalances = [ const expectedFinalBalances = [
spenderInitialBalance.minus(valuesToTransfer[0]), spenderInitialFungibleBalance.minus(valuesToTransfer[0]),
receiverInitialBalance.plus(valuesToTransfer[0]), receiverInitialFungibleBalance.plus(valuesToTransfer[0]),
nftNotOwnerBalance, nftNotOwnerBalance,
nftOwnerBalance nftOwnerBalance,
]; ];
await erc1155Wrapper.assertBalancesAsync( await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
tokenHolders,
tokensToTransfer,
expectedFinalBalances
);
}); });
it('should throw if transfer reverts', async () => { it('should throw if transfer reverts', async () => {
// setup test parameters // setup test parameters
const tokensToTransfer = [fungibleToken]; const tokensToTransfer = [fungibleToken];
const valuesToTransfer = [spenderInitialBalance.plus(1)]; const valuesToTransfer = [spenderInitialFungibleBalance.plus(1)];
// execute transfer // execute transfer
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
token.safeBatchTransferFrom.sendTransactionAsync( token.safeBatchTransferFrom.sendTransactionAsync(
@ -428,7 +350,7 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
{ from: spender }, { from: spender },
), ),
RevertReason.Uint256Underflow RevertReason.Uint256Underflow,
); );
}); });
it('should throw if callback reverts', async () => { it('should throw if callback reverts', async () => {
@ -438,14 +360,11 @@ describe('ERC1155Token', () => {
// set receiver to reject balances // set receiver to reject balances
const shouldRejectTransfer = true; const shouldRejectTransfer = true;
await web3Wrapper.awaitTransactionSuccessAsync( await web3Wrapper.awaitTransactionSuccessAsync(
await erc1155Receiver.setRejectTransferFlag.sendTransactionAsync( await erc1155Receiver.setRejectTransferFlag.sendTransactionAsync(shouldRejectTransfer),
shouldRejectTransfer,
),
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
); );
// execute transfer // execute transfer
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
token.safeBatchTransferFrom.sendTransactionAsync( token.safeBatchTransferFrom.sendTransactionAsync(
spender, spender,
receiver, receiver,
@ -454,7 +373,7 @@ describe('ERC1155Token', () => {
receiverCallbackData, receiverCallbackData,
{ from: spender }, { from: spender },
), ),
RevertReason.TransferRejected RevertReason.TransferRejected,
); );
}); });
}); });

65
contracts/erc1155/test/utils/erc1155_wrapper.ts
View File

@ -32,30 +32,31 @@ export class Erc1155Wrapper {
this._contractOwner = contractOwner; this._contractOwner = contractOwner;
this._logDecoder = new LogDecoder(this._web3Wrapper, artifacts); this._logDecoder = new LogDecoder(this._web3Wrapper, artifacts);
} }
public async getBalancesAsync( public async getBalancesAsync(owners: string[], tokens: BigNumber[]): Promise<BigNumber[]> {
owners: string[], const balances = await this._erc1155Contract.balanceOfBatch.callAsync(owners, tokens);
tokens: BigNumber[]
): Promise<BigNumber[]> {
const balances = await this._erc1155Contract.balanceOfBatch.callAsync(
owners,
tokens,
);
return balances; return balances;
} }
public async safeTransferFromAsync(from: string, to: string, token: BigNumber, value: BigNumber, callbackData: string = '0x'): Promise<TransactionReceiptWithDecodedLogs> { public async safeTransferFromAsync(
from: string,
to: string,
token: BigNumber,
value: BigNumber,
callbackData: string = '0x',
): Promise<TransactionReceiptWithDecodedLogs> {
const tx = await this._logDecoder.getTxWithDecodedLogsAsync( const tx = await this._logDecoder.getTxWithDecodedLogsAsync(
await this._erc1155Contract.safeTransferFrom.sendTransactionAsync( await this._erc1155Contract.safeTransferFrom.sendTransactionAsync(from, to, token, value, callbackData, {
from, from,
to, }),
token,
value,
callbackData,
{ from },
),
); );
return tx; return tx;
} }
public async safeBatchTransferFromAsync(from: string, to: string, tokens: BigNumber[], values: BigNumber[], callbackData: string = '0x'): Promise<TransactionReceiptWithDecodedLogs> { public async safeBatchTransferFromAsync(
from: string,
to: string,
tokens: BigNumber[],
values: BigNumber[],
callbackData: string = '0x',
): Promise<TransactionReceiptWithDecodedLogs> {
const tx = await this._logDecoder.getTxWithDecodedLogsAsync( const tx = await this._logDecoder.getTxWithDecodedLogsAsync(
await this._erc1155Contract.safeBatchTransferFrom.sendTransactionAsync( await this._erc1155Contract.safeBatchTransferFrom.sendTransactionAsync(
from, from,
@ -72,7 +73,9 @@ export class Erc1155Wrapper {
const tokenUri = 'dummyFungibleToken'; const tokenUri = 'dummyFungibleToken';
const tokenIsNonFungible = false; const tokenIsNonFungible = false;
const tx = await this._logDecoder.getTxWithDecodedLogsAsync( const tx = await this._logDecoder.getTxWithDecodedLogsAsync(
await this._erc1155Contract.create.sendTransactionAsync(tokenUri, tokenIsNonFungible, { from: this._contractOwner }) await this._erc1155Contract.create.sendTransactionAsync(tokenUri, tokenIsNonFungible, {
from: this._contractOwner,
}),
); );
const createFungibleTokenLog = tx.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>; const createFungibleTokenLog = tx.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>;
const token = createFungibleTokenLog.args._id; const token = createFungibleTokenLog.args._id;
@ -84,33 +87,39 @@ export class Erc1155Wrapper {
); );
return token; return token;
} }
public async mintNonFungibleTokenAsync(beneficiary: string): Promise<[BigNumber,BigNumber]> { public async mintNonFungibleTokenAsync(beneficiary: string): Promise<[BigNumber, BigNumber]> {
const tokenUri = 'dummyNonFungibleToken'; const tokenUri = 'dummyNonFungibleToken';
const tokenIsNonFungible = true; const tokenIsNonFungible = true;
const tx = await this._logDecoder.getTxWithDecodedLogsAsync( const tx = await this._logDecoder.getTxWithDecodedLogsAsync(
await this._erc1155Contract.create.sendTransactionAsync(tokenUri, tokenIsNonFungible, { from: this._contractOwner }) await this._erc1155Contract.create.sendTransactionAsync(tokenUri, tokenIsNonFungible, {
from: this._contractOwner,
}),
); );
const createFungibleTokenLog = tx.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>; const createFungibleTokenLog = tx.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>;
const token = createFungibleTokenLog.args._id; const token = createFungibleTokenLog.args._id;
await this._web3Wrapper.awaitTransactionSuccessAsync( await this._web3Wrapper.awaitTransactionSuccessAsync(
await this._erc1155Contract.mintNonFungible.sendTransactionAsync(token, [beneficiary], { from: this._contractOwner }), await this._erc1155Contract.mintNonFungible.sendTransactionAsync(token, [beneficiary], {
from: this._contractOwner,
}),
constants.AWAIT_TRANSACTION_MINED_MS, constants.AWAIT_TRANSACTION_MINED_MS,
); );
const nftId = token.plus(1); const nftId = token.plus(1);
return [token, nftId]; return [token, nftId];
} }
public async assertBalancesAsync(owners: string[], tokens: BigNumber[], expectedBalances: BigNumber[]): Promise<void> { public async assertBalancesAsync(
owners: string[],
tokens: BigNumber[],
expectedBalances: BigNumber[],
): Promise<void> {
const ownersExtended: string[] = []; const ownersExtended: string[] = [];
const tokensExtended: BigNumber[] = []; const tokensExtended: BigNumber[] = [];
_.each(tokens, (token: BigNumber) => { _.each(tokens, (token: BigNumber) => {
ownersExtended.concat(owners); ownersExtended.concat(owners);
_.range(0, owners.length, () => {tokensExtended.push(token)}); _.range(0, owners.length, () => {
tokensExtended.push(token);
});
}); });
const balances = await this.getBalancesAsync( const balances = await this.getBalancesAsync(ownersExtended, tokensExtended);
ownersExtended,
tokensExtended,
);
_.each(balances, (balance: BigNumber, i: number) => { _.each(balances, (balance: BigNumber, i: number) => {
expect(balance, `${ownersExtended[i]}${tokensExtended[i]}`).to.be.bignumber.equal(expectedBalances[i]); expect(balance, `${ownersExtended[i]}${tokensExtended[i]}`).to.be.bignumber.equal(expectedBalances[i]);
}); });