Lesson 9: [FAIL. Reason: expected an emit, but no logs were emitted afterwards. you might have mismatched events or not enough events were emitted] #1982

Ifra001 · 2024-07-10T12:20:38Z

Ifra001
Jul 10, 2024

This is the error I am receiving:

[FAIL. Reason: expected an emit, but no logs were emitted afterwards. you might have mismatched events or not enough events were emitted] testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() (gas: 367949)
Logs:
  Creating Subscription on ChainId:  31337
  Your Subscription ID is: 1
  Your Subscription ID is: 1
  On ChainId:  31337
  Using VRFCoordinator 0x90193C961A926261B756D1E5bb255e67ff9498A1
  Using VRFCoordinator 0x90193C961A926261B756D1E5bb255e67ff9498A1
  Your Subscription ID is: 1
  Using Lottery Contract Address: 0x50EEf481cae4250d252Ae577A09bF514f224C6C4

Traces:
  [294360] LotteryTest::testFulfillRandomWordsPicksWinnerResetsAndSendsMoney()
    ├─ [0] VM::prank(PLAYER: [0x915f794B36Fd328D362445e3BD66ae4f3A894389])
    │   └─ ← [Return] 
    ├─ [47803] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: PLAYER: [0x915f794B36Fd328D362445e3BD66ae4f3A894389])
    │   └─ ← [Stop] 
    ├─ [0] VM::warp(102)
    │   └─ ← [Return] 
    ├─ [0] VM::roll(2)
    │   └─ ← [Return] 
    ├─ [2369] Lottery::getLastTimeStamp() [staticcall]
    │   └─ ← [Return] 1
    ├─ [0] VM::deal(0x0000000000000000000000000000000000000001, 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(0x0000000000000000000000000000000000000001)
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: 0x0000000000000000000000000000000000000001)
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(0x0000000000000000000000000000000000000002, 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(0x0000000000000000000000000000000000000002)
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: 0x0000000000000000000000000000000000000002)
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(0x0000000000000000000000000000000000000003, 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(0x0000000000000000000000000000000000000003)
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: 0x0000000000000000000000000000000000000003)
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(0x0000000000000000000000000000000000000004, 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(0x0000000000000000000000000000000000000004)
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: 0x0000000000000000000000000000000000000004)
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(0x0000000000000000000000000000000000000005, 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(0x0000000000000000000000000000000000000005)
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: 0x0000000000000000000000000000000000000005)
    │   └─ ← [Stop] 
    ├─ [0] VM::recordLogs()
    │   └─ ← [Return] 
    ├─ [71354] Lottery::performUpkeep(0x)
    │   ├─ [45844] VRFCoordinatorV2Mock::requestRandomWords(0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 1, 3, 500000 [5e5], 1)
    │   │   ├─ emit RandomWordsRequested(keyHash: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, requestId: 1, preSeed: 100, subId: 1, minimumRequestConfirmations: 3, callbackGasLimit: 500000 [5e5], numWords: 1, sender: Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   │   └─ ← [Return] 1
    │   ├─ emit WinnerRequested(request_Id: 1)
    │   └─ ← [Stop] 
    ├─ [0] VM::getRecordedLogs()
    │   └─ ← [Return] [([0x63373d1c4696214b898952999c9aaec57dac1ee2723cec59bea6888f489a9772, 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 0x0000000000000000000000000000000000000000000000000000000000000001, 0x00000000000000000000000050eef481cae4250d252ae577a09bf514f224c6c4], 0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000007a1200000000000000000000000000000000000000000000000000000000000000001, 0x90193C961A926261B756D1E5bb255e67ff9498A1), ([0x4c01f12e9bd0974ebab4e7627b9d3455845461e6259a0c7a436d77a2249d8fc7, 0x0000000000000000000000000000000000000000000000000000000000000001], 0x, 0x50EEf481cae4250d252Ae577A09bF514f224C6C4)]
    ├─ [43746] VRFCoordinatorV2Mock::fulfillRandomWords(1, Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   ├─ [14151] Lottery::rawFulfillRandomWords(1, [78541660797044910968829902406342334108369226379826116161446442989268089806461 [7.854e76]])
    │   │   ├─ emit WinnerPicked(winner: 0x0000000000000000000000000000000000000005)
    │   │   ├─ [200] 0x0000000000000000000000000000000000000005::fallback{value: 6000000000000000000}()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Stop] 
    │   ├─ emit RandomWordsFulfilled(requestId: 1, outputSeed: 1, payment: 13132593381597356595607044096 [1.313e28], success: true)
    │   └─ ← [Stop] 
    ├─ [0] VM::expectEmit(true, false, false, false, Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   └─ ← [Return] 
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000005
    ├─ emit WinnerPicked(winner: 0x0000000000000000000000000000000000000005)
    ├─ [350] Lottery::getLotteryState() [staticcall]
    │   └─ ← [Return] 0
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000005
    ├─ [325] Lottery::getPlayerLength() [staticcall]
    │   └─ ← [Return] 0
    ├─ [369] Lottery::getLastTimeStamp() [staticcall]
    │   └─ ← [Return] 102
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000005
    └─ ← [Stop] 

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 14.77ms (886.30µs CPU time)

Ran 1 test suite in 2.47s (14.77ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/LotteryTest.t.sol:LotteryTest
[FAIL. Reason: expected an emit, but no logs were emitted afterwards. you might have mismatched events or not enough events were emitted] testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() (gas: 367949)

This is the code of my test (My contract name is Lottery instead Raffle)

    function testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() public RaffleEnteredAndTimePassed() {
        //Arrange
        uint256 startingIndex = 1;
        uint256 Entrants = 5;
        uint256 recentTimeStamp = lottery.getLastTimeStamp();

        for(uint256 i = startingIndex; i < startingIndex + Entrants; i++) {
            address player = address(uint160(i));
            hoax(player, STARTING_BALANCE);
            lottery.enterLottery{value: ENTERANCE_FEE}();
        }


        uint256 prize = ENTERANCE_FEE * (Entrants + 1);

        vm.recordLogs();
        lottery.performUpkeep("");
        Vm.Log[] memory entries = vm.getRecordedLogs();
        bytes32 requestId = entries[1].topics[1];

        //Act
        VRFCoordinatorV2Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(lottery));
        vm.expectEmit(true,false,false,false,address(lottery));
        emit WinnerPicked(lottery.getRecentWinner());
        

        //Assert
        assert(uint256(lottery.getLotteryState()) == 0);
        assert(lottery.getRecentWinner() != address(0));
        assert(lottery.getPlayerLength() == 0);
        assert(recentTimeStamp < lottery.getLastTimeStamp());
        assert(lottery.getRecentWinner().balance == STARTING_BALANCE + prize - ENTERANCE_FEE);
        assert(uint256(requestId) > 0);

    }

The error specifically comes from this piece of the code(I am pretty sure):

        vm.expectEmit(true,false,false,false,address(lottery));
        emit WinnerPicked(lottery.getRecentWinner());

Answered by EngrPips

Jul 12, 2024

function testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() public RaffleEnteredAndTimePassed() {
        //Arrange
        uint256 startingIndex = 1;
        uint256 Entrants = 5;
        uint256 recentTimeStamp = lottery.getLastTimeStamp();

        for(uint256 i = startingIndex; i < startingIndex + Entrants; i++) {
            address player = address(uint160(i));
            hoax(player, STARTING_BALANCE);
            lottery.enterLottery{value: ENTERANCE_FEE}();
        }


        uint256 prize = ENTERANCE_FEE * (Entrants + 1);

        vm.recordLogs();
        lottery.performUpkeep("");
        Vm.Log[] memory entries = vm.getRecordedLogs();
        bytes32 requestId = entries[1].

View full answer

Chinwuba22 · 2024-07-10T12:58:00Z

Chinwuba22
Jul 10, 2024

This might be because you did not emit an event in the main contract.

0 replies

EngrPips · 2024-07-10T13:21:46Z

EngrPips
Jul 10, 2024

Hello @Chinwuba22, actually, they did emit that event in their contract. You will see that if you look at the below stack trace. There were two emit of the WinnerPicked event, one from the Raffle contract and one from the test contract.

─ [43746] VRFCoordinatorV2Mock::fulfillRandomWords(1, Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   ├─ [14151] Lottery::rawFulfillRandomWords(1, [78541660797044910968829902406342334108369226379826116161446442989268089806461 [7.854e76]])
    │   │   ├─ emit WinnerPicked(winner: 0x0000000000000000000000000000000000000005)
    │   │   ├─ [200] 0x0000000000000000000000000000000000000005::fallback{value: 6000000000000000000}()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Stop] 
    │   ├─ emit RandomWordsFulfilled(requestId: 1, outputSeed: 1, payment: 13132593381597356595607044096 [1.313e28], success: true)
    │   └─ ← [Stop] 
    ├─ [0] VM::expectEmit(true, false, false, false, Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   └─ ← [Return] 
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000005
    ├─ emit WinnerPicked(winner: 0x0000000000000000000000000000000000000005)

3 replies

Chinwuba22 Jul 11, 2024

ohhh. Thanks for the clarity.
@dontmind-me have you been able to solve this?

Ifra001 Jul 12, 2024
Author

I haven't yet, I'll just move on with the course and hopefully eventually someone will solve it

EngrPips Jul 12, 2024

Yeah, move on, sometimes somethings will only make more sense later in your journey, but if I find out what happened, I will indeed communicate here

EngrPips · 2024-07-10T13:23:34Z

EngrPips
Jul 10, 2024

I will test the expectEmit cheat-code on my end and see if I run into the same error

0 replies

EngrPips · 2024-07-12T11:43:23Z

EngrPips
Jul 12, 2024

testFulfillRandomWordsPicksWinnerResetsAndSendsMoney

@dontmind-me I figured this out. I will come up with an explanation and solution in a bit.

2 replies

Ifra001 Jul 12, 2024
Author

Yay! Thank you so much for dedicating your time to this issue!

EngrPips Jul 12, 2024

function testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() public RaffleEnteredAndTimePassed() {
        //Arrange
        uint256 startingIndex = 1;
        uint256 Entrants = 5;
        uint256 recentTimeStamp = lottery.getLastTimeStamp();

        for(uint256 i = startingIndex; i < startingIndex + Entrants; i++) {
            address player = address(uint160(i));
            hoax(player, STARTING_BALANCE);
            lottery.enterLottery{value: ENTERANCE_FEE}();
        }


        uint256 prize = ENTERANCE_FEE * (Entrants + 1);

        vm.recordLogs();
        lottery.performUpkeep("");
        Vm.Log[] memory entries = vm.getRecordedLogs();
        bytes32 requestId = entries[1].topics[1];

        //Act
        VRFCoordinatorV2Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(lottery));
        vm.expectEmit(true,false,false,false,address(lottery));
        emit WinnerPicked(lottery.getRecentWinner());
        

        //Assert
        assert(uint256(lottery.getLotteryState()) == 0);
        assert(lottery.getRecentWinner() != address(0));
        assert(lottery.getPlayerLength() == 0);
        assert(recentTimeStamp < lottery.getLastTimeStamp());
        assert(lottery.getRecentWinner().balance == STARTING_BALANCE + prize - ENTERANCE_FEE);
        assert(uint256(requestId) > 0);

    }

I haven't read how exactly the vm.expectEmit() works in foundry. But how I assume it works is immediately after you instruct the vm to expect an emit by using vm.expectEmit(), you need to emit the event you instructed the vm to expect. The vm holds that emit and awaits the actual emit that will come from a call to your contract. Once the vm gets another emit from your contract, it will compare if the emits are the same. If they are the same, then your test passes.

Let's look at the below code to understand what you did wrong in your test

 vm.recordLogs();
        lottery.performUpkeep("");
        Vm.Log[] memory entries = vm.getRecordedLogs();
        bytes32 requestId = entries[1].topics[1];

        //Act
        VRFCoordinatorV2Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(lottery));
        vm.expectEmit(true,false,false,false,address(lottery));
        emit WinnerPicked(lottery.getRecentWinner());

So, in the code above, you reversed the process by firstly calling your contract and then using vm.expectEmit(). This makes so your contract had emitted an event long ago, then you called vm.expectEmit(), which is now expecting two emits, but you only emitted one till the process end so vm.expectEmit() didn't get a second emit to do comparison and ensure that the event emitted was correct hence it reverts with FAIL. Reason: expected an emit, but no logs were emitted afterwards. you might have mismatched events or not enough events were emitted] testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() (gas: 367949) Logs:

Honestly, I understand the reason behind first calling your contract before using vm.expectEmit(). but if I am correct about the analysis of how vm.expectRevert() works, then you can't call your contract first before you use vm.expectEmit() you need to use vm.expectEmit(), emit a local event in your test then call your contract to emit the actual event, That way vm.expectEmit() will be able to compare the two events emitted and let us know if the events are correct. So to do this, I needed to hardcode the winner of the Lottery since every time we call the VRFCoordinatorV2Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(lottery)); it is always the same address that wins because the state of our game is always the same every time we run the test. Hardcoding the winner address makes it so that I was able to follow the proper flow of using vm.expectEmit() by firstly emitting our test local event and passing in the address of the hardcoded winner to the event and then call our Raffle contract which picks a winner and also emitted it's event and on comparison, the events matched so the test passed. Below is the re-structure I did for the test and the result of the test when I ran it.
RESTRUCTURED TEST

function testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() public RaffleEnteredAndTimePassed() {
        //Arrange
        uint256 startingIndex = 1;
        uint256 Entrants = 5;
        uint256 recentTimeStamp = lottery.getLastTimeStamp();

        for(uint256 i = startingIndex; i < startingIndex + Entrants; i++) {
            address player = address(uint160(i));
            hoax(player, STARTING_BALANCE);
            lottery.enterLottery{value: ENTERANCE_FEE}();
        }

        uint256 prize = ENTERANCE_FEE * (Entrants + 1);

        vm.recordLogs();
        lottery.performUpkeep("");
        Vm.Log[] memory entries = vm.getRecordedLogs();
        bytes32 requestId = entries[1].topics[1];

        //Act
        vm.expectEmit(true,false,false,false,address(lottery));
        emit WinnerPicked(WINNER);
        VRFCoordinatorV2Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(lottery));
        address recentWinner = lottery.getRecentWinner();
        console.log("The winner address is: ", recentWinner);
        //Assert
        // assert(uint256(lottery.getLotteryState()) == 0);
        // assert(lottery.getRecentWinner() != address(0));
        // assert(lottery.getPlayerLength() == 0);
        // assert(recentTimeStamp < lottery.getLastTimeStamp());
        console.log(lottery.getRecentWinner().balance);
        console.log(STARTING_BALANCE + prize - ENTERANCE_FEE);
        assert(lottery.getRecentWinner().balance == STARTING_BALANCE + prize - ENTERANCE_FEE);

    }

TEST OUTPUT

Ran 1 test for test/unit/LotteryTest.t.sol:LotteryTest
[PASS] testFulfillRandomWordsPicksWinnerResetsAndSendsMoney() (gas: 291437)
Logs:
  Creating Subscription on ChainId:  31337
  Your Subscription ID is: 1
  Your Subscription ID is: 1
  On ChainId:  31337
  Using VRFCoordinator 0x90193C961A926261B756D1E5bb255e67ff9498A1
  Using VRFCoordinator 0x90193C961A926261B756D1E5bb255e67ff9498A1
  Your Subscription ID is: 1
  Using Lottery Contract Address: 0x50EEf481cae4250d252Ae577A09bF514f224C6C4
  The winner address is:  0x0000000000000000000000000000000000000005
  15000000000000000000
  15000000000000000000

Traces:
  [295650] LotteryTest::testFulfillRandomWordsPicksWinnerResetsAndSendsMoney()
    ├─ [0] VM::prank(PLAYER: [0x915f794B36Fd328D362445e3BD66ae4f3A894389])
    │   └─ ← [Return] 
    ├─ [47803] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: PLAYER: [0x915f794B36Fd328D362445e3BD66ae4f3A894389])
    │   └─ ← [Stop] 
    ├─ [0] VM::warp(102)
    │   └─ ← [Return] 
    ├─ [0] VM::roll(2)
    │   └─ ← [Return] 
    ├─ [2369] Lottery::getLastTimeStamp() [staticcall]
    │   └─ ← [Return] 1
    ├─ [0] VM::deal(ECRecover: [0x0000000000000000000000000000000000000001], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ECRecover: [0x0000000000000000000000000000000000000001])
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: ECRecover: [0x0000000000000000000000000000000000000001])
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(SHA-256: [0x0000000000000000000000000000000000000002], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(SHA-256: [0x0000000000000000000000000000000000000002])
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: SHA-256: [0x0000000000000000000000000000000000000002])
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(RIPEMD-160: [0x0000000000000000000000000000000000000003], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(RIPEMD-160: [0x0000000000000000000000000000000000000003])
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: RIPEMD-160: [0x0000000000000000000000000000000000000003])
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(Identity: [0x0000000000000000000000000000000000000004], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(Identity: [0x0000000000000000000000000000000000000004])
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: Identity: [0x0000000000000000000000000000000000000004])
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(ModExp: [0x0000000000000000000000000000000000000005], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ModExp: [0x0000000000000000000000000000000000000005])
    │   └─ ← [Return] 
    ├─ [23903] Lottery::enterLottery{value: 1000000000000000000}()
    │   ├─ emit EnteredLottery(player: ModExp: [0x0000000000000000000000000000000000000005])
    │   └─ ← [Stop] 
    ├─ [0] VM::recordLogs()
    │   └─ ← [Return] 
    ├─ [71370] Lottery::performUpkeep(0x)
    │   ├─ [45844] VRFCoordinatorV2Mock::requestRandomWords(0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 1, 3, 500000 [5e5], 1)
    │   │   ├─ emit RandomWordsRequested(keyHash: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, requestId: 1, preSeed: 100, subId: 1, minimumRequestConfirmations: 3, callbackGasLimit: 500000 [5e5], numWords: 1, sender: Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   │   └─ ← [Return] 1
    │   ├─ emit WinnerRequested(request_Id: 1)
    │   └─ ← [Stop] 
    ├─ [0] VM::getRecordedLogs()
    │   └─ ← [Return] [([0x63373d1c4696214b898952999c9aaec57dac1ee2723cec59bea6888f489a9772, 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 0x0000000000000000000000000000000000000000000000000000000000000001, 0x00000000000000000000000050eef481cae4250d252ae577a09bf514f224c6c4], 0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000007a1200000000000000000000000000000000000000000000000000000000000000001, 0x90193C961A926261B756D1E5bb255e67ff9498A1), ([0x4c01f12e9bd0974ebab4e7627b9d3455845461e6259a0c7a436d77a2249d8fc7, 0x0000000000000000000000000000000000000000000000000000000000000001], 0x, 0x50EEf481cae4250d252Ae577A09bF514f224C6C4)]
    ├─ [0] VM::expectEmit(true, false, false, false, Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   └─ ← [Return] 
    ├─ emit WinnerPicked(winner: ModExp: [0x0000000000000000000000000000000000000005])
    ├─ [43772] VRFCoordinatorV2Mock::fulfillRandomWords(1, Lottery: [0x50EEf481cae4250d252Ae577A09bF514f224C6C4])
    │   ├─ [14153] Lottery::rawFulfillRandomWords(1, [78541660797044910968829902406342334108369226379826116161446442989268089806461 [7.854e76]])
    │   │   ├─ emit WinnerPicked(winner: ModExp: [0x0000000000000000000000000000000000000005])
    │   │   ├─ [200] ModExp::fallback{value: 6000000000000000000}()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Stop] 
    │   ├─ emit RandomWordsFulfilled(requestId: 1, outputSeed: 1, payment: 34132593381348356595607044096 [3.413e28], success: true)
    │   └─ ← [Stop] 
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] ModExp: [0x0000000000000000000000000000000000000005]
    ├─ [0] console::log("The winner address is: ", ModExp: [0x0000000000000000000000000000000000000005]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] ModExp: [0x0000000000000000000000000000000000000005]
    ├─ [0] console::log(15000000000000000000 [1.5e19]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log(15000000000000000000 [1.5e19]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [420] Lottery::getRecentWinner() [staticcall]
    │   └─ ← [Return] ModExp: [0x0000000000000000000000000000000000000005]
    └─ ← [Stop] 

Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 9.93ms (3.08ms CPU time)

Ran 1 test suite in 323.45ms (9.93ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Answer selected by Ifra001

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Lesson 9: [FAIL. Reason: expected an emit, but no logs were emitted afterwards. you might have mismatched events or not enough events were emitted] #1982

{{title}}

Replies: 4 comments 5 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

Select a reply

Lesson 9: [FAIL. Reason: expected an emit, but no logs were emitted afterwards. you might have mismatched events or not enough events were emitted] #1982

Replies: 4 comments · 5 replies

Ifra001 Jul 12, 2024 Author

Ifra001 Jul 12, 2024 Author

Replies: 4 comments 5 replies

Ifra001 Jul 12, 2024
Author

Ifra001 Jul 12, 2024
Author