Lesson 11 NFT: How is this not crashing? Result of callback function used before it is finished.

[n4n0b1t3]

Does anyone understand the execution order of the following code? I understand that this has something to do with asynchronous execution order. However, is there not a chance, that the callback function will reach the line where it makes use of the address before it is actually set?

As I understand it, the "owner" address should not be available at the time it is used in fulfillRandomness.
A synchronous execution order would look like this:

1. createCollectible calls requestRandomness
2. requestRandomness uses the callback function fulfillRandomness
3. fulfillRandomness reaches the point of address owner = requestIdToSenderMap[requestId]
4. since this is after the execution of requestRandomness, the direct following line requestIdToSenderMap[requestId] = msg.sender has not yet been executed and the owner address should not be available at this time.

here is the complete solidity file

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";

contract AdvancedCollectible is ERC721, VRFConsumerBase {
    uint256 public tokenCounter;
    bytes32 public keyhash;
    // fee = 0.1 * 10 ** 18; // 0.1 LINK (Varies by network)
    uint256 public fee;
    mapping(uint256 => Breed) public tokenIdToBreedMap;
    mapping(bytes32 => address) public requestIdToSenderMap;

    enum breed {
        PUG,
        SHIBA_INU,
        ST_BERNARD
    }

    constructor(
        address _vrfCoordinator,
        address _linkToken,
        bytes32 _keyhash,
        uint256 _fee
    )
        public
        VRFConsumerBase(_vrfCoordinator, _linkToken)
        ERC721("Dogie", "DOG")
    {
        tokenCounter = 0;
        keyhash = _keyhash;
        fee = _fee;
    }

    function createCollectible(string memory tokenURI)
        public
        returns (bytes32 requestId)
    {
        bytes32 requestId = requestRandomness(keyhash, fee);
        // this should be executed after the callback function is finished
        requestIdToSenderMap[requestId] = msg.sender;
    }

    function fulfillRandomness(bytes32 requestId, uint256 randomness)
        internal
        overwrite
    {
        Breed breed = Breed(randmoness % 3);
        uint256 newTokenId = tokenCounter;
        tokenIdToBreedMap[newTokenId] = breed;
       // owner should not yet be available
        address owner = requestIdToSenderMap[requestId];
        _safeMint(owner, newTokenId);
    }
}

[cromewar]

Hello @n4n0b1t3
I think you described perfectly how this works
As fulfill randomness is an asynchronous function requestIdToSenderMap[requestId] = msg.sender gets executed before the function finishes as the randomness variable need time to return a value, so at the time you use address owner = requestIdToSenderMap[requestId] the mapping already knows the address of the sender.

Somethings some coders are used to set up a requiere statement to prevent the further execution of the function if for some reason the randomness returns null, but is not likely.

Also VRF V2 is just realized and the way we take that random number has changed a lot.