Solidity – Can’t Call Function in One Contract from Another

contract-deploymentcontract-developmentcontract-invocationsolidity

I'm trying to call a function in one contract from another contract with the following simple example:

Untitled.sol:

pragma solidity ^0.4.16;

contract helloworld {
function returnint() returns (uint) {
return 15;
}
}

And the second contract:

pragma solidity ^0.4.16;

import "./Untitled.sol";

contract pullother {

function callFunctionInContractOne (address _address) returns (uint) {
    helloworld contractOne = helloworld(_address);
    contractOne.returnint();
}
}

When calling callFunctionInContractOne() in the second contract, the address of the deployed Untitled.sol is given as a parameter, then the returnint() function in the first contract is called (which should return 15). When I try this in the remix editor I get the following returned instead:

I am copying from calling simple function from another contract but getting a different result. I've also tried running a function on one contract from another on a private blockchain in a similar way but am unsuccessful.

Adding a return value I get the same thing:

Best Answer

You actually sent a TX that call that method of the first smart contract, that called the function of the second smart contract. The thing is you are on a real blockchain - it seems Ropsten to me - and not in the memory of your computer, so you cannot retrieve values from a contract like that. What remix is returning to you is the transaction receipt after the block is mint.

If you want a ÐApp to be able to retrieve values directly from a contract, create functions with constant returns. And please note soon this constant will be split in view and pure.

Related Solutions

Solidity Function Call – Calling a Simple Function from Another Contract

I've tried your code in the solidity browser and it works

I think your need to use

return h.f()

solidity – Calling One Contract Method from Another Contract

pragma solidity 0.4.21;

contract Base {

    uint public dataA;
    bytes32 public dataB;

    function setAB(uint a, bytes32 b) public {
        dataA = a;
        dataB = b;
    }

    function getA() public view returns(uint) {
        return dataA ;
    }

    function getB() public view returns(bytes32) {
        return dataB ;
    }

}

contract Extra {

   Base base;

   function Extra() public {
       base = new Base();
   }

   function getBaseAddres() public view returns(address) {
       return address(base);
   }

   function baseGetA() public view returns(uint) {
        return base.getA();
   }

   function baseGetB() public view returns(bytes32) {
       return base.getB();
   }

   function baseSetAB(uint a, bytes32 b) public returns(bool success) {
       base.setAB(a,b);
       return true;
   }
}

Hope it helps.

UPDATE

The above example just creates a new Base with each deployment of Extra to show them talking in the simplest manner I can think of. Another way to go is to deploy a Base separately. It's location can then be relayed to Extra.

You could pass it into the constructor:

Base base;

function Extra(address baseAddress) public {
  base = Base(baseAddress);
}

It's not checking anything, merely assuming the deployer knows what they're doing. You can also make the address of the base something the owner can change.

Add an owner to the state and the constructor:

address public owner;

function Extra(address baseAddress) public {
  base = Base(baseAddress);
  owner = msg.sender;
}

Add a modifier (after state and before constructor, by convention) to restrict access to the sensitive function.

modifier onlyOwner {
  require(msg.sender == owner);
  _;
}

Add a restricted function to change the base.

function changeBase(address newBase) public onlyOwner returns(bool success) {
  base = Base(newBase);
  return true;
}

You might want to know the address of the Base:

return address(base);

It would be good practice to add event emitters to the state-changing functions in both contracts.

Best Answer

Related Solutions

Solidity Function Call – Calling a Simple Function from Another Contract

solidity – Calling One Contract Method from Another Contract

Related Topic