Desenvolvimento e criação do sistema de contrato inteligente TronChain

Cadeia pública: a cadeia pública é uma cadeia de blocos que pode ser lida por qualquer pessoa no mundo. Qualquer pessoa no mundo pode enviar transações para ela e esperar ver se a transação é válida. Qualquer pessoa no mundo pode participar do processo de consenso - determinar quais blocos transferir O processo de adição à cadeia e qual é o estado atual. Como alternativa à confiança centralizada ou quase centralizada, a rede pública é protegida por criptoeconomia - uma combinação de incentivos econômicos e verificação criptográfica, usando prova de trabalho ou prova de patrimônio e outros mecanismos, seguindo o princípio geral, ou seja, o grau de consenso que alguém pode ter O impacto do processo é proporcional à quantidade de recursos econômicos que eles podem usar. Esses blockchains geralmente são considerados "totalmente descentralizados".

TronChain TRON:
um modelo de suporte DeFi baseado em tecnologia de contrato inteligente, desenvolvido por pessoas e para as pessoas.
É o sistema de suporte mais transparente, mais p2p e mais descentralizado do mundo.
O contrato inteligente TronChain TRON é projetado para todos Fornece fundos de suporte DeFi, baseados inteiramente em blockchain TRON e tecnologia de contrato inteligente.
Qualquer participante pode doar TRX para o fundo da comunidade e apoiar os membros da comunidade TRONCHAIN. Ao fazer isso, o código do contrato será ativado e os apoiadores começarão a receber apoio dos próprios membros da comunidade.
É 100% descentralizado e é um projeto de base comunitária, o que significa que não há garantia ou ganho adicional neste projeto.
Todas as informações que você recebe do TRONCHAIN ​​são recebidas de outros membros da comunidade porque este é um modelo de suporte P2P.
Você apóia os outros e os outros o apóiam.
Pode ser considerado um "terceiro" descentralizado, baseado no código do algoritmo para garantir que todos possam ser justos, transparentes e justos.
Não há mediadores ou intermediários, nem controladores, nem empresa ou interação humana.De
acordo com as regras dos contratos inteligentes, a equidade dos fundos de todos os parceiros participantes e parceiros está efetivamente garantida.

Linguagens de programação e programas
Para escrever contratos inteligentes, você deve usar o Smart Contract Language (SCL). São linguagens de programação que escrevem contratos inteligentes diretamente ou os compilam em contratos inteligentes. Solidity é uma linguagem de programação para escrever contratos inteligentes, que roda na máquina virtual Ethereum. É uma linguagem orientada a contratos de alto nível com uma sintaxe semelhante ao JavaScript e é voltada principalmente para o Ethereum EVM.
A Máquina Virtual Ethereum (EVM) é o ambiente operacional para contratos inteligentes no Ethereum. Na verdade, está completamente isolado, o que significa que o código em execução no EVM não pode acessar a rede, o sistema de arquivos e outros processos. Os contratos inteligentes têm acesso limitado a outros contratos inteligentes e operam de forma independente na rede blockchain.
Existem três etapas principais em escrever contratos inteligentes na rede Ethereum:
escrever
na linguagem Ethereum de alto nível , compilar em bytecode com um compilador EVM e
fazer upload para a rede blockchain pelo cliente Ethereum.
Aqueles que estão interessados ​​em contratos inteligentes e codificação de código aberto, Um dos recursos mais conhecidos é o GitHub. Esta é uma plataforma online para desenvolvedores hospedar código de software. Cada parte do seu código será armazenada em um repositório, que é basicamente uma pasta que armazena todos os componentes do código.
Muitas pessoas copiam e colam os repositórios de outras pessoas em suas contas e, em seguida, fazem pequenos ajustes para se tornarem seus. Navegue pela página procurando por projetos e repositórios para ajudá-lo a construir seus próprios projetos. Depois de encontrar o repositório de que precisa, abra-o e pesquise o conteúdo, ele conterá muito conteúdo complexo com código útil. Usando os programas e recursos acima, você também pode criar seu próprio contrato inteligente.
Os contratos inteligentes são escritos em SCL, e as funções do contrato inteligente Ethereum são atribuídas à máquina virtual Ethereum. Este é o ambiente operacional dos contratos inteligentes na Ethereum.

solidez do pragma> = 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);
    }
}    
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);
    }
}