msg.sender在构造函数中：
 
//构造函数
constructor() public {
    owner = msg.sender;
}

function increse(address receiver, uint amount) public{
    require( owner == receiver);
    balances[receiver] += amount;
}
 
在构造函数中，msg.sender等于部署该合约的地址；

智能合约之间的调用
 
在区块链上，有些功能往往无法通过一个智能合约完成，此时便会用到智能合约之间的调用。本篇文章带大家通过具体示例来了解一下智能合约之间的调用。
 
在智能合约的编译过程中，有两种情况：调用者和被调用者在一个sol文件中和分别在不同的文件中。
 
同sol文件的智能合约调用
 
在下面的智能合约中，Demo1和Demo在同一个文件中，可进行同时编译，然后逐个发布。
 
pragma solidity ^0.5.10;

contract Demo1{
    
    uint public data;
    
    function setData(uint _data) public {
        data = _data;
    }
}

contract Demo2{
    function toSetData(Demo1 demo1,uint _data) public {
        demo1.setData(_data);
    }
}
 
当发布完成，可通过第Demo2的toSetData方法进行Demo1方法的调用。传递的第一个参数为Demo1的智能合约地址，第二个参数为要设置的值。
 
不同sol文件的智能合约调用
 
在大多数情况下，两个智能合约不存在于同一个sol文件中，那么就需要使用另外一种形式来进行调用。还拿调用Demo1方法来举例，用另外一个sol文件中的Demo3来调用Demo1。
 
首先需要声明接口，然后在Demo3中直接调用对应的接口。
 
pragma solidity ^0.5.10;

contract Demo1{
    function setData(uint _data) public;
}

contract Demo3{
    function toSetData(Demo1 demo1,uint _data) public {
        demo1.setData(_data);
    }
}
 
调用接口是传递的参数依旧同第一种情况。
 
原文链接：https://www.choupangxia.com/2019/07/30/solidity-智能合约之间的调用/
 
 

 程序新视界
 

 

 关注程序员的职场生涯，大量优质学习资源、技术文章分享
 

 

最近在看以太坊，顺便记录一下，这篇文章的目的是一个智能合约调用另一个智能合约的方法，写个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方法
 
 
发送成功后就可以查看了
 
 
至此一个合约调用另一个合约可以实现

最近有个新的需求
 已经有一个代币合约如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);
        _;
    }
}