最近有个新的需求
已经有一个代币合约如C,需要实现一个合约，在这个合约中调用代币合约C中的transfer函数，即转代币的函数。

要在一个合约中调用另一个合约，可用用以下三种方式调用。

• CALL:最常用调用，内置变量msg的值会被修改为调用者，执行环境为被调用者的运行环境。
• DELEGATECALL:调用后内置变量msg的值不会修改为调用者，但执行环境为调用者的运行环境。
• CALLCODE和DELEGATECALL: 是在调用者的上下文中执行, 可以修改调用者的storage; CALLCODE 阻止msg.sender和msg.value传递;
  而DELEGATECALL不阻止;

在A的合约中,B.callcode(c的函数): c看到msg.sender是B;
在A的合约中,B.delegatecall(c的函数): c看到msg.sender是A;

可以看到，这三种方式都并不符合我们的需求。
方法只有，先让用户调用代币合约C中的approve方法，再调用下面实现的合约中的depositToken方法。
pragma solidity ^0.4.25;

contract Deposit {
    
    bool public stopped = false;
    uint256 public totalDeposit=0;
    uint256 minDepositValue;
    address owner;
    address cTokenAddr=0x01c2ce7bd1bc34eed8a99d0ea0abee305362c143;
    uint256 minBlockGap;
    mapping(address => mapping(string=>uint256))  depositRecords;
    mapping(address=>mapping(string=>uint256))  withdrawRecords;
    uint256 public account=0;
    
    uint256 public blocknum ;
   
    constructor(uint256 _minValue,uint256 _minBlockGap) public {
        owner=msg.sender;
        minDepositValue=_minValue;
        minBlockGap=_minBlockGap;
    }
    
    event Withdraw(address indexed _from, string indexed _pk, uint indexed _value);
    event DepositToken(address indexed _from,address indexed _to,uint256 indexed _value);


    function depositToken(address _to,uint256 _value,string pk) public isRunning  validAddress returns (bool sucess) {
        require(_value>minDepositValue);
        bytes4 transferFromMethodId = bytes4(keccak256("transferFrom(address,address,uint256)"));
        if(cTokenAddr.call(transferFromMethodId,msg.sender,_to, _value)){
             depositRecords[msg.sender][pk]+=_value;
             totalDeposit+=_value;
             emit DepositToken(msg.sender,_to,_value);
             return true;
        }
        return false;
    }
    
    function setMinBlockGap(uint256 _blockGap) public onlyOwner {
        minBlockGap=_blockGap;
    }

    function withdraw(uint256 _value,string _pk) public onlyOwner isRunning  validAddress returns (bool sucess) {
        require(depositRecords[msg.sender][_pk]>_value);
        uint256 blockNumGap=getBlockNumGap(_pk);
        if(blockNumGap<minBlockGap)
             return false;
             
        bytes4 transferMethodId = bytes4(keccak256("transfer(address,uint256)"));
        if(cTokenAddr.call(transferMethodId,msg.sender, _value)){
            depositRecords[msg.sender][_pk]-=_value;
            withdrawRecords[msg.sender][_pk]=0;
            totalDeposit-=_value;
            emit Withdraw(msg.sender,_pk,_value);
            return true;
        }
        return false;
    }

  
    
    function getDeposit(string pk) public view returns (uint256){
        return depositRecords[msg.sender][pk];
    }
    
    function getDepositByAddr(address addr,string pk) public onlyOwner view returns(uint256){
        return depositRecords[addr][pk];
    }
    
    
    function RequestWithdraw(string pk) public returns (bool){
       getBlockNumGap(pk);
    }
    
    function getwithdrawRecords(string pk) public view returns (uint256){
        return withdrawRecords[msg.sender][pk];
    }
    
    function getBlockNum() private view returns (uint256){
        return block.number;
    }
    
  
    function getBlockNumGap(string pk) private returns (uint256){
        uint256 number=getBlockNum();
        if (withdrawRecords[msg.sender][pk]==0){
            withdrawRecords[msg.sender][pk]=number;
            return 0;
        }else{
            return number-withdrawRecords[msg.sender][pk];
        }
    }
    
    function getTotalDeposit()  public onlyOwner view returns (uint256){
        return totalDeposit;
    }
    
    function stop(address _to,bool ifTransfer) public onlyOwner returns (bool sucess) {
        stopped=true;
        if(!ifTransfer){
            return true;
        }
        bytes4 methodId = bytes4(keccak256("transfer(address,uint256)"));
        if(cTokenAddr.call(methodId,_to,totalDeposit)){
            totalDeposit=0;
            return true;
        }
       return false;
    }
    
    function () payable public {
        revert();
    }
    
    function start() public onlyOwner {
        stopped = false;
    }
  
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    modifier isRunning {
        require(!stopped);
        _;
    }
    modifier validAddress {
        require(address(0) != msg.sender);
        _;
    }
}

我们将介绍一种新颖的方法来调用另一个智能合约。方法建立在 OP_PUSH_TX 的技术之上。我们通过让一个合约调用另一个合约来求解二次方程来说明该方法。它已在 Sensible Contract 等项目中得到推广和广泛使用。

背景

从 sighash 原像的规范中，我们可以看到交易中的每个输入都有不同的 sighash 原像。我们还看到它们的原像有重叠的部分。最值得注意的是，它们共享相同的输出（彩色）。input0 和 input1 的原像都包括 output0 和 output1，如下面的示例交易₁中突出显示的部分。我们利用这一特性来让两个合约相互通信。

合约间调用

为了演示如何调用另一个合约，我们考虑求解一个二次方程的示例：a * x² + b * x + c = 0。

下面列出了求解方程的合约。它将解 x 写入 output0。

struct Coeff {
    int a;
    int b;
    int c;
}

contract Callee {
    static const int N = 2;

    public function solve(Coeff co, int x, SigHashPreimage txPreimage) {
        // Note: SigHash_SINGLE is used
        require(Tx.checkPreimageSigHashType(txPreimage, SigHash.SINGLE | SigHash.FORKID));

        // check x is a root
        require(co.a * x * x + co.b * x + co.c == 0);

        bytes data = num2bin(co.a, N) + num2bin(co.b, N) + num2bin(co.c, N) + num2bin(x, N);
        bytes outputScript = Utils.buildOpreturnScript(data);
        bytes output = Utils.buildOutput(outputScript, 0);
        require(hash256(output) == SigHash.hashOutputs(txPreimage));
    }
}

调用者Caller合约也可以访问 output0，可以提取解 x 并使用它，而无需求解 x 本身。也就是调用上面的Callee合约。

contract Caller {
    static const int N = 2;
    static const int calleeContractInputIndex = 1;
    static const int selfContractInputIndex = 0;
    // hash of the callee contract, i.e., its locking script
    PubKeyHash calleeContractHash;

    public function call(Coeff co, bytes prevouts, bytes calleeContractTx,
        bytes outputScript, int amount, SigHashPreimage txPreimage) {
        require(Tx.checkPreimage(txPreimage));
        require(hash256(prevouts) == SigHash.hashPrevouts(txPreimage));

        // validate the tx containing the callee contract
        bytes prevScriptTxId = prevouts[calleeContractInputIndex * TxUtil.OUTPOINT_LEN : calleeContractInputIndex * TxUtil.OUTPOINT_LEN + TxUtil.TX_ID_LEN];
        require(hash256(calleeContractTx) == prevScriptTxId);

        // validate the callee contract, i.e., its locking script
        int lockContractTxOutIndex = Utils.fromLEUnsigned(prevouts[selfContractInputIndex * TxUtil.OUTPOINT_LEN + TxUtil.TX_ID_LEN : selfContractInputIndex * TxUtil.OUTPOINT_LEN + TxUtil.TX_ID_LEN + 4]);
        bytes prevScriptCode = TxUtil.readOutput(calleeContractTx, lockContractTxOutIndex).script;
        require(hash160(prevScriptCode) == this.calleeContractHash);

        int l = len(outputScript);
        int a = unpack(outputScript[l - 4 * N : l - 3 * N]);
        int b = unpack(outputScript[l - 3 * N : l - 2 * N]);
        int c = unpack(outputScript[l - 2 * N : l - N]);
        require(co == { a, b, c });
        int x = unpack(outputScript[l - N :]);
        // ------>> x must be a root for the following quadatic equition: no need to double check
        // require(a * x * x + b * x + c == 0);

        bytes output = Utils.buildOutput(outputScript, amount);
        require(hash256(output) == SigHash.hashOutputs(txPreimage));
    }
}

优点

与通过将函数直接包含到合约本身来调用函数的直接方式相比，通过另一个单独的合约调用它有几个显着的优势。

• 效率 ： 一个有状态的合约可以有多个内部功能。每次它改变状态时，并不是所有的都必须被调用。然而，由于它们都是合约的一部分，它们都必须包含在内，从而导致交易规模膨胀。通过将它们放入单独的合约中，只从主合约调用给定调用所需的那些，从而节省大量成本，尤其是在有许多功能时。
• 可扩展性 ： 一个通用函数可以包装到一个库合约中，可以从任何其他合约调用，而无需了解其内部实现细节。这使它与调用合约₂ 解耦。

致谢

该技术由 Sensible Contract 的 Chen Cheng、Jiejiang 和 Lu Gu 以及 Cambridge Cryptographic 的 Ying Chan 独立发明。

[1] 假设使用了 SIGHASH_ALL。

[2] 库合约的作者可以通过要求在合约被调用时必须向他控制的地址支付小额款项来获得收益。

最近在看以太坊，顺便记录一下，这篇文章的目的是一个智能合约调用另一个智能合约的方法，写个demo记录一下

pragma solidity ^0.4.18;

contract DataContract {
    mapping (address => uint256) public balanceOf;

    function setBlance(address _address, uint256 v) public  {
        balanceOf[_address] = v;
    }

}

contract ControlContract {
    mapping (address => uint256) public tmp;
    DataContract dataContract;

    function ControlContract(address _dataContractAddr) public {
        dataContract = DataContract(_dataContractAddr);
    }

    function set(uint256 value) public {
        dataContract.setBlance(msg.sender, value);
        tmp[msg.sender] = value + 10;
    }
}

说明 DataContract合约提供了一个公共方法setBalance, ControlContract合约中会调用set方法来更新自己与DataContract保存的数据。

首先部署DataContract合约，然后部署ControlContract合约，在创建的时候需要指定DataContract合约地址。

首先调用set方法

发送成功后就可以查看了

至此一个合约调用另一个合约可以实现