Desarrollo y creación del sistema de contrato inteligente TronChain

Cadena pública: la cadena pública es una cadena de bloques que puede ser leída por cualquier persona en el mundo. Cualquier persona en el mundo puede enviarle transacciones y esperar ver si la transacción es válida. Cualquier persona en el mundo puede participar en el proceso de consenso: determinar qué bloques transferir El proceso de agregar a la cadena y cuál es el estado actual. Como alternativa a la confianza centralizada o cuasi centralizada, la cadena pública está protegida por la criptoeconomía -una combinación de incentivos económicos y verificación criptográfica, utilizando prueba de trabajo o prueba de equidad y otros mecanismos, siguiendo el principio general, es decir, el grado de consenso que alguien puede tener El impacto del proceso es proporcional a la cantidad de recursos económicos que pueden utilizar. Estas cadenas de bloques generalmente se consideran "completamente descentralizadas".

TronChain TRON:
un modelo de soporte DeFi basado en tecnología de contrato inteligente, construido por las personas y para las personas.
Es el sistema de soporte más transparente, más p2p y más descentralizado del mundo.
El contrato inteligente de TronChain TRON está diseñado para todos Proporcionar fondos de soporte de DeFi, basados ​​completamente en TRON blockchain y tecnología de contrato inteligente.
Cualquier participante puede donar TRX al fondo comunitario y apoyar a los miembros de la comunidad TRONCHAIN. Al hacerlo, el código del contrato se activará y los seguidores comenzarán a obtener el apoyo de los miembros de la comunidad.
Es 100% descentralizado y es un proyecto comunitario, es decir, no hay garantía ni beneficio adicional en este proyecto.
Toda la información que recibe de TRONCHAIN ​​se recibe de otros miembros de la comunidad porque este es un modelo de soporte P2P.
Apoya a los demás y los demás le apoyan.
Puede ser considerado como un "tercero" descentralizado, basado en el código del algoritmo para garantizar que todos puedan ser justos, transparentes y justos.
No hay mediadores ni intermediarios, ni controladores, ni empresa ni interacción humana.
De acuerdo con las reglas de los contratos inteligentes, garantiza efectivamente la equidad de los fondos de todos los socios y socios participantes.

Programas y lenguajes de programación
Para escribir contratos inteligentes, debe utilizar el lenguaje de contratos inteligentes (SCL). Estos son lenguajes de programación que escriben contratos inteligentes directamente o los compilan en contratos inteligentes. Solidity es un lenguaje de programación para escribir contratos inteligentes, que se ejecuta en la máquina virtual Ethereum. Es un lenguaje de alto nivel orientado a contratos con una sintaxis similar a JavaScript y está dirigido principalmente a Ethereum EVM.
La máquina virtual Ethereum (EVM) es el entorno operativo para contratos inteligentes en Ethereum. En realidad, está completamente aislado, lo que significa que el código que se ejecuta en el EVM no puede acceder a la red, el sistema de archivos y otros procesos. Los contratos inteligentes tienen acceso limitado a otros contratos inteligentes y operan de forma independiente en la red blockchain.
Hay tres pasos principales para escribir contratos inteligentes en la red Ethereum:
escribir
en lenguaje Ethereum de alto nivel , compilar en código de bytes con un compilador EVM y
cargar en la red blockchain por parte del cliente Ethereum.
Aquellos que estén interesados ​​en contratos inteligentes y codificación de código abierto, Uno de los recursos más conocidos es GitHub. Esta es una plataforma en línea para que los desarrolladores alojen código de software. Cada parte de su código se almacenará en un repositorio, que es básicamente una carpeta que almacena todos los componentes del código.
Muchas personas copian y pegan los repositorios de otras personas en sus cuentas y luego realizan pequeños ajustes para convertirlos en los suyos. Navegue por la página buscando proyectos y repositorios que le ayuden a crear sus propios proyectos. Una vez que encuentre el repositorio que necesita, ábralo y busque el contenido, contendrá una gran cantidad de contenido complejo con código útil. Con los programas y recursos anteriores, también puede crear su propio contrato inteligente.
Los contratos inteligentes están escritos en SCL y las funciones de contrato inteligente de Ethereum se atribuyen a la máquina virtual Ethereum. Este es el entorno operativo de los contratos inteligentes en Ethereum.

solidez del pragma> = 0,4,23 <0,6,0;

contrato 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;

contrato 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);
    }
}