How to find the address of the contract owner?

Question

I'm under the impression that the owner of the contract is simply referred to as accounts[0] in Truffle's testing environment, but I'm getting the error by the modifier that the caller of a certain function is not the owner.

I have instantiated contract A and contract B and the following code is in contract B:

    modifier requireContractOwner() {
        require(msg.sender == contractOwner, "Caller is not contract owner");
        _;
    }

    function _authorizeCaller(address addr)
        external
        requireContractOwner
    {
        authorizedCaller[addr] = true;
    }

And I'm calling the functions from contract A:

    function authorizeCaller(address addr) public {
        B._authorizeCaller(addr);
    }

The way I instantiated A is:

    constructor(address dataContract) public {
        contractOwner = msg.sender;
        B = B(dataContract);
    }

and B:

   constructor() public {
        contractOwner = msg.sender;
        authorizedCaller[msg.sender] = true;
    }

Following is how I deploy them:

module.exports = function (deployer, network, accounts) {
  deployer.deploy(B).then(() => {
    return deployer
      .deploy(A, B.address)
      .then(() => {
       // configuration
      });
  });
};

The problem is, when I test calling the function with the owner of the contract:

      let B = await B.new();
      let A = await A.new(B.address);
      await A.authorizeCaller(accounts[1], {
        from: accounts[0],
        gasPrice: 0,
      });

the testing fails saying that accounts[0] is not the owner of the contract by the modifier requireContractOwner().

Answer 1

I'm under the impression that the owner of the contract is simply referred to as accounts[0] in Truffle's testing environment...

Unless you explicitly specify {from: someAccount}, the default is indeed {from: accounts[0]}.

---

And I'm calling the functions from contract A:

function authorizeCaller(address addr) public {
    B._authorizeCaller(addr);
}

Here, the value of msg.sender when function _authorizeCaller is executed will be the address of contract A, not the address of the deployer of contract A.

Hence the expression msg.sender == contractOwner will evaluate to false.

You should generally implement the requireContractOwner modifier in a utility contract:

contract Owned {
    address public contractOwner;

    constructor() public {
        contractOwner = msg.sender;
    }

    modifier requireContractOwner() {
        require(msg.sender == contractOwner, "Caller is not contract owner");
        _;
    }
}

And then inherit this contract and use it wherever needed:

import "./Owned.sol";

contract B is Owned {
    constructor() public {
        // constructor of `Owned` has already executed at this point
        ...
    }

    function _authorizeCaller(address addr) external requireContractOwner {
        ...
    }
}