Forsage系統源代碼下載Forsage智能合約代碼分享


Forsage是一個永久存在的且無法被任何實體修改或關閉的智能合約,一旦部署Forsage智能合約,這個智能合約永久存在互聯網上,任何人都無法修改。

以下是Forsage系統部分核心源代碼分享給大家,Forsage智能合約核心代碼分析見下

pragma solidity >=0.4.23 <0.6.0;

// 合約名稱:智能矩陣【為智者】
contract SmartMatrixForsage {

    // 用戶
    struct User {
        uint id; // 用戶ID
        address referrer; // 推薦人地址
        uint partnersCount; // 團隊總人數

        mapping(uint8 => bool) activeX3Levels; // X3模塊:記錄X3點位是否開通
        mapping(uint8 => bool) activeX6Levels; // X6模塊:記錄X6點位是否開通

        mapping(uint8 => X3) x3Matrix; // 對應X3的12個矩陣
        mapping(uint8 => X6) x6Matrix; // 對應X6的12個矩陣
    }

    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; // 定義每模塊矩陣個數為12個

    mapping(address => User) public users; // 所有用戶數據:地址——>用戶數據
    mapping(uint => address) public idToAddress; // 所有ID數據:ID——>地址
    mapping(uint => address) public userIds; // 
    mapping(address => uint) public balances; // 所有地址數據:地址——>余額

    uint public lastUserId = 2; // 最新的ID,目前為2
    address public owner; // 合約擁有者地址

    mapping(uint8 => uint) public levelPrice; // 矩陣價格:矩陣位數——>激活矩陣的價格

    // 以下event為事件,意思是當用戶觸發了某些條件的時候,合約就會給用戶發送一些數據,這里也可以理解為給用戶發送消息
    // 注冊消息:發送用戶地址、用戶推薦人地址、用戶ID、推薦人ID
    event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
    // 復投消息:用戶地址、用戶當前推薦人地址、調用者、矩陣模塊(X3 or X6)、矩陣等級
    event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
    // 矩陣升級(激活)消息:用戶地址、用戶推薦人地址、矩陣模塊(X3 or X6)、矩陣等級
    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);
    // 燒傷消息:接收者地址、點位來源地址、矩陣模塊(X3 or X6)、矩陣等級
    event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
    // 發送ETH消息:ETH來源地址、ETH接收者地址、矩陣模塊(X3 or X6)、矩陣等級
    event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);


    // 構造函數:合約剛開始部署到以太坊上需要首先輸入的內容——>傳入創始人地址,之后無法修改
    // 創始人就是合約擁有者,這里為了方便大家觀看,以下我就說創始人
    constructor(address ownerAddress) public {
        // 第一個矩陣價格:0.025以太幣
        levelPrice[1] = 0.025 ether;
        // 第二個矩陣的價格是前一個矩陣的兩倍,一共12矩陣,循環計算11次
        for (uint8 i = 2; i <= LAST_LEVEL; i++) {
            levelPrice[i] = levelPrice[i-1] * 2;
        }

        // 記錄創始人
        owner = ownerAddress;

        // 把創始人定義為ID為1的用戶
        User memory user = User({
            id: 1, // ID為1
            referrer: address(0), // 推薦人為空
            partnersCount: uint(0) // 團隊成員目前為0
            });

        // 把創始人記到用戶總冊里
        users[ownerAddress] = user;
        // 把創始人記到ID總冊里
        idToAddress[1] = ownerAddress;

        // 創始人的X3、X6的所有矩陣全部開通,沒有花錢
        for (uint8 i = 1; i <= LAST_LEVEL; i++) {
            users[ownerAddress].activeX3Levels[i] = true;
            users[ownerAddress].activeX6Levels[i] = true;
        }

        // 用戶ID為1的記錄為創始人
        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);
    }

    // 購買新的矩陣等級:輸入X3 或 X6模塊,矩陣等級序列
    function buyNewLevel(uint8 matrix, uint8 level) external payable {
        // 調用者必須是激活用戶
        require(isUserExists(msg.sender), "user is not exists. Register first.");
        // 必須選擇X3 或 X6矩陣
        require(matrix == 1 || matrix == 2, "invalid matrix");
        // 購買價格必須符合等級對應要求
        require(msg.value == levelPrice[level], "invalid price");
        // 1 < 已開通矩陣等級必須小於 < 12
        require(level > 1 && level <= LAST_LEVEL, "invalid level");

        // 選擇購買的是X3模塊
        if (matrix == 1) {
            // 用戶X3對應的矩陣必須是未激活狀態
            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);

            // 將實際推薦人填入用戶的X3對應矩陣的推薦人地址中
            users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;

            // 激活用戶對應X3矩陣
            users[msg.sender].activeX3Levels[level] = true;

            // 更新實際推薦人的X3矩陣
            updateX3Referrer(msg.sender, freeX3Referrer, level);

            // 發送升級消息:用戶地址、實際推薦人地址、X3模塊、對應等級
            emit Upgrade(msg.sender, freeX3Referrer, 1, level);

        // 選擇購買的是X6矩陣
        } else {
            // 用戶X6對應的矩陣必須是未激活狀態
            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);

            // 激活用戶對應X6矩陣
            users[msg.sender].activeX6Levels[level] = true;

            // 更新實際推薦人的X6矩陣
            updateX6Referrer(msg.sender, freeX6Referrer, level);

            // 發送升級消息:用戶地址、實際推薦人地址、X6模塊、對應等級
            emit Upgrade(msg.sender, freeX6Referrer, 2, level);
        }
    }

    // 新用戶注冊:新用戶地址、推薦人地址
    function registration(address userAddress, address referrerAddress) private {
        // 注冊必須有0.05個ETH(不含手續費),否則出錯
        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)
        }
        // 如果長度(大小)為0,出錯
        require(size == 0, "cannot be a contract");

        // 創建新用戶對象
        User memory user = User({
            id: lastUserId, // 新用戶的ID為最新ID
            referrer: referrerAddress, // 推薦人地址為傳入的推薦人地址
            partnersCount: 0 // 團隊人數為0
            });

        users[userAddress] = user; // 保存新用戶數據:新用戶地址——>新用戶數據
        idToAddress[lastUserId] = userAddress; // 新用戶ID——>新用戶地址

        // 再記錄一次新用戶的推薦人地址
        users[userAddress].referrer = referrerAddress;

        // 激活(打開)X3和X6第一個矩陣
        users[userAddress].activeX3Levels[1] = true;
        users[userAddress].activeX6Levels[1] = true;

        // 把新用戶地址記錄到ID總冊里,然后最新的ID+1,等待下一個新用戶
        userIds[lastUserId] = userAddress;
        lastUserId++;

        // 推薦人的團隊人數+1
        users[referrerAddress].partnersCount++;

        // 確認X3推薦人地址,如果是前兩個點位,就是直推人地址;如果是第三個點位,就是直推人的推薦人地址;如果推薦人是創始人,ID為1,那第三個點位的推薦人還是創始人
        // 傳入 新用戶地址,X3模塊
        address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
        // 將確認到的X3推薦人地址填入新用戶X3第一個矩陣的推薦人地址中
        users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
        // 升級推薦人X3的第一個矩陣
        updateX3Referrer(userAddress, freeX3Referrer, 1);

        // 升級推薦人X6的第一個矩陣
        updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
                // 發送注冊消息:新用戶地址、推薦人地址、用戶ID、用戶推薦人ID
        emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
    }

    function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
        // 將當前用戶地址填入推薦人X3矩陣下面
        users[referrerAddress].x3Matrix[level].referrals.push(userAddress);

        // 如果用戶地址放入推薦人X3點位下之后,推薦人的X3矩陣點位小於3
        if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
            // 提交用戶占據推薦人X3點位的消息:用戶地址、推薦人地址、X3模塊、哪個等級矩陣、放入推薦人X3矩陣的哪個點位(第一或者第二)
            emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
            // 發送對應X3等級的ETH給推薦人
            return sendETHDividends(referrerAddress, userAddress, 1, level);
        }

        // 如果如果用戶地址放入推薦人X3點位下之后,推薦人的X3矩陣點位>=3
        // 則發送用戶占領推薦人X3的第三個點位的消息:用戶地址、推薦人地址、點位信息
        emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);

        // 當推薦者的X3矩陣點位滿了之后,就要把當前這個矩陣關閉
        // 清空對應矩陣下的點位地址
        users[referrerAddress].x3Matrix[level].referrals = new address[](0);
        // 如果推薦人的之后的矩陣未激活並且當前矩陣不是最后一個矩陣,那么該推薦人此矩陣之后的收益取消
        if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
            // 將推薦人的X3最后一級矩陣阻塞,之后不會再有收益,除非激活下一個矩陣直至全部激活
            users[referrerAddress].x3Matrix[level].blocked = true;
        }

        // 創建新的矩陣
        // 如果推薦人的地址不是創始人
        if (referrerAddress != owner) {
            // 首先檢查推薦人X3模塊下對應矩陣是否激活,並獲取對應正確的【推薦人的推薦人】地址,該步驟是第三個點位向上滑落,找到最終滑落的地點,最后找到的地址我稱為實際推薦人
            address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
            // 如果獲取到的實際推薦人地址不是【推薦人的推薦人】地址,
            if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
                // 則把該推薦人的推薦人地址記錄為實際推薦人
                users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
            }

            // 推薦人該矩陣的團隊成員數量+1
            users[referrerAddress].x3Matrix[level].reinvestCount++;
            // 發送復投消息:推薦人地址、實際推薦人地址、用戶地址、X3模塊、對應級別
            emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
            // 然后拿着推薦人地址、和獲取到的實際推薦人地址、對應矩陣等級再把這個流程走一遍,因為這些步驟是查找真正存放新用戶點位的上級地址,還沒有轉賬;
            // 直到找到矩陣點數不滿2個不需要升級的上級,然后轉賬,新用戶的X3才結束
            updateX3Referrer(referrerAddress, freeReferrerAddress, level);
        } else {
            // 如果是創始人直推的用戶,創始人X3點位滿三個,ETH都是直接打入創始人地址。
            sendETHDividends(owner, userAddress, 1, level);
            // 創始人X3對應矩陣復投次數+1
            users[owner].x3Matrix[level].reinvestCount++;
            // 發送創始人復投的消息:創始人地址、推薦人地址為空、調用者地址、X3模塊、矩陣對應的等級
            emit Reinvest(owner, address(0), userAddress, 1, level);
        }
    }

    // 升級推薦人的X6矩陣:傳入用戶地址、實際推薦人地址、對應矩陣等級
    function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
        // 推薦人X6對應矩陣必須為激活狀態,否則出錯
        require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");

        // 判斷推薦人X6第一層級是否還有空位
        if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
            // 如果還有空位,則將用戶地址填入
            users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
            // 發送用戶位置信息:用戶地址、推薦人地址、X6模塊、對應矩陣等級、放在第一層級的哪個位置
            emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));

            // 將實際推薦人地址填入用戶X6的對應矩陣的推薦人位置中
            users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;

            // 如果推薦人為創始人
            if (referrerAddress == owner) {
                // 直接把ETH轉入創始人地址中
                return sendETHDividends(referrerAddress, userAddress, 2, level);
            }

            // 拿出【推薦人的推薦人】地址,我這里稱為【二級推薦人】
            address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
            // 將用戶地址填入二級推薦人的第二層級地位中
            users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);

            // 拿出二級推薦人的第一層級的已有點位個數
            uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;

            // 如果二級推薦人第一層級點位已滿,並且兩個點位都是推薦人的地址
            if ((len == 2) &&
            (users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
                (users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
                // 如果推薦人的第一層級只有一個點位
                if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
                    // 提交用戶位置信息:用戶地址、二級推薦人、X6模塊、對應矩陣等級、第5位置
                    emit NewUserPlace(userAddress, ref, 2, level, 5);
                } else {
                    // 如果推薦人的第一層級點位滿了
                    // 提交用戶位置信息:用戶地址、二級推薦人、X6模塊、對應矩陣等級、第6位置
                    emit NewUserPlace(userAddress, ref, 2, level, 6);
                }

            // 如果二級推薦人第一層級點位已有1個或者2個,並且推薦人為第一個點位地址
            }  else if ((len == 1 || len == 2) &&
            users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
                // 如果推薦人的第一層級只有一個點位
                if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
                    // 提交用戶位置信息:用戶地址、二級推薦人、X6模塊、對應矩陣等級、第3位置
                    emit NewUserPlace(userAddress, ref, 2, level, 3);
                } else {
                    // 如果推薦人的第一層級點位滿了
                    // 提交用戶位置信息:用戶地址、二級推薦人、X6模塊、對應矩陣等級、第4位置
                    emit NewUserPlace(userAddress, ref, 2, level, 4);
                }
            // // 如果二級推薦人第一層級點位已滿,並且推薦人為第二個點位地址
            } else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
                // 如果推薦人的第一層級只有一個點位
                if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
                    // 提交用戶位置信息:用戶地址、二級推薦人、X6模塊、對應矩陣等級、第5位置
                    emit NewUserPlace(userAddress, ref, 2, level, 5);
                } else {
                    // 如果推薦人的第一層級點位滿了
                    // 提交用戶位置信息:用戶地址、二級推薦人、X6模塊、對應矩陣等級、第6位置
                    emit NewUserPlace(userAddress, ref, 2, level, 6);
                }
            }

            // 然后升級二級推薦人X6第二層級矩陣:傳入用戶地址、二級推薦人地址、矩陣級別
            return updateX6ReferrerSecondLevel(userAddress, ref, level);
        }

        // 推薦人X6第一層級已經沒有空位,將新用戶地址放入推薦人的第二層級的點位里
        users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);

        // 當推薦人的封鎖區域里面有地址時
        if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
            // 當推薦人第一層級的兩個點位地址都一樣,並且第一個點位地址和封鎖區域地址一樣時
            if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
            users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
                (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
                users[referrerAddress].x6Matrix[level].closedPart)) {

                // 更新X6矩陣
                updateX6(userAddress, referrerAddress, level, true);
                // 更新推薦人X6第二層級矩陣
                return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);

            // 當推薦人第一層級的第一點位與推薦人的封鎖區域地址一樣時
            } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
                users[referrerAddress].x6Matrix[level].closedPart) {
                // 更新X6矩陣
                updateX6(userAddress, referrerAddress, level, true);
                // 更新推薦人X6第二層級矩陣
                return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);

            // 其他原因
            } else {
                // 更新X6矩陣
                updateX6(userAddress, referrerAddress, level, false);
                // 更新推薦人X6第二層級矩陣
                return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
            }
        }

    // 當推薦人的封鎖區域里面沒有地址時
    // 當用戶放在推薦人第一層級第二點位時
    if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
            // 更新X6矩陣
            updateX6(userAddress, referrerAddress, level, false);
            // 更新推薦人X6第二層級矩陣
            return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);

        // 當用戶放在推薦人第一層級第一點位時
        } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
        // 更新X6矩陣
            updateX6(userAddress, referrerAddress, level, true);
        // 更新推薦人X6第二層級矩陣
            return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
        }

    // 當推薦者第一層級的第一個點位的第一層級的點位數量小於等於第二個點位的第一層級的點位數量
    if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
            users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
            // 更新X6矩陣
            updateX6(userAddress, referrerAddress, level, false);
        } else {
            // 更新X6矩陣
            updateX6(userAddress, referrerAddress, level, true);
        }
        // 更新推薦人X6第二層級矩陣
        updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
    }

    // 此時推薦人第一層級已滿
    function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
        if (!x2) {
            // 將用戶地址填入推薦人第一層級的一號點位的第一層級的點位中
            users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
            // 發送用戶點位信息
            emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
            // 發送用戶點位信息
            emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
            // 將推薦人的第一層級的第一個點位的地址填入用戶X6矩陣的推薦人地址中
            users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
        } else {
            // 將用戶地址填入推薦人第一層級的2號點位的第一層級的點位中
            users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
            // 發送用戶點位信息
            emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
            // 發送用戶點位信息
            emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
            // 將推薦人的第一層級的第二個點位的地址填入用戶X6矩陣的推薦人地址中
            users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
        }
    }

    // 升級二級推薦人X6的第二層級矩陣:傳入用戶地址、二級推薦人地址、矩陣等級
    function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
        // 如果二級推薦人第二層級點位未滿(小於4)
        if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
            // 則直接將ETH轉給二級推薦人:傳入二級推薦人地址、用戶地址、X6模塊、矩陣等級
            return sendETHDividends(referrerAddress, userAddress, 2, level);
        }

        // 如果二級推薦人第二層級已滿
        // 將二級推薦人當前矩陣的推薦人【三級推薦人】第一層級點位取出
        address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;

        // 當三級推薦人第一層級點位已滿
        if (x6.length == 2) { // 
            // 如果三級推薦人的第一層級點位中有二級推薦人地址
            if (x6[0] == referrerAddress ||
            x6[1] == referrerAddress) {
                // 將二級推薦人填入三級推薦人對應矩陣的封鎖區域 
                users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
            // 當三級推薦人第一層級未滿
            } else if (x6.length == 1) {
                // 如果三級推薦人第一層級的第一點位為二級推薦人
                if (x6[0] == referrerAddress) {
                    // 將二級推薦人填入三級推薦人對應矩陣的封鎖區域 
                    users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
                }
            }
        }

        // 清空二級推薦人第一層級點位
        users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
        // 清空二級推薦人第二層級點位
        users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
        // 清空二級推薦人的封鎖地址
        users[referrerAddress].x6Matrix[level].closedPart = address(0);

        // 判斷二級推薦人對應矩陣是否激活
        if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
            // 如果沒激活,則將二級推薦人對應矩陣進行阻塞(燒傷)
            users[referrerAddress].x6Matrix[level].blocked = true;
        }

        // 二級推薦人對應矩陣復投次數+1
        users[referrerAddress].x6Matrix[level].reinvestCount++;

        // 判斷二級推薦人是否為創始人
        if (referrerAddress != owner) {
            // 如果二級推薦人不是創始人,查找實際的地址(需要二級推薦人激活對應矩陣,如果沒有就往上找)
            address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);

            // 發送復投消息:二級推薦人地址、實際推薦人地址、用戶地址、矩陣等級
            emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
            // 然后拿着二級推薦人地址、和獲取到的實際推薦人地址、對應矩陣等級再把這個流程走一遍,因為這些步驟是查找真正存放新用戶點位的上級地址,還沒有轉賬;
            // 直到找到實際推薦人(第二層級不滿4個),然后轉賬,新用戶的X6才結束
            updateX6Referrer(referrerAddress, freeReferrerAddress, level);
        } else {
            // 如果二級推薦人是創始人
            // 發送復投消息:創始人、推薦人地址為空、調用者、X6模塊、矩陣等級
            emit Reinvest(owner, address(0), userAddress, 2, level);
            // 用戶給創始人轉賬:傳入創始人地址、用戶地址、X6模塊、矩陣等級
            sendETHDividends(owner, userAddress, 2, level);
        }
    }

    // 檢查用戶推薦人X3模塊下某個矩陣是否激活:傳入用戶地址、X3矩陣級別序列號,並獲取實際推薦人地址
    function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
        while (true) {
            // 檢查用戶推薦人的X3是否激活
            if (users[users[userAddress].referrer].activeX3Levels[level]) {
                // 如果對應矩陣已經激活,則返回推薦人地址
                return users[userAddress].referrer;
            }
            // 如果推薦人對應矩陣未激活,則將推薦人地址改為【推薦人的推薦人】地址,找的是直接推薦人,然后再檢查該地址是否激活;
            // 如果還是沒有激活,再往上查,直到找到對應矩陣激活的推薦人地址,然后返回該地址
            userAddress = users[userAddress].referrer;
        }
    }

    // 檢查用戶推薦人X6模塊下某個矩陣是否激活:傳入用戶地址、X3矩陣級別序列號,並獲取實際推薦人地址
    function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
        while (true) {
            // 檢查用戶推薦人的X6是否激活
            if (users[users[userAddress].referrer].activeX6Levels[level]) {
                // 如果對應矩陣已經激活,則返回推薦人地址
                return users[userAddress].referrer;
            }
            // 如果推薦人對應矩陣未激活,則將推薦人地址改為【推薦人的推薦人】地址,找的是直接推薦人,然后再檢查該地址是否激活;
            // 如果還是沒有激活,再往上查,直到找到對應矩陣激活的推薦人地址,然后返回該地址
            userAddress = users[userAddress].referrer;
        }
    }

    // 外用查詢接口【查詢對應矩陣是否激活】:輸入用戶地址、X3的等級序列,可以查詢是否激活
    function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
        return users[userAddress].activeX3Levels[level];
    }

    // 外用查詢接口【查詢對應矩陣是否激活】:輸入用戶地址、X6的等級序列,可以查詢是否激活
    function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
        return users[userAddress].activeX6Levels[level];
    }

    // 外用查詢接口【查詢用戶X3對應序列矩陣信息】:輸入用戶地址、X3的等級序列;輸出推薦人地址、已點亮點位的地址、是否阻塞(燒傷)
    function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
        return (users[userAddress].x3Matrix[level].currentReferrer,
        users[userAddress].x3Matrix[level].referrals,
        users[userAddress].x3Matrix[level].blocked);
    }

    // 外用查詢接口【查詢用戶X6對應序列矩陣信息】:輸入用戶地址、X6的等級序列;輸出推薦人地址、已點亮第一層級點位的地址、已點亮第二層級點位的地址、是否阻塞(燒傷)、封鎖區域的地址
    function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
        return (users[userAddress].x6Matrix[level].currentReferrer,
        users[userAddress].x6Matrix[level].firstLevelReferrals,
        users[userAddress].x6Matrix[level].secondLevelReferrals,
        users[userAddress].x6Matrix[level].blocked,
        users[userAddress].x6Matrix[level].closedPart);
    }

    // 外用查詢接口【查詢用戶是否注冊】:輸入用戶地址;輸出該用戶是否存在
    function isUserExists(address user) public view returns (bool) {
        return (users[user].id != 0);
    }

    // 尋找每一筆交易ETH真正的接收者,檢查推薦人的對應矩陣是否阻塞
    function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
        address receiver = userAddress;
        bool isExtraDividends;

        // 如果是X3模塊
        if (matrix == 1) {
            while (true) {
                // 查詢推薦人的X3對應矩陣是否阻塞(官網對應矩陣會出現黃色三角號表示阻塞)
                if (users[receiver].x3Matrix[level].blocked) {
                    // 推薦人對應矩陣阻塞,發送燒傷(錯過)消息:推薦人地址、用戶地址、X3模塊、對應矩陣等級
                    emit MissedEthReceive(receiver, _from, 1, level);
                    // 然后激活額外滑落
                    isExtraDividends = true;
                    // 實際ETH接收者變為用戶推薦人的推薦人
                    receiver = users[receiver].x3Matrix[level].currentReferrer;
                } else {
                    // 推薦人未阻塞對應矩陣,ETH接收者為推薦人,非額外滑落
                    return (receiver, isExtraDividends);
                }
            }
            // 如果是X6模塊
        } else {
            while (true) {
                // 查詢推薦人的X6對應矩陣是否阻塞(官網對應矩陣會出現黃色三角號表示阻塞)
            if (users[receiver].x6Matrix[level].blocked) {
                // 推薦人對應矩陣阻塞,發送燒傷(錯過)消息:推薦人地址、用戶地址、X3模塊、對應矩陣等級
                    emit MissedEthReceive(receiver, _from, 2, level);
                // 然后激活額外滑落
                    isExtraDividends = true;
                // 實際ETH接收者變為用戶推薦人的當前推薦人
                    receiver = users[receiver].x6Matrix[level].currentReferrer;
                } else {
                // 推薦人未阻塞對應矩陣,ETH接收者為推薦人,非額外滑落
                return (receiver, isExtraDividends);
                }
            }
        }
    }

    // 合約內ETH轉賬交易:接收者地址、發送者地址、對應的X3或者X6模塊、對應的矩陣等級
    function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
        // 確定ETH接收者地址,判斷推薦人對應矩陣是否阻塞,如果阻塞則激活滑落:傳入推薦人地址、當前用戶地址、X3或者X6模塊、對應的矩陣等級
        (address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);

        // 合約轉賬:如果轉賬對應矩陣的ETH未成功,則會將用戶地址上所有余額轉到接收者地址上
        if (!address(uint160(receiver)).send(levelPrice[level])) {
            return address(uint160(receiver)).transfer(address(this).balance);
        }

        // 如果這筆交易是額外滑落,那就發送額外滑落消息:用戶地址、實際接收者地址、X3或X6模塊、對應矩陣等級
        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系統開發技術微信交流:15889726201,歡迎探討

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM