学习solidity的一个简单智能合约（2）——对冲

在白皮书中看到，以太坊之上有三种应用。第一类是金融应用，为用户提供更强大的用他们的钱管理和参与合约的方法。包括子货币，金融衍生品，对冲合约，储蓄钱包，遗嘱，甚至一些种类的全面的雇佣合约。第二类是半金融应用，这里有钱的存在但也有很重的非金钱的方面，一个完美的例子是为解决计算问题而设的自我强制悬赏。最后，还有在线投票和去中心化治理这样的完全的非金融应用。

于是根据白皮书上的一个例子——对冲合约，即一种金融衍生品——进行了编写（仅仅是模拟，还不知道怎么加入区块链），用智能合约进行编写的原因是因为在这一方面的特别的方便

以下是白皮书上举一个例子：

当这些关键要素都齐备，对冲合约看起来会是下面的样子：

等待A输入1000以太币。.

等待B 输入1000以太币。

通过查询数据提供合约，将1000以太币的美元价值，例如，x美元，记录至存储器。

30天后，允许A或B“重新激活“合约以发送价值x美元的以太币（重新查询数据提供合约，以获取新价格并计算）给A并将剩余的以太币发送给B。

pragma solidity ^0.4.0;

//完成金融衍生品对冲合约

/*等待A输入1000以太币。.
等待B 输入1000以太币。
通过查询数据提供合约，将1000以太币的美元价值，例如，x美元，记录至存储器。
30天后，允许A或B“重新激活“合约以发送价值x美元的以太币
（重新查询数据提供合约，以获取新价格并计算）给A并将剩余的以太币发送给B。*/

描述在注释中对冲智能合约；

contract hedge{
    
    struct giver{
        address gaddr;//A方人地址
        bool yn;//是否投票
        uint amount;//金额
    }
    
    struct reciever{
        address raddr;//B方人地址
        bool yn;//是否投票        
        uint amount;//金额
    }
    
    address p1;
    address p2;
    mapping(address => giver) givers;
    mapping(address => reciever) recievers;
     
    
function initializeA(address giverA){
        // A方人初始化
        givers[giverA].amount = 1000 ether;
        givers[giverA].yn = true;
        p1 = giverA;
        givers[giverA].amount = 0 ether;
    }
    
    function initializeB(address recieverB){
        // B方人初始化
       recievers[recieverB].amount = 1000 ether;
       recievers[recieverB].yn = true;
       p2 = recieverB;
       recievers[recieverB].amount = 0 ether;
    }

uint  hedgevalue;
    
    function hedging1(uint exchangerate) returns (uint){
        hedgevalue = 1000 ether /exchangerate ;
        return  hedgevalue;
    }

bool success; function hedging2(uint exchangerate , uint time) returns(bool success){ if(time != 30) return false ; if(givers[p1].yn == false) return false; if(recievers[p2].yn == false) return false; givers[p1].amount = hedgevalue * exchangerate; recievers[p2].amount
 = 2000 ether - hedgevalue * exchangerate; return true ; } function checkA(address giverA)returns(uint){ if(success) givers[giverA].amount = givers[p1].amount ; else givers[giverA].amount = 1000 ether; return givers[giverA].amount; } function checkB(address
 recieverB)returns(uint){ if(success) recievers[recieverB].amount = recievers[p2].amount; else recievers[recieverB].amount = 1000 ether; return recievers[p2].amount; }}



以上是全部代码，接下来将慢慢分析；


struct giver{
        address gaddr;//A方人地址
        bool yn;//是否投票
        uint amount;//金额
    }
    
    struct reciever{
        address raddr;//B方人地址
        bool yn;//是否投票
        uint amount;//金额
    }
首先是确定进行交易的双方（包含地址，是否投票（默认为否），金额）

function initializeA(address giverA){
        // A方人初始化
        givers[giverA].amount = 1000 ether;
        givers[giverA].yn = true;
        p1 = giverA;
        givers[giverA].amount = 0 ether;
    }
    
    function initializeB(address recieverB){
        // B方人初始化
       recievers[recieverB].amount = 1000 ether;
       recievers[recieverB].yn = true;
       p2 = recieverB;
       recievers[recieverB].amount = 0 ether;
    }
然后对双方进行初始化，每个账户打入1000ether；然后确认交易后，bool改为true；第三部是将地址用一个storage保存起来方便以后调用，如果没有amount而使用balance，第四部转账可以只用msg.sender（准备下次实现），目前只有将amount变为0来表示将1000ether转入对冲基金（在现实生活中则有很高的风险，是明显不可取的）。


uint  hedgevalue;
    
    function hedging1(uint exchangerate) returns (uint){
        hedgevalue = 1000 ether /exchangerate ;
        return  hedgevalue;
    }
这一段是对冲的第一部，将1000ether根据汇率转换成其他货币；


 bool success;
    function hedging2(uint exchangerate , uint time) returns(bool success){
        if(time != 30) return false ;
        if(givers[p1].yn == false) return false;
        if(recievers[p2].yn == false) return false;
        givers[p1].amount = hedgevalue * exchangerate;
        recievers[p2].amount = 2000 ether - hedgevalue * exchangerate;
        return true ;
    }

接着便是对冲的第二部，30 天后再次转化回以太币；值得注意的是使用了bool以防交易失败；

最后两部则是确定双方交易后的金额；









值得提醒的是，在转换汇率的时候，我用的整型，这在现实中也是不可能的额



程序在可以在Remix上完成调试。