Doubt on contract calling it's own function

Question

Suppose there is a modifier in a contract:

modifier onlySelf() {
        require(msg.sender == address(this), "Not Self");
        _;
    }

If i make a function in this contract like this:

function test() public onlySelf {
    <function_body>
}

How it will work? More explicitly i wanna know if i deploy the contract how this function will be called?

Answer 1

This modifier requires that the call to the test function is made from the contract instance itself. In a simple contract, it is the same as declaring the method internal/private but it costs more gas.

In all likelihood though it is being used to facilitate some level of contract upgradeability or possibly to allow contracts to have the same proxy address on different EVM chains. Without more context/code though it is hard to say why it is written.

To actually call it, you can use a method in the same contract instance such as:

function testTheTestFunction() public {
  return this.test()
};

You may need to add some specifics to testTheTestFunction depending on the return value of test() ect but the concept is basically it enforces access control so that the test function can only be called from the contract instance itself.

Answer 2

Modifier is testing the sender against address of the contract, calling test function from other contracts or EoA will fail.

And if there are no other functions in this contract that make call to test function using call or delegatecall, it will not be possible to call test function from even within the contract.

Test can also be called from within the contract using this.test()

contract Storage {

    uint256 number;

    function store(uint256 num) public {
        number = num;
    }

    modifier onlyMe(){
        require(msg.sender == address(this));
        _;
    }

    function retrieve() public view returns (uint256){
        //return this.get();    this also works
        return ((Storage)(this)).get();
    }

    function get() public onlyMe view returns (uint256){
        return number;
    }
}

Answer 3

OnlySelf is a modifier. It is a special kind of function that is processed at the beginning of the callable function.

You can imagine it like this:

function test() public {
    require(msg.sender == address(this), "Not Self");
    <function_body>
}

The _; indicates where the <function_body> is inserted.