title: Solidity - How to call smart contract instances from external contract?
body: <p>I have created an AccountManager smart contract and two instances of it(PARTYA and PARTYB).
  When calling TransferAgent.transfer(AccountManager.address, AccountManager.address) I can see accounts[msg.sender].balance update as expected.
  However, when calling the instances(PARTYA and PARTYB), for example, TransferAgent.transfer(PARTYA.address, PARTYB.address) there is no change reflected in the balance.  </p>
  
  <p>I have spent some time researching how to call AccountManager (instances) from TransferAgent (external contract) using addresses, but could not find anything specific to this.  I am not able to get balance to reflect change.  Any suggestions?</p>
  
  <p>Environment
  - Ethereum
  - embark-framework
  - Solidity</p>
  
  <p>My setup is below </p>
  
  <p>contracts.json</p>
  
  <pre><code>    {
        "default": {
          "gas": "auto",
          "contracts": {
            "SimpleStorage": {
              "args": [
                100
              ]
            },
            "Agent" : {
              "args": [
              ]
            },
            "AccountManager" : {
              "args": [
              ]
            },
            "PARTYA" : {
              "instanceOf" : "AccountManager",
              "args" : [
              ]       
            },
            "PARTYB" : {
              "instanceOf" : "AccountManager",
              "args" : [
              ]       
            },
            "TransferAgent" : {
              "args": [
              ]
            }
          }
        }
      }
  </code></pre>
  
  <p>Agent.sol</p>
  
  <pre><code>pragma solidity ^0.4.0;
  
  contract Agent {
  /* Define variable owner of the type address*/
  address owner;
  
  /* this function is executed at initialization and sets the owner of the contract */
  function Agent() { owner = msg.sender; }
  
  /* Function to recover the funds on the contract */
  function kill() { if (msg.sender == owner) selfdestruct(owner); }
  }
  
  contract AccountManager is Agent {
  enum ACTIVE { Y, N } 
  enum STATUS { CREDIT, DEBIT }
  mapping (address =&gt; Account) public accounts;
  
  struct Account {
      bytes32 ssn;
      int balance;
      ACTIVE active;
      STATUS status;
  }
  
  modifier withdrawValidation(int withdrawAmt) {
      if( withdrawAmt &lt;= accounts[msg.sender].balance)  {
          throw;
      }
      _;
  }
  
  // Check for current account matching 
  modifier transferValidation(address _from, address _to, bytes32 _ssn) {
      if( AccountManager(_from).getSSN() != _ssn || 
              AccountManager(_to).getSSN() != _ssn || 
                  AccountManager(_from).getStatus() == STATUS.CREDIT )  {
          throw;
      }
      _;
  }
  
  function register(bytes32 _ssn) public returns (bool success) {
      Account memory newRegistree;
      newRegistree.ssn = _ssn;
      newRegistree.balance = 0;
      newRegistree.active = ACTIVE.Y;
      newRegistree.status = STATUS.DEBIT;
      accounts[msg.sender] = newRegistree;
      return true;
  }
  
  function update(bytes32 _ssn) public returns (bool success) {
      accounts[msg.sender].ssn = _ssn;
      return true;
  }
  
  function deposit(int _depositAmt) public returns(bool success) {
      accounts[msg.sender].balance += _depositAmt;
      return true;
  }
  
  function withdraw(int _withdrawAmt) public returns(bool success) {
      accounts[msg.sender].balance = (accounts[msg.sender].balance - _withdrawAmt);
      return true;
  }
  
  function getBalance() public constant returns(int balance) {
      return accounts[msg.sender].balance;
  }
  
  function setBalance(int _balance) external returns(bool success) {
      accounts[msg.sender].balance = _balance;
      return true;
  }
  
  function setStatus() internal {
      if(accounts[msg.sender].balance &gt;= 0)
          accounts[msg.sender].status = STATUS.DEBIT;
      else 
          accounts[msg.sender].status = STATUS.CREDIT;
  }
  
  function getStatus() external constant returns (STATUS status) {
      return accounts[msg.sender].status;
  }
  
  function getSSN() external constant returns(bytes32 ssn) {
      return accounts[msg.sender].ssn;
  }
  
  function getAccount() public constant returns (bytes32 ssn, int balance, ACTIVE active, STATUS status) {
      return (accounts[msg.sender].ssn, accounts[msg.sender].balance, accounts[msg.sender].active, accounts[msg.sender].status);
  }
  }
  
  contract TransferAgent is Agent {
  function transfer(address _from, address _to) public returns (bool success) {
      AccountManager(_from).setBalance(100); // not working for instances PARTYA,PARTYB
      AccountManager(_to).setBalance(200); // not working for instances PARTYA,PARTYB    }
  }
  </code></pre>