Blockchain Solidity-如何从外部合同调用智能合同实例？

我创建了AccountManager智能合约和两个实例（PARTYA和PARTYB）。 调用TransferAgent.transfer（AccountManager.address，AccountManager.address）时，我可以看到帐户[msg.sender]。余额按预期更新。 但是，当调用实例（PARTYA和PARTYB）时，例如TransferAgent.transfer（PARTYA.address，PARTYB.address），余额中没有反映任何更改

我花了一些时间研究如何使用地址从TransferAgent（外部合同）调用AccountManager（实例），但找不到任何特定于此的内容。我无法获得平衡以反映变化。有什么建议吗

环境 -以太坊 -启动框架 -坚固性

我的设置如下

contracts.json

    {
      "default": {
        "gas": "auto",
        "contracts": {
          "SimpleStorage": {
            "args": [
              100
            ]
          },
          "Agent" : {
            "args": [
            ]
          },
          "AccountManager" : {
            "args": [
            ]
          },
          "PARTYA" : {
            "instanceOf" : "AccountManager",
            "args" : [
            ]       
          },
          "PARTYB" : {
            "instanceOf" : "AccountManager",
            "args" : [
            ]       
          },
          "TransferAgent" : {
            "args": [
            ]
          }
        }
      }
    }

索尔探员

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 => Account) public accounts;

struct Account {
    bytes32 ssn;
    int balance;
    ACTIVE active;
    STATUS status;
}

modifier withdrawValidation(int withdrawAmt) {
    if( withdrawAmt <= 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 >= 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    }
}

pragma-solidity^0.4.0；
合同代理人{
/*定义类型地址的变量所有者*/
地址所有者；
/*此函数在初始化时执行，并设置合同的所有者*/
函数代理（）{owner=msg.sender；}
/*收回合同资金的功能*/
函数kill（）{if（msg.sender==owner）selfdestruct（owner）；}
}
合同会计经理是代理人{
枚举活动{Y，N}
枚举状态{贷方，借方}
映射（地址=>账户）公共账户；
结构帐户{
bytes32-ssn；
国际收支平衡；
积极主动；
地位；
}
修改器提取验证（int提取金额）{
如果（提款金额=0）
账户[msg.sender].status=status.DEBIT；
其他的
帐户[msg.sender].status=status.CREDIT；
}
函数getStatus（）外部常量返回（状态）{
返回帐户[msg.sender]。状态；
}
函数getSSN（）外部常量返回（bytes32 ssn）{
返回帐户[msg.sender].ssn；
}
函数getAccount（）公共常量返回（字节32 ssn，整数余额，活动，状态）{
返回（帐户[msg.sender].ssn，帐户[msg.sender].balance，帐户[msg.sender].active，帐户[msg.sender].status）；
}
}
合同转让代理人是代理人{
函数传输（地址从，地址到）公共返回（bool成功）{
AccountManager（_from）.setBalance（100）；//不适用于实例PARTYA、PARTYB
AccountManager（_to）.setBalance（200）；//不适用于实例PARTYA，PARTYB}
}

这里有一个非常简单的示例，它只专注于将事务发送到另一个合同

“集线器”将部署两个“辐条”，然后您可以使用

函数local（）

向其中一个辐条发送消息。事件记录在两侧，因此您可以看到发生了什么

contract Hub {

  Spoke public A;
  Spoke public B;

  event LogTXNSent(address spoke);

  function Hub() {
    A = new Spoke();
    B = new Spoke();
  }

  function local(address spokeAddress)
    public
    returns(bool success)
  {
    if(spokeAddress != address(A) && spokeAddress != address(B)) throw;
    if(!Spoke(spokeAddress).logEvent()) throw;
    LogTXNSent(spokeAddress);
    return true;
  }

}

contract Spoke {

  event LogTXNFrom(address sender);

  function logEvent()
    public
    returns(bool success)
  {
    LogTXNFrom(msg.sender);
    return true;
  }
}

希望能有帮助