Are multiple interfaces with same function signature necessary

Question

I need some basic interface understanding. In my contract I implement two interfaces with the same function signature:

interface IFirst {function someCall(address sender) external;}
interface ISecond {function someCall(address sender) external;}

contract MyContract is IFirst, ISecond {    
    function someCall(address sender) external override {...}
}

Because my contract can be called from other contracts e.g. A and B like this:

A: IFirst(myContractAddress).someCall(0x...);
B: ISecond(myContractAddress).someCall(0x...);

Isn't it just enough to implement the first Interface because it already ensures the existance of the correct someCall function?

But..is it then necessary to implement the interface at all if I just make sure the function someCall with the correct signature exists in my contract?

Answer 1

You're right, you can use one same interface for multiple contracts.

On a side note - you can actually use one interface for multiple instances inside same contract if for whatever reason two different contracts share same method names and method parameters, but with different functionality behind them:

pragma solidity 0.8.0;

contract TestContract {
    Interface interface_instance_one = Interface(<CONTRACT_ADDRESS_ONE>);
    Interface interface_instance_two = Interface(<CONTRACT_ADDRESS_TWO>);
}

interface Interface {
    function someCall(address sender) external;
}