佛萨奇智能合约系统开发搭建流程

佛萨奇 Forsage智能合约是全球首创100%分散-以太坊营销共享矩阵计划，以太坊公链上开发的智能合约DAPP，佛萨奇 Forsage是革命性的智能合约技术，为分布式的市场参与者提供了直接从事个人和商业交易的能力、国际众筹平台。佛萨奇 Forsage分布式全球共享矩阵项目的智能合约是公开透明的，可以在区块链上查看，这样能够有效的预防黑客攻击智能合约、停止项目的风险。

佛萨奇 Forsage智能合约的特点：
1.以太坊公链上开发的智能合约DAPP；
2.全球首创以太坊100%分散共享矩阵计划；佛萨奇 Forsage是真实国际项目，全球参与；波比100%，零资金沉淀，零泡沫；
3.佛萨奇 Forsage智能合约无法篡改，公开透明；永不崩盘，永不关网，无人为操控；
4.佛萨奇 Forsage制度可享受被动收入，赚取的是全球第二大主流币—以太坊；
5.链上100%秒结进你自己的去中心化钱包
6.佛萨奇 Forsage智能合约在中国市场发展时间不长，市场相对广阔，未来可期。

此外，佛萨奇 Forsage智能合约能够简化复杂的合约，还能降低交易的成本，深受金融界和学术界的厚爱。

下面，就跟大家分享一下佛萨奇智能合约系统开发搭建的相关步骤。还不太清楚的小伙伴们，可以了解一下。

首先，打开ethereum-IDE，输入网址：http://remix.ethereum.org/。
其次，选择RUN模式 ；

然后，下拉菜单 选择JavaScript VM；

接着，复制下面佛萨奇 Forsage智能合约的代码及修改相关参数；

pragma solidity >=0.4.23 <0.6.0;//此处为版本号

contract SmartMatrixForsage {

struct User {
    uint id;
    address referrer;
    uint partnersCount;
    
    mapping(uint8 => bool) activeX3Levels;
    mapping(uint8 => bool) activeX6Levels;
    
    mapping(uint8 => X3) x3Matrix;
    mapping(uint8 => X6) x6Matrix;
}

struct X3 {
    address currentReferrer;
    address[] referrals;
    bool blocked;
    uint reinvestCount;
}

struct X6 {
    address currentReferrer;
    address[] firstLevelReferrals;
    address[] secondLevelReferrals;
    bool blocked;
    uint reinvestCount;

    address closedPart;
}

uint8 public constant LAST_LEVEL = 12;

mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances; 

uint public lastUserId = 2;
address public owner;

mapping(uint8 => uint) public levelPrice;

event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);


constructor(address ownerAddress) public {
    levelPrice[1] = 0.025 ether;
    for (uint8 i = 2; i <= LAST_LEVEL; i++) {
        levelPrice[i] = levelPrice[i-1] * 2;
    }
    
    owner = ownerAddress;
    
    User memory user = User({
        id: 1,
        referrer: address(0),
        partnersCount: uint(0)
    });
    
    users[ownerAddress] = user;
    idToAddress[1] = ownerAddress;
    
    for (uint8 i = 1; i <= LAST_LEVEL; i++) {
        users[ownerAddress].activeX3Levels[i] = true;
        users[ownerAddress].activeX6Levels[i] = true;
    }
    
    userIds[1] = ownerAddress;
}

function() external payable {
    if(msg.data.length == 0) {
        return registration(msg.sender, owner);
    }
    
    registration(msg.sender, bytesToAddress(msg.data));
}

function registrationExt(address referrerAddress) external payable {
    registration(msg.sender, referrerAddress);
}

function buyNewLevel(uint8 matrix, uint8 level) external payable {
    require(isUserExists(msg.sender), "user is not exists. Register first.");
    require(matrix == 1 || matrix == 2, "invalid matrix");
    require(msg.value == levelPrice[level], "invalid price");
    require(level > 1 && level <= LAST_LEVEL, "invalid level");

    if (matrix == 1) {
        require(!users[msg.sender].activeX3Levels[level], "level already activated");

        if (users[msg.sender].x3Matrix[level-1].blocked) {
            users[msg.sender].x3Matrix[level-1].blocked = false;
        }

        address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
        users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
        users[msg.sender].activeX3Levels[level] = true;
        updateX3Referrer(msg.sender, freeX3Referrer, level);
        
        emit Upgrade(msg.sender, freeX3Referrer, 1, level);

    } else {
        require(!users[msg.sender].activeX6Levels[level], "level already activated"); 

        if (users[msg.sender].x6Matrix[level-1].blocked) {
            users[msg.sender].x6Matrix[level-1].blocked = false;
        }

        address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
        
        users[msg.sender].activeX6Levels[level] = true;
        updateX6Referrer(msg.sender, freeX6Referrer, level);
        
        emit Upgrade(msg.sender, freeX6Referrer, 2, level);
    }
}    

function registration(address userAddress, address referrerAddress) private {
    require(msg.value == 0.05 ether, "registration cost 0.05");
    require(!isUserExists(userAddress), "user exists");
    require(isUserExists(referrerAddress), "referrer not exists");
    
    uint32 size;
    assembly {
        size := extcodesize(userAddress)
    }
    require(size == 0, "cannot be a contract");
    
    User memory user = User({
        id: lastUserId,
        referrer: referrerAddress,
        partnersCount: 0
    });
    
    users[userAddress] = user;
    idToAddress[lastUserId] = userAddress;
    
    users[userAddress].referrer = referrerAddress;
    
    users[userAddress].activeX3Levels[1] = true; 
    users[userAddress].activeX6Levels[1] = true;
    
    
    userIds[lastUserId] = userAddress;
    lastUserId++;
    
    users[referrerAddress].partnersCount++;

    address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
    users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
    updateX3Referrer(userAddress, freeX3Referrer, 1);

    updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
    
    emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}

function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
    (address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);

    if (!address(uint160(receiver)).send(levelPrice[level])) {
        return address(uint160(receiver)).transfer(address(this).balance);
    }
    
    if (isExtraDividends) {
        emit SentExtraEthDividends(_from, receiver, matrix, level);
    }
}

function bytesToAddress(bytes memory bys) private pure returns (address addr) {
    assembly {
        addr := mload(add(bys, 20))
    }
}

}

/**

最后，已经为大家描述得非常详细，目的是为了能让大家更好的了解佛萨奇Forsage智能合约系统开发搭建的相关步骤，想要了解接下来的相关详细步骤，Forsage系统源码分析，Forsage智能合约系统源码分析，Forsage智能合约系统开发，佛萨奇Forsage智能合约系统开发搭建。