[FAIL. Reason: stdStorage find(StdStorage): Slot(s) not found.]

[omeguhh]

Hello,

I am trying to test my contract to see if I am picking up the correct "tenant" address. I know that the contract works because I tested it with remix. However, Im doing this exercise to gain a deeper understanding with Foundry. My contract looks like this:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract PropertyManagement {

    address payable private propertyManager;
    address payable private tenant;

    using Counters for Counters.Counter;
    Counters.Counter private _propertyId; 
    Counters.Counter private _agreementId; 

    struct Property {
        uint256 propertyId;
        uint256 rent;
        uint8 bedrooms;
        uint8 bathrooms;
        address _tenant;
        bool vacant;
    }

    struct Agreement {
        Property property;
        uint256 agreementId;
        uint256 duration;
        address _tenant;
        address _propertyManager;
    }

    mapping(uint => Property) public propertyById;
    mapping(uint => Agreement) public agreementById;

    constructor(address _propertymanager) {
        propertyManager = payable(_propertymanager);
    }

    receive() external payable {}

    modifier onlyPropertyManager {
        require(msg.sender == propertyManager, "You're not the property manager.");
        _;
    }

    function createProperty(uint256 _rent, uint8 _bedrooms, uint8 _bathrooms) public onlyPropertyManager {
        _propertyId.increment();
        uint256 setPropertyId = _propertyId.current();
        Property storage property = propertyById[setPropertyId];
        property.propertyId = setPropertyId;
        property.rent = _rent;
        property.bedrooms = _bedrooms;
        property.bathrooms = _bathrooms;
        property.vacant = true;
    }

    function createAgreement(uint256 _pId, uint256 _duration, address _tenant, uint256 _amount) public payable onlyPropertyManager {
        Property memory property = propertyById[_pId];
        require(property.rent == _amount, "Please provide correct amount.");
        require(_amount <= msg.sender.balance, "You dont have enough money.");

        _agreementId.increment();
        uint256 setAgreementId = _agreementId.current();
        Agreement storage agreement = agreementById[setAgreementId];
        agreement.property = property;
        agreement.agreementId = setAgreementId;
        agreement.duration = _duration;
        agreement._tenant = _tenant;
        agreement._propertyManager = msg.sender;

        payable(address(this)).transfer(_amount);
        Property storage rental = propertyById[_pId];
        rental.vacant = false;
        rental._tenant = _tenant;
    }

}

The specific test i'm having trouble with:

function testcheckTenant() public {
        vm.prank(address(1));
        propertyManagement.createProperty(1000, 3, 3);
        vm.prank(address(1));
        propertyManagement.createAgreement{value: 1000}(1, 1, tenant, 1000);
        address slot = stdstore
            .target(address(propertyManagement))
            .sig(propertyManagement.agreementById.selector)
            .with_key(1)
            .depth(3)
            .read_address();
            
        emit log_address(slot);
        //assertEq(address(uint160(uint(vm.load(address(propertyManagement), slot)))), tenant);

    }

Each time I run it I get "[FAIL. Reason: stdStorage find(StdStorage): Slot(s) not found.]" And i've tried it multiple ways but can't seem to figure out the solution. I think ".depth(3)" is not picking up the index in the struct because its not of type uint256? However I'm not sure how to get past that. Would appreciate any advice. Thanks!

[onbjerg]

I'm not actually sure how structs inside structs are represented. Your Property struct is packed (check the Solidity docs for info on the rules):

struct Property {
        uint256 propertyId; // slot 0, 32 bytes
        uint256 rent; // slot 1, 32 bytes
        uint8 bedrooms; // slot 2, 1 byte
        uint8 bathrooms; // slot 2, 1 byte
        address _tenant; // slot 2, 20 bytes
        bool vacant; // slot 2, 1 bit(?)
}

Your Agreement struct is not packed, though:

struct Agreement {
        Property property; // not sure about this one
        uint256 agreementId; // slot 0, 32 bytes
        uint256 duration; // slot 1, 32 bytes
        address _tenant; // slot 2, 20 bytes
        address _propertyManager; // slot 3, 20 bytes
}

In your case it seems that you are trying to get the slot of the _propertyManager field for a specific value in your mapping. I see a couple of scenarios:

1. There's a bug in Forge Std, in which case I'd recommend you open an issue in the Forge Std repo
2. The property field in the Agreement struct occupies 1 slot, in which case the property manager would be in slot 4
3. The property field is a flattened representation of the Property struct, in which case the first 3 slots are actually the Property struct and your property manager address would be in slot 6 (slots 0-2 inclusive are Property fields, slots 3-6 inclusive are Agreement fields)

[omeguhh]

Hey thanks for the reply. I just read through this section on the solidity docs and it was definitely helpful - I did not know that was how slots were set up. I am trying to get to the "tenant" in the agreement struct. I figured key(1) & depth(3) should get me to that value but now realizing that may be more complicated.

Additionally, I ran one of my other tests now understanding how the slots are separated:

function testCreateProperty() public {
        vm.prank(address(1));
        propertyManagement.createProperty(1000, 4, 3);
        uint256 slot = stdstore
            .target(address(propertyManagement))
            .sig(propertyManagement.propertyById.selector)
            .with_key(1)
            .depth(2)
            .find();

        
        assertEq(uint(vm.load(address(propertyManagement), bytes32(slot))),4);
    }

And I got the same error (Slot not found) - which leads me to think regardless of how the property field is represented there may be a bug preventing me from accessing some of my slots (Using depth 1 and 0 work to access propertyId and rent but I can't access anything else after that). Would you agree? I think I may reach out and open an issue with that in mind.

Thanks again for your help

[onbjerg]

The reason you probably can't access anything after slot 1 in your property struct is that it's a packed slot, and I think Forge Std has some issues with packed slots, but I'm not sure. Pinging @brockelmore because he might have a better understanding of what's going on 🙂

[omeguhh]

I think you're right because I did notice when I was doing my test yesterday that when i switched the bedrooms field in Property from uint8 to uint256 that it did work so that does seem to be part of the problem. However, it is not only the Property struct it's also the Agreement struct that I cannot access. Just read through this article on variable packing and it helped clarify it a bit but I still think this may be a forge issue

Thanks for that too btw!

[onbjerg]

Just want to clarify here: the bug is not in Forge, it's in the Forge Std library here: https://github.com/foundry-rs/forge-std. I would recommend opening up an issue there; I haven't contributed to it myself, so my knowledge of how it works is rather limited unfortunately 🙁

[omeguhh]

Thanks for the clarification. No problem I definitely understand more than I did before your messages so appreciate that. Will go ahead and open up an issue there though