Ran prettier
This commit is contained in:
		@@ -1,4 +1,3 @@
 | 
			
		||||
 | 
			
		||||
import {
 | 
			
		||||
    chaiSetup,
 | 
			
		||||
    constants,
 | 
			
		||||
@@ -24,7 +23,7 @@ import {
 | 
			
		||||
    //DummyERC1155TokenTransferEventArgs,
 | 
			
		||||
    InvalidERC1155ReceiverContract,
 | 
			
		||||
    ERC1155TransferSingleEventArgs,
 | 
			
		||||
    DummyERC1155ReceiverBatchTokenReceivedEventArgs
 | 
			
		||||
    DummyERC1155ReceiverBatchTokenReceivedEventArgs,
 | 
			
		||||
} from '../src';
 | 
			
		||||
 | 
			
		||||
chaiSetup.configure();
 | 
			
		||||
@@ -32,7 +31,6 @@ const expect = chai.expect;
 | 
			
		||||
const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 | 
			
		||||
// tslint:disable:no-unnecessary-type-assertion
 | 
			
		||||
describe('ERC1155Token', () => {
 | 
			
		||||
 | 
			
		||||
    const DUMMY_FUNGIBLE_TOKEN_URI = 'FUN';
 | 
			
		||||
    const DUMMY_FUNGIBLE_TOKEN_IS_FUNGIBLE = false;
 | 
			
		||||
    const DUMMY_NONFUNGIBLE_TOKEN_URI = 'NOFUN';
 | 
			
		||||
@@ -79,37 +77,24 @@ describe('ERC1155Token', () => {
 | 
			
		||||
        logDecoder = new LogDecoder(web3Wrapper, artifacts);
 | 
			
		||||
        // Create & mint fungible token
 | 
			
		||||
        let txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
 | 
			
		||||
            await token.create.sendTransactionAsync(
 | 
			
		||||
                DUMMY_FUNGIBLE_TOKEN_URI,
 | 
			
		||||
                DUMMY_FUNGIBLE_TOKEN_IS_FUNGIBLE
 | 
			
		||||
            )
 | 
			
		||||
            await token.create.sendTransactionAsync(DUMMY_FUNGIBLE_TOKEN_URI, DUMMY_FUNGIBLE_TOKEN_IS_FUNGIBLE),
 | 
			
		||||
        );
 | 
			
		||||
        const createFungibleTokenLog = txReceipt.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>;
 | 
			
		||||
        dummyFungibleTokenType = createFungibleTokenLog.args._id;
 | 
			
		||||
        await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
            await token.mintFungible.sendTransactionAsync(
 | 
			
		||||
                dummyFungibleTokenType,
 | 
			
		||||
                [spender],
 | 
			
		||||
                [spenderInitialBalance],
 | 
			
		||||
                { from: owner }
 | 
			
		||||
            ),
 | 
			
		||||
            await token.mintFungible.sendTransactionAsync(dummyFungibleTokenType, [spender], [spenderInitialBalance], {
 | 
			
		||||
                from: owner,
 | 
			
		||||
            }),
 | 
			
		||||
            constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
        );
 | 
			
		||||
        // Create & mint non-fungible token
 | 
			
		||||
        txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
 | 
			
		||||
            await token.create.sendTransactionAsync(
 | 
			
		||||
                DUMMY_NONFUNGIBLE_TOKEN_URI,
 | 
			
		||||
                DUMMY_NONFUNGIBLE_TOKEN_IS_FUNGIBLE
 | 
			
		||||
            )
 | 
			
		||||
            await token.create.sendTransactionAsync(DUMMY_NONFUNGIBLE_TOKEN_URI, DUMMY_NONFUNGIBLE_TOKEN_IS_FUNGIBLE),
 | 
			
		||||
        );
 | 
			
		||||
        const createNonFungibleTokenLog = txReceipt.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>;
 | 
			
		||||
        dummyNonFungibleTokenType = createNonFungibleTokenLog.args._id;
 | 
			
		||||
        await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
            await token.mintNonFungible.sendTransactionAsync(
 | 
			
		||||
                dummyNonFungibleTokenType,
 | 
			
		||||
                [spender],
 | 
			
		||||
                { from: owner }
 | 
			
		||||
            ),
 | 
			
		||||
            await token.mintNonFungible.sendTransactionAsync(dummyNonFungibleTokenType, [spender], { from: owner }),
 | 
			
		||||
            constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
        );
 | 
			
		||||
        dummyNft = dummyNonFungibleTokenType.plus(1);
 | 
			
		||||
@@ -134,18 +119,35 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [valueToTransfer];
 | 
			
		||||
            const callbackData = constants.NULL_BYTES;
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdx]).to.be.bignumber.equal(spenderInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdx]).to.be.bignumber.equal(receiverInitialBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
                await token.safeTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer[0], valuesToTransfer[0], callbackData, {from}),
 | 
			
		||||
                await token.safeTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer[0],
 | 
			
		||||
                    valuesToTransfer[0],
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
                constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
            );
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdx]).to.be.bignumber.equal(balancesBeforeTransfer[fromIdx].minus(valueToTransfer));
 | 
			
		||||
            expect(balancesAfterTransfer[toIdx]).to.be.bignumber.equal(balancesBeforeTransfer[toIdx].plus(valueToTransfer));
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdx]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[fromIdx].minus(valueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[toIdx]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[toIdx].plus(valueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
        it('should transfer non-fungible token if called by token owner', async () => {
 | 
			
		||||
            // setup test parameters
 | 
			
		||||
@@ -160,16 +162,29 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [valueToTransfer];
 | 
			
		||||
            const callbackData = constants.NULL_BYTES;
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdx]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdx]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
                await token.safeTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer[0], valuesToTransfer[0], callbackData, {from}),
 | 
			
		||||
                await token.safeTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer[0],
 | 
			
		||||
                    valuesToTransfer[0],
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
                constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
            );
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdx]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            expect(balancesAfterTransfer[toIdx]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
        });
 | 
			
		||||
@@ -189,14 +204,24 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer];
 | 
			
		||||
            const callbackData = '0x01020304';
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdxFungible]).to.be.bignumber.equal(spenderInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdxFungible]).to.be.bignumber.equal(receiverInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdxNonFungible]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdxNonFungible]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
 | 
			
		||||
                await token.safeTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer[0], valuesToTransfer[0], callbackData, {from})
 | 
			
		||||
                await token.safeTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer[0],
 | 
			
		||||
                    valuesToTransfer[0],
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
            );
 | 
			
		||||
            expect(txReceipt.logs.length).to.be.equal(2);
 | 
			
		||||
            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverTokenReceivedEventArgs>;
 | 
			
		||||
@@ -207,9 +232,16 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            expect(receiverLog.args.tokenValue).to.be.bignumber.equal(valuesToTransfer[0]);
 | 
			
		||||
            expect(receiverLog.args.data).to.be.deep.equal(callbackData);
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxFungible]).to.be.bignumber.equal(balancesBeforeTransfer[fromIdxFungible].minus(fungibleValueToTransfer));
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxFungible]).to.be.bignumber.equal(balancesBeforeTransfer[toIdxFungible].plus(fungibleValueToTransfer));
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxFungible]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[fromIdxFungible].minus(fungibleValueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxFungible]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[toIdxFungible].plus(fungibleValueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
    });
 | 
			
		||||
    describe('batchSafeTransferFrom', () => {
 | 
			
		||||
@@ -226,18 +258,35 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [valueToTransfer];
 | 
			
		||||
            const callbackData = constants.NULL_BYTES;
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdx]).to.be.bignumber.equal(spenderInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdx]).to.be.bignumber.equal(receiverInitialBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer, valuesToTransfer, callbackData, {from}),
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer,
 | 
			
		||||
                    valuesToTransfer,
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
                constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
            );
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdx]).to.be.bignumber.equal(balancesBeforeTransfer[fromIdx].minus(valueToTransfer));
 | 
			
		||||
            expect(balancesAfterTransfer[toIdx]).to.be.bignumber.equal(balancesBeforeTransfer[toIdx].plus(valueToTransfer));
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdx]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[fromIdx].minus(valueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[toIdx]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[toIdx].plus(valueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
        it('should transfer non-fungible token if called by token owner', async () => {
 | 
			
		||||
            // setup test parameters
 | 
			
		||||
@@ -252,16 +301,29 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [valueToTransfer];
 | 
			
		||||
            const callbackData = constants.NULL_BYTES;
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdx]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdx]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer, valuesToTransfer, callbackData, {from}),
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer,
 | 
			
		||||
                    valuesToTransfer,
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
                constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
            );
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdx]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            expect(balancesAfterTransfer[toIdx]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
        });
 | 
			
		||||
@@ -281,20 +343,37 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer];
 | 
			
		||||
            const callbackData = constants.NULL_BYTES;
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
             const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdxFungible]).to.be.bignumber.equal(spenderInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdxFungible]).to.be.bignumber.equal(receiverInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdxNonFungible]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdxNonFungible]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            await web3Wrapper.awaitTransactionSuccessAsync(
 | 
			
		||||
                 await token.safeBatchTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer, valuesToTransfer, callbackData, {from}),
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer,
 | 
			
		||||
                    valuesToTransfer,
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
                constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
            );
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
             const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
             expect(balancesAfterTransfer[fromIdxFungible]).to.be.bignumber.equal(balancesBeforeTransfer[fromIdxFungible].minus(fungibleValueToTransfer));
 | 
			
		||||
             expect(balancesAfterTransfer[toIdxFungible]).to.be.bignumber.equal(balancesBeforeTransfer[toIdxFungible].plus(fungibleValueToTransfer));
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxFungible]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[fromIdxFungible].minus(fungibleValueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxFungible]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[toIdxFungible].plus(fungibleValueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxNonFungible]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxNonFungible]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
        });
 | 
			
		||||
@@ -314,17 +393,29 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            const valuesToTransfer = [fungibleValueToTransfer, nonFungibleValueToTransfer];
 | 
			
		||||
            const callbackData = '0x01020304';
 | 
			
		||||
            // check balances before transfer
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            const balancesBeforeTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdxFungible]).to.be.bignumber.equal(spenderInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdxFungible]).to.be.bignumber.equal(receiverInitialBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[fromIdxNonFungible]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
            expect(balancesBeforeTransfer[toIdxNonFungible]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            // execute transfer
 | 
			
		||||
            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(from, to, tokenTypesToTransfer, valuesToTransfer, callbackData, {from})
 | 
			
		||||
                await token.safeBatchTransferFrom.sendTransactionAsync(
 | 
			
		||||
                    from,
 | 
			
		||||
                    to,
 | 
			
		||||
                    tokenTypesToTransfer,
 | 
			
		||||
                    valuesToTransfer,
 | 
			
		||||
                    callbackData,
 | 
			
		||||
                    { from },
 | 
			
		||||
                ),
 | 
			
		||||
            );
 | 
			
		||||
            expect(txReceipt.logs.length).to.be.equal(2);
 | 
			
		||||
            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC1155ReceiverBatchTokenReceivedEventArgs>;
 | 
			
		||||
            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<
 | 
			
		||||
                DummyERC1155ReceiverBatchTokenReceivedEventArgs
 | 
			
		||||
            >;
 | 
			
		||||
            // check callback logs
 | 
			
		||||
            expect(receiverLog.args.operator).to.be.equal(from);
 | 
			
		||||
            expect(receiverLog.args.from).to.be.equal(from);
 | 
			
		||||
@@ -336,9 +427,16 @@ describe('ERC1155Token', () => {
 | 
			
		||||
            expect(receiverLog.args.tokenValues[1]).to.be.bignumber.equal(valuesToTransfer[1]);
 | 
			
		||||
            expect(receiverLog.args.data).to.be.deep.equal(callbackData);
 | 
			
		||||
            // check balances after transfer
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(participatingOwners, participatingTokens);
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxFungible]).to.be.bignumber.equal(balancesBeforeTransfer[fromIdxFungible].minus(fungibleValueToTransfer));
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxFungible]).to.be.bignumber.equal(balancesBeforeTransfer[toIdxFungible].plus(fungibleValueToTransfer));
 | 
			
		||||
            const balancesAfterTransfer = await token.balanceOfBatch.callAsync(
 | 
			
		||||
                participatingOwners,
 | 
			
		||||
                participatingTokens,
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxFungible]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[fromIdxFungible].minus(fungibleValueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxFungible]).to.be.bignumber.equal(
 | 
			
		||||
                balancesBeforeTransfer[toIdxFungible].plus(fungibleValueToTransfer),
 | 
			
		||||
            );
 | 
			
		||||
            expect(balancesAfterTransfer[fromIdxNonFungible]).to.be.bignumber.equal(nftNotOwnerBalance);
 | 
			
		||||
            expect(balancesAfterTransfer[toIdxNonFungible]).to.be.bignumber.equal(nftOwnerBalance);
 | 
			
		||||
        });
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user