检查 msg.sender 是否是特定类型的合约

Question

As it is now, anyone can call the setMyString function in the FirstContract . I'm trying to restrict access to that function to an instance of SecondContract . But not one specific instance, any contract of type SecondContract should be able to call setMyString .

contract FirstContract{
    String public myString;

    function setMyString(String memory what) public {
        myString=what;
    }
}

contract SecondContract{
    address owner;
    address firstAddress;
    FirstContract firstContract;
    constructor(address _1st){
        owner=msg.sender;
        firstAddress=_1st;
        firstContract=FirstContract(firstAddress);
    }
    function callFirst(String memory what){
        require(msg.sender==owner);
        firstContract.setMyString("hello");
    }
}

Answer 1

Solidity currently doesn't have an easy way to validate an address against an interface.

You can check the bytecode, whether it contains the specified signatures (of the public properties and methods). This requires a bit larger scope than a usual StackOverflow answer, so I'm just going to describe the steps instead of writing the code.

First, define the desired list of signatures (1st 4 bytes of keccak256 hash of the name and arguments datatypes) that you're going to be looking for. You can find more info about signatures in my other answers here and here .

An example in the documentation shows how to get any address's (in your case msg.sender ) bytecode as bytes (dynamic-length array).

You'll then need to loop through the returned bytes array and search for the 4-byte signatures.

If you find them all , it means that msg.sender "implements the interface". If any of the signatures is missing in the external contract, it means it doesn't implement the interface.

---

But... I'd really recommend you to rethink your approach to whitelisting. Yes, you'll need to maintain the list and call setIsSecondContract() when a new SecondContract wants to call the setMyString() function for the first time. But it's more gas efficient for all callers of the FirstContract 's setMyString() function, as well as easier to write and test the functionality in the first place.

contract FirstContract{
    String public myString;
    
    address owner;
    mapping (address => bool) isSecondContract;
    
    modifier onlySecondContract {
        require(isSecondContract[msg.sender]);
        _;
    }
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    function setIsSecondContract(address _address, bool _value) public onlyOwner {
        isSecondContract[_address] = _value;
    }

    function setMyString(String memory what) public onlySecondContract {
        myString=what;
    }
}