以太坊众筹DAPP实战（一）

一、业务分析

（1）角色分配

管理员：发起众筹。

参与者：参与众筹。

（2）业务介绍

由管理员发起众筹 。

所有人都可以参与众筹。

如果在指定时间内筹到目标金额，则众筹结束，参与人获得超值产品。

如果没有在指定时间内筹到目标金额，平台自动把筹到的资金退还给所有参与者。

（3）项目意义

区块链众筹平台能够保证资金安全性，防止众筹方跑路或不作为。项目方筹到的钱不会被拿走，而是一直放在众筹合约中，项目方如果想花费一笔支出，需要提出申请，由所有参与人共同投票决定是否允许花费该笔费用。

（4）项目界面截图

二、编写智能合约

（1）定义合约属性：管理员、项目名、筹集金额、平均支持金额、项目结束时间、参与者。

pragma solidity 0.4.24;

contract Funding {
    // 管理员
    address public manager; 
    // 项目名
    string public projectName;
    // 筹集金额
    uint256 public targetMoney;
    // 平均支持的金额
    uint256 public supportMoney;
    // 项目结束时间,单位秒
    uint256 public endTime;
    // 参与者
    address[] investors;
    
    constructor(string _projectName, uint256 _targetMoney, uint256 _supportMoney, uint256 duration) public {
        manager = msg.sender;
        projectName = _projectName;
        targetMoney = _targetMoney * 10**18;
        supportMoney = _supportMoney * 10**18;
        // 合约创建时间 + 持续时间 = 结束时间
        endTime = now + duration;
    }
｝

（2）定义一些基本的方法。

// 参与众筹
function invest() public payable returns(uint256) {
    require(msg.value == supportMoney);
    investors.push(msg.sender);
}

// 获取筹集到的金额
function getBalance() public view returns(uint256) {
    return address(this).balance;
}
    
// 获取所有参与者
function getInvestors() public view returns(address[]) {
   return investors;
}
    
// 退款
function refund() public {
    // 遍历每一个参与者，执行转账操作
    for (uint256 i = 0; i < investors.length; i++) {
        investors[i].transfer(supportMoney);
    }
    // 清空数组
    delete investors;
}

（3）定义花费请求结构体

如果众筹成功，就代表项目启动了。那么众筹方要花费资金的时候，就要向所有参与者发起请求，只有得到50%以上的参与者同意后，才能够花费合约中的资金。

所以，这里我们定义一个结构体，保存请求申请的信息。结构体应该包含以下信息：

1）用途：买什么

2）需要花费的金额

3）商家地址：向谁购买

4）当前已经赞成的票数：多少参与者赞成，只有超过半数才允许花费

5）当前花费申请的状态：完成（已经花费）、待批准（超过半数赞成）、待执行（发起花费请求时候）6）标记投过票的参与者，防止参与者重复投票

// 花费申请的状态，0：进行中，1：已批准，2：已完成
enum RequestStatus {
    Voting, Approved, Completed
}

// 记录请求申请的信息
struct Request {
    // 花费申请的目的
    string purpose;
    // 所需金额
    uint256 cost;
    // 商家地址
    address seller;
    // 以赞成的票数
    uint256 approveCount;
    // 申请状态
    RequestStatus status;
    // 记录参与者的投票状态，true代表已经投过，false代表还没投票
    mapping(address=>bool) isVotedMap;
}

（4）发起请求申请

第一步：定义一个Request类型的数组，记录所有发起过的支出申请。

// 记录所有的请求申请
Request[] requests;

第二步：定义发起申请的方法。

// 发起请求申请
function createRequest(string _purpose, uint256 _cost, address _seller) public {
    Request memory req = Request({
        purpose : _purpose,
        cost : _cost * 10**18,
        seller : _seller,
        approveCount : 0,
        status : RequestStatus.Voting
    });
    requests.push(req);
}

（5）批准申请

项目发起方发起申请后，由所有参与者进行投票。如果不支持则无序理会。如果支持，则需要执行赞成动作。

执行批准申请的时候，对Request结构体的修改有：

1）approveCount加1。

2）将投票人记录到isVotedMap中，并指定Value为true。

// 批准请求
// 参数i：第几个请求申请
function approveRequest(uint256 i) public {
    Request storage req = requests[i];
    // 赞成票数加1
    req.approveCount++;
    // 记录该用户已经投票
    req.isVotedMap[msg.sender] = true;
}

校验投票者是否有资格投票。只有满足以下两个条件才允许投票：

1）没有投过票

2）必须是投资者

为了能够识别是否是投资者，这里定义一个mapping记录投资人的地址，方便判断一个地址是否是投资人的地址。然后在invest方法中把当前投资者添加到该mapping集合中。

 // 定义一个mapping，记录投资人的地址，方便判断一个地址是否是投资人的地址。
mapping(address=>bool) isInvestorMap;
    
// 参与众筹
function invest() public payable returns(uint256) {
    ...
    isInvestorMap[msg.sender] = true;
}

在approveRequest方法中添加检验代码。

function approveRequest(uint256 i) public {
    // 检查用户时候已经投票
    require(req.isVotedMap[msg.sender] == false);
    // 检查是否是投资人，只有投资人才有权投票
    require(isInvestorMap[msg.sender] == true);
    ...
}

（6）完成花费请求

完成花费请求必须满足以下两个条件：

1）赞成票数过半

2）账户余额必须大于花费申请的金额

// 完成花费申请
function finalizeRequest(uint256 i) public {
    Request storage req = requests[i];
    // 检查余额是否足够
    require(address(this).balance >= req.cost);
    // 检查赞成票数是否过半
    require(req.approveCount * 2 > investors.length);
    // 转账给商家
    req.seller.transfer(req.cost);
    // 更新请求申请的状态为已完成
    req.status = RequestStatus.Completed;
}

（7）增加权限控制

有三个函数只有项目发起人才允许操作：refund（退款）、createRequest（花费申请）、finalizeRequest（完成花费）。这里我们使用修饰器进行限定。

第一步：定义修饰器。

modifier onlyManager {
    require(msg.sender == manager);
    _;
}

第二步：在方法定义上使用修饰器。

// 退款
function refund() onlyManager  public {...}

// 发起请求申请
function createRequest(string _purpose, uint256 _cost, address _seller) onlyManager public {...}

// 完成花费申请
function finalizeRequest(uint256 i) onlyManager  public {...}

（8）定义辅助函数

getLeftTime：返回众筹剩余时间，以秒为单位。now用于获取当前系统的时间戳。

getInvestorCount()：返回投资人的数量。

getRequestCount()：返回请求申请的数量。

getRequest(uint256 i)：返回指定请求申请的详细信息。

// 返回众筹剩余时间，以秒为单位
function getLeftTime() public view returns(uint256) {
    return endTime - now;
}
    
// 返回投资人的数量
function getInvestorCount() public view returns(uint256) {
    return investors.length;
}
    
// 返回请求申请的数量
function getRequestCount() public view returns(uint256) {
    return requests.length;
}
    
// 返回指定Request的信息
function getRequest(uint256 i) public view returns(string, uint256, address, uint256, RequestStatus) {
    Request memory req = requests[i];
    return (req.purpose, req.cost, req.seller, req.approveCount, req.status);
}

 

三、创建合约工厂

当发起众筹时候，系统会创建一个合约实例。因为每个人都可以发起众筹，所以可能会创建许多合约实例。为了方便管理这些合约实例，这里我们使用工厂设计模式，对合约进行管理。

（1）定义工厂合约，工厂合约的内容包含有：

平台管理员：address platformManager

所有众筹合约的集合：address[] allFundings

自己创建的合约集合：mapping(address=>address[]) creatorFundings（key代表创建人地址，value代表该创建人创建合约的地址集合）

参与过的合约集合：mapping(address=>address[]) supportFundings（key代表参与者地址，value代表该参与者参与的合约地址集合）

pragma solidity 0.4.24;
import "./funding.sol";

contract FundingFactory {
    // 平台管理员
    address platformManager;
    // 所有众筹合约的集合
    address[] allFundings;
    // 自己创建的合约集合
    mapping(address=>address[]) creatorFundings;
    // 参与过的合约集合：
    mapping(address=>address[]) supportFundings;
    
    constructor() public {
        platformManager = msg.sender;
    }
    
}

（2）定义创建众筹合约的方法

createFunding(string _name, uint256 _targetMoney, uint256 _supportMoney, uint256 _duration)：

参数一：花费的目的

参数二：需要多少钱

参数三：平均支持的金额

参数四：持续时间，以秒为单位

// 创建众筹合约
function createFunding(string _name, uint256 _targetMoney, uint256 _supportMoney, uint256 _duration) public {
    address funding = new Funding(_name, _targetMoney, _supportMoney, _duration);
    allFundings.push(funding);
    creatorFundings[msg.sender].push(funding);
}

（3）定义辅助函数

// 获取所有众筹合约
function getAllFundings() public view returns(address[]) {
    return allFundings;
}
    
// 获取创建者的众筹合约
function getCreatorFunding() public view returns(address[]) {
    return creatorFundings[msg.sender];
}

// 获取用户参与过的众筹
function getSupportorFunding() public view returns(address[]) {
    return supportFundings[msg.sender];
}

注意：定义好工厂合约之后，就不要直接创建合约实例，而是通过FundingFactory的createFunding函数创建合约实例。

（4）把msg.sender给Funding实例。

当FundingFactory创建合约实例的时候，传递给Funding构造函数的msg.sender是FundingFactory，而不是真正项目发起者。所以，在创建Funding实例的时候，需要将项目发起人传递给Funding构造函数。

// 创建众筹合约
function createFunding(string _name, uint256 _targetMoney, uint256 _supportMoney, uint256 _duration) public {
        address funding = new Funding(_name, _targetMoney, _supportMoney, _duration, msg.sender);
    ...
}

修改Funding构造函数，增加项目发起人参数creator。

constructor(string _projectName, uint256 _targetMoney, uint256 _supportMoney, uint256 duration, address creator) public {
    // manager = msg.sender;
    manager = creator;
    ...
}

（5）我参与的合约

当执行invest()方法的时候，需要把参与众筹的合约地址保存在FundingFactory的supportFundings中。由于solidity不支持在函数参数中定义复杂类型，所以我们无法直接把supportFundings变量传给invest方法。这里我们创建一个临时合约，该合约维护了所有参与者参与过的众筹合约。

// 该合约维护了所有参与者所参与过的众筹合约
contract SupportFunding {
    // 参与过的合约集合：
    mapping(address=>address[]) supportFundingsMap;
    
    // 添加合约到集合
    function setFunding(address _supportor, address _funding) public {
        supportFundingsMap[_supportor].push(_funding);
    }
    
    // 读取合约数据
    function getFundings(address _supportor) public view returns(address[]) {
        return supportFundingsMap[_supportor];
    }
    
}

由于在SupportFunding中临时维护了用户参与过的合约集合，所以在FundingFactory中就不需要再维护supportFundings集合，这里我们把它注释掉，然后添加SupportFunding状态变量，并且在构造函数中进行实例化。

// mapping(address=>address[]) supportFundings;
SupportFunding supportFunding;

constructor() public {
    platformManager = msg.sender;
    supportFunding = new SupportFunding(); 
}

修改getSupportorFunding函数，改为调用SupportFunding的getFundings方法获取用户参与过的众筹合约。

// 获取用户参与过的众筹
function getSupportorFunding() public view returns(address[]) {
    return supportFunding.getFundings(msg.sender);
}

修改createFunding函数，在创建Funding实例的时候把supportFunding状态变量传递到Funnding合约中。

// 创建众筹合约
function createFunding(string _name, uint256 _targetMoney, uint256 _supportMoney, uint256 _duration) public {
    address funding = new Funding(_name, _targetMoney, _supportMoney, _duration, msg.sender, supportFunding);
    ...
}

同样地，在Funding合约的构造函数中添加SupportFunding类型参数，用于接收上面传递过来的supportFunding状态变量数据。

SupportFunding supportFunding;

constructor(string _projectName, uint256 _targetMoney, uint256 _supportMoney, uint256 _duration, address _creator, SupportFunding _supportFunding) public {
    ...
    supportFunding = _supportFunding;
}

修改invest方法，调用supportFunding对象的setFunding方法，保存用户参与过的众筹合约。

// 参与众筹
function invest() public payable returns(uint256) {
    ...
    // 保存用户参与过的众筹
    supportFunding.setFunding(msg.sender, this);
}

至此，众筹的智能合约已经开发完毕！！！