How to detect emit in a receiving contract using hardhat?

Question

I'm trying to replicate expectEvent.inTransaction() from @openzeppelin/test-helpers for hardhat.

The scenario: token is transfering from owner to receiverContract. I want to check that receiverContract emitted a Received event.

The transaction looks like this and is initiated by the owner.

const tx = await token.transferFrom(
  owner.address, // <- From this wallet
  receiverContract.address, // <- To this contract
  tokenId,
  {
    from: owner.address,
  }
);

This test works showing the token emitted a Transfer event.

await expect(tx)
  .to.emit(this.token, "Transfer")
  .withArgs(owner.address, receiverContract.address, tokenId);

But I want to write something like this...

await expect(tx) // <- Not sure what to put here
  .to.emit(receiverContract, "Received") // <- This may also be off
  .withArgs(token, owner.address, tokenId, null);

Or alternatively, I can look through the receiver's receipt object but I'm not sure how to get that either... normally it's via...

const tx = await token.transferFrom(owner.address, receiverContract.address, tokenId, {from: owner.address});
const receipt = await tx.wait();
console.log("receipt", receipt); // <- This will show an events array 
// which I can check. But how do I get this same receipt object for
// the receiverContract

Answer 1

This might be late but it could help someone else.

A contract cannot emit an event on behalf of an other contract. This means that your receiverContract is the one that needs to emit this 'Received' event.

If you are the deployer of receiverContract you can achieve this. (Since you have a 'tokenId' in the transferFrom() function I imagine this token contract is ERC721 or similar) In order to accomplish that, you would need to have an onERC721received() function in receiverContract contract like :

function onERC721received(address, address _from, uint256 _tokenID) public returns (bytes4) {
    emit Received(msg.sender, _sender, _tokenID) 
    //msg.sender will be the contract that made the transfer call.
    return this.onERC721Received.selector;
}

N.B: if the receiverContract is also an ERC721 contract you would need to have the override keyword in there.

The token contract will then need to call this function selector before the transfer is done. ERC721 contracts based on OpenZeppelin templates include this call in the _checkOnERC721Received() check only for safeTransferFrom() and not in transferFrom() function. If you are implement your own contract, you would need to call the onERC721received selector in a function like _beforeTokenTransfer() that is called before any transfer.

Finally, you should be carefull with calls to other contracts and read more about Reentrancy attacks, and also be aware that anybody could call the onERC721Received function without a real transfer.