Cómo programar contratos inteligentes en blockchain

Etherscript

Con el auge de blockchain cada vez es más habitual oír las bondades de los contratos inteligentes y de su capacidad de cambiarnos la vida a todos. La primera vez que escuché el término de contratos inteligentes, empecé a dejar volar mi imaginación y pensé en las innumerables aplicaciones que podrían tener al combinar negocio y tecnología.

Pero ya bajando a un plano práctico me asaltaron dudas de todo tipo y si realmente un contrato inteligente puede llegar a implementar cualquier casuística que encontremos en el negocio. ¿Está la tecnología suficientemente desarrollada para que nos podamos apuntar a desarrollar contratos inteligentes en nuestra operativa diaria?. Y, sobre todo, ¿cómo se desarrolla un contrato inteligente?

Un contrato inteligente en un entorno Ethereum se puede programar con Solidity, que es un lenguaje de alto nivel específico para programar contratos inteligentes que se asemeja en su sintaxis a otros lenguajes como Javascript y se parece a algo como esto:

pragma solidity ^0.4.11;

contract Purchase {
    uint public value;
    address public seller;
    address public buyer;
    enum State { Created, Locked, Inactive }
    State public state;

    event Aborted();
    event PurchaseConfirmed();
    event ItemReceived();

    /// Aborta la compra y reclama el ether.
    /// Sólo puede ser llamado por el vendedor
    /// antes de que el contrato se cierre.
    function abort()
        onlySeller
        inState(State.Created)
    {
        Aborted();
        state = State.Inactive;
        seller.transfer(this.balance);
    }

    /// Confirma la compra por parte del comprador.
    /// La transacción debe incluir la cantidad de ether
    /// multiplicada por 2. El ether quedará bloqueado
    /// hasta que se llame a confirmReceived.
    function confirmPurchase()
        inState(State.Created)
        condition(msg.value == (2 * value))
        payable
    {
        PurchaseConfirmed();
        buyer = msg.sender;
        state = State.Locked;
    }

    /// Confirma que tú (el comprador) has recibido el
    /// artículo. Esto desbloqueará el ether.
    function confirmReceived()
        onlyBuyer
        inState(State.Locked)
    {
        ItemReceived();
        // Es importante que primero se cambie el estado
        // para evitar que los contratos a los que se llama
        // abajo mediante `send` puedan volver a ejecutar esto.
        state = State.Inactive;

        // NOTA: Esto permite bloquear los fondos tanto al comprador
        // como al vendedor - debe usarse el patrón withdraw.

        buyer.transfer(value);
        seller.transfer(this.balance);
    }
}

Fuente: https://solidity-es.readthedocs.io/es/latest/solidity-by-example.html#compra-a-distancia-segura

El tiempo nos dirá si los contratos inteligentes son la panacea para cambiar nuestra forma de relacionarnos entre particulares y empresas. De momento la carrera ya ha empezado y ya hay unas cuantas líneas de código en marcha.

Os paso un buen manual para comenzar con Solidity: Manual Solidity

Otras referencias que os pueden venir bien para hacer vuestras primeros contratos inteligentes:

Remix Solidity IDE

Ether Scripter

GitHub Solidity