佛萨奇2.0矩阵系统开发源码解析 - 广州天河珠江新城/跑马场软件开发

近，佛萨奇2.0确实【郑生：181-2191开发-3361系统】刷爆了朋友圈，那么很多人都还停在佛萨奇1.0的印象中，之所以会那么火，是因为其运用智能合约的技术，独特的矩阵制度，让很多人都参与其中，从而导致了很多人曾经的狂欢，如今2.0的问世，增加了不少的创新，尤其是原力元宇宙平台币和未来打造的NFT交易平台，足以引起业行业的浪潮，也会缔造成更多的财富神话。

　　那么佛萨奇2.0是什么呢？又有哪些改进呢？

　　也就是说佛萨奇FORGE原力项目基于马蹄莲MATIC开发的智能合约dapp，公开透明，100%公开开源，玩家进出都是usdt，没有套路，项目方也无法篡改，合约永续执行。

　　首先我们来看这张图。经典矩阵由两种财务模型组成，一种称为S3型矩阵，另一种称为S6型矩阵。所以很多伙伴都不懂什么是矩阵。其实很简单。矩阵是一个组织***。我们在早的直销中说过，太阳线或者双轨也是一种金融模式。那两种矩阵呢？他们分别是S3和S6。那就一个一个给你解释吧。让我们先来看看S3矩阵。它如何分配我们的财富？让我们来看看这张照片。首先，S3矩阵是由你下面的三个位置组成的，即一个位置和两个位置可以理解为你拿到钱的位置，即一个基金在你的之一个位置进来，你得到100%，另一个基金在你的第二个位置进来，你得到100%。然后，第三个位置进来，你就拿不到了。因为清了之后，有更多的资金进来，你就可以100%拿到1号2号位了。你能理解吗？那么在循环bit的同时，不可思议的是你也循环了自己的bit，那么如何循环呢？其实你已经把钱再投资了，那你去哪？我去找了你的上级推荐人。

　　所以我们总结一下，S3矩阵的意思是，你在1号位获得100%的资金，在2号位获得100%的资金，在3号位的资金进来之后，相当于你自己的仓位进行了一次重新投资，所有的仓位都被重置了，这就意味着你的仓位发生了变化，那么你下面的1号位和2号位都被清空了，有人进来的时候，你又可以获得1000。100%的收益，那么在S3矩阵中，你的金钱头寸只能来自于你自己的直接推荐，或者你的下属合伙人的另一个推荐，也就是说你的团队给你带来的收益。这是一个多劳多得的S3矩阵模型。

　　所以，伙伴，我们再来看看S6 matrix。这是Meta force中的第二个模型，叫做S6矩阵。S6矩阵呢，也就是下面的？它有六个要点。之一排的两个点去哪里？就是每次进来的资金涨，涨，你自己不拿，但是在二线。你的钱的之一、第二、第三个位置是100%，然后是100%或者100%，第二行的后一个位置叫循环位。无论是在S3矩阵还是S6矩阵中，所有循环比特都具有相同的含义。forsage佛萨奇系统代码部署教程如下：

　　pragma solidity 0.1.11;

　　contract MillionMoney{

　　address public ownerWallet;

　　MillionMoney public oldSC=MillionMoney;

　　uint oldSCUserId=1;

　　struct UserStruct{

　　bool isExist;

　　uint id;

　　uint referrerID;

　　address[]referral;

　　mapping(uint=>uint)levelExpired;

　　}

　　uint REFERRER_1_LEVEL_LIMIT=2;

　　uint PERIOD_LENGTH=100 days;

　　mapping(uint=>uint)public LEVEL_PRICE;

　　mapping(address=>UserStruct)public users;

　　mapping(uint=>address)public userList;

　　uint public currUserID=0;

　　event regLevelEvent(address indexed _user,address indexed _referrer,uint _time);

　　event buyLevelEvent(address indexed _user,uint _level,uint _time);

　　event prolongateLevelEvent(address indexed _user,uint _level,uint _time);

　　event getMoneyForLevelEvent(address indexed _user,address indexed _referral,uint _level,uint _time);

　　event lostMoneyForLevelEvent(address indexed _user,address indexed _referral,uint _level,uint _time);

　　constructor()public{

　　ownerWallet=msg.sender;

　　LEVEL_PRICE[1]=0.03 ether;

　　LEVEL_PRICE[2]=0.01 ether;

　　LEVEL_PRICE[3]=0.1 ether;

　　LEVEL_PRICE[4]=0.4 ether;

　　LEVEL_PRICE[1]=1 ether;

　　LEVEL_PRICE[6]=2.1 ether;

　　LEVEL_PRICE[7]=1 ether;

　　LEVEL_PRICE[8]=10 ether;

　　LEVEL_PRICE[9]=20 ether;

　　LEVEL_PRICE[10]=40 ether;

　　UserStruct memory userStruct;

　　currUserID++;

　　userStruct=UserStruct({

　　isExist:true,

　　id:currUserID,

　　referrerID:0,

　　referral:new address[](0)

　　});

　　users[ownerWallet]=userStruct;

　　userList[currUserID]=ownerWallet;

　　for(uint i=1;i<=10;i++){

　　users[ownerWallet].levelExpired=111111;

　　}

　　}

　　function()external payable{

　　uint level;

　　if(msg.value==LEVEL_PRICE[1])level=1;

　　else if(msg.value==LEVEL_PRICE[2])level=2;

　　else if(msg.value==LEVEL_PRICE[3])level=3;

　　else if(msg.value==LEVEL_PRICE[4])level=4;

　　else if(msg.value==LEVEL_PRICE[1])level=1;

　　else if(msg.value==LEVEL_PRICE[6])level=6;

　　else if(msg.value==LEVEL_PRICE[7])level=7;

　　else if(msg.value==LEVEL_PRICE[8])level=8;

　　else if(msg.value==LEVEL_PRICE[9])level=9;

　　else if(msg.value==LEVEL_PRICE[10])level=10;

　　else revert('Incorrect Value send');

　　if(users[msg.sender].isExist)buyLevel(level);

　　else if(level==1){

　　uint refId=0;

　　address referrer=bytesToAddress(msg.data);

　　if(users[referrer].isExist)refId=users[referrer].id;

　　else revert('Incorrect referrer');

　　regUser(refId);

　　}

　　else revert('Please buy first level for 0.03 ETH');

　　}

　　function regUser(uint _referrerID)public payable{

　　require(address(oldSC)==address(0),'Initialize not finished');

　　require(!users[msg.sender].isExist,'User exist');

　　require(_referrerID>0&&_referrerID<=currUserID,'Incorrect referrer Id');

　　require(msg.value==LEVEL_PRICE[1],'Incorrect Value');

　　if(users[userList[_referrerID]].referral.length>=REFERRER_1_LEVEL_LIMIT)_referrerID=users[findFreeReferrer(userList[_referrerID])].id;

　　UserStruct memory userStruct;

　　currUserID++;

　　userStruct=UserStruct({

　　isExist:true,

　　id:currUserID,

　　referrerID:_referrerID,

　　referral:new address[](0)

　　});

　　users[msg.sender]=userStruct;

　　userList[currUserID]=msg.sender;

　　users[msg.sender].levelExpired[1]=now+PERIOD_LENGTH;

　　users[userList[_referrerID]].referral.push(msg.sender);

　　payForLevel(1,msg.sender);

　　emit regLevelEvent(msg.sender,userList[_referrerID],now);

　　}

　　function buyLevel(uint _level)public payable{

　　require(users[msg.sender].isExist,'User not exist');

　　require(_level>0&&_level<=10,'Incorrect level');

　　if(_level==1){

　　require(msg.value==LEVEL_PRICE[1],'Incorrect Value');

　　users[msg.sender].levelExpired[1]+=PERIOD_LENGTH;

　　}

　　else{

　　require(msg.value==LEVEL_PRICE[_level],'Incorrect Value');

　　for(uint l=_level-1;l>0;l--)require(users[msg.sender].levelExpired[l]>=now,'Buy the previous level');

　　if(users[msg.sender].levelExpired[_level]==0)users[msg.sender].levelExpired[_level]=now+PERIOD_LENGTH;

　　else users[msg.sender].levelExpired[_level]+=PERIOD_LENGTH;

　　}

　　payForLevel(_level,msg.sender);

　　emit buyLevelEvent(msg.sender,_level,now);

　　}

　　function syncWithOldSC(uint limit)public{

　　require(address(oldSC)!=address(0),'Initialize closed');

　　require(msg.sender==ownerWallet,'Access denied');

　　for(uint i=0;i<limit;i++){

　　address user=oldSC.userList(oldSCUserId);

　　(bool isExist,,uint referrerID)=oldSC.users(user);

　　if(isExist){

　　oldSCUserId++;

　　address ref=oldSC.userList(referrerID);

　　if(!users[user].isExist&&users[ref].isExist){

　　users[user].isExist=true;

　　users[user].id=++currUserID;

　　users[user].referrerID=users[ref].id;

　　userList[currUserID]=user;

　　users[ref].referral.push(user);

　　for(uint j=1;j<=8;j++){

　　users[user].levelExpired[j]=oldSC.viewUserLevelExpired(user,j);

　　}

　　emit regLevelEvent(user,ref,block.timestamp);

　　}

　　}

　　else break;

　　}

　　}

　　function syncClose()external{

　　require(address(oldSC)!=address(0),'Initialize already closed');

　　require(msg.sender==ownerWallet,'Access denied');

　　oldSC=MillionMoney(0);

　　}

　　function payForLevel(uint _level,address _user)internal{

　　address referer;

　　address referer1;

　　address referer2;

　　address referer3;

　　address referer4;

　　if(_level==1||_level==6){

　　referer=userList[users[_user].referrerID];

　　}

　　else if(_level==2||_level==7){

　　referer1=userList[users[_user].referrerID];

　　referer=userList[users[referer1].referrerID];

　　}

　　else if(_level==3||_level==8){

　　referer1=userList[users[_user].referrerID];

　　referer2=userList[users[referer1].referrerID];

　　referer=userList[users[referer2].referrerID];

　　}

　　else if(_level==4||_level==9){

　　referer1=userList[users[_user].referrerID];

　　referer2=userList[users[referer1].referrerID];

　　referer3=userList[users[referer2].referrerID];

　　referer=userList[users[referer3].referrerID];

　　}

　　else if(_level==1||_level==10){

　　referer1=userList[users[_user].referrerID];

　　referer2=userList[users[referer1].referrerID];

　　referer3=userList[users[referer2].referrerID];

　　referer4=userList[users[referer3].referrerID];

　　referer=userList[users[referer4].referrerID];

　　}

　　if(!users[referer].isExist)referer=userList[1];

　　bool sent=false;

　　if(users[referer].levelExpired[_level]>=now){

　　sent=address(uint160(referer)).send(LEVEL_PRICE[_level]);

　　if(sent){

　　emit getMoneyForLevelEvent(referer,msg.sender,_level,now);

　　}

　　}

　　if(!sent){

　　emit lostMoneyForLevelEvent(referer,msg.sender,_level,now);

　　payForLevel(_level,referer);

　　}

　　}

　　function findFreeReferrer(address _user)public view returns(address){

　　if(users[_user].referral.length<REFERRER_1_LEVEL_LIMIT)return _user;

　　address[]memory referrals=new address[](126);

　　referrals[0]=users[_user].referral[0];

　　referrals[1]=users[_user].referral[1];

　　address freeReferrer;

　　bool noFreeReferrer=true;

　　for(uint i=0;i<126;i++){

　　if(users[referrals].referral.length==REFERRER_1_LEVEL_LIMIT){

　　if(i<62){

　　referrals[(i+1)*2]=users[referrals].referral[0];

　　referrals[(i+1)*2+1]=users[referrals].referral[1];

　　}

　　}

　　else{

　　noFreeReferrer=false;

　　freeReferrer=referrals;

　　break;

　　}

　　}

　　require(!noFreeReferrer,'No Free Referrer');

　　return freeReferrer;

　　}

　　function viewUserReferral(address _user)public view returns(address[]memory){

　　return users[_user].referral;

　　}

　　function viewUserLevelExpired(address _user,uint _level)public view returns(uint){

　　return users[_user].levelExpired[_level];

　　}

　　function bytesToAddress(bytes memory bys)private pure returns(address addr){

　　assembly{

　　addr:=mload(add(bys,20))

　　}

　　}

　　}