Curso Ethereum

Avanzado

andres.junge@consensys.net

Introducción a los Smart Contracts

Programación de Smart Contracts

Introducción a los Smart Contracts

Smart Contracts

Nick Szabo 1994

¿Contratos?

¿Inteligentes?

Smart Contracts

Lógica de Negocio en el Blockchain

Código almacenado en el Blockchain

Estado consensuado

Smart Contracts

Estado

Funciones que modifican el estado

Consulta de estado

Blockchain y Smart Contracts

Transacción de instanciación

Transacción de invocación

Consulta de estado de contrato

Ethereum

Ethereum Virtual Machine (EVM)

Turing Complete

Cada nodo ejecuta el código

Lenguajes

Serpent / Viper

LLL

Solidity

Instanciación

from: Instanciador del contrato

to: (vacio)

data: código compilado del contrato

resultado: dirección de instancia de contrato

Invocación de función

from: Invocador del contrato

to: dirección de instancia del contrato

data: función + parametros

resultado: status + eventos

Consenso

Nodo ejecuta la transacción

Verifica el estado final

Consenso a nivel de bloque

contract Counter {

    int private count = 0;

    function incrementCounter() public {
        count += 1;
    }

    function decrementCounter() public {
        count -= 1;
    }

    function getCount() public constant returns (int) {
        return count;
    }

}

Interacción externa

Entre contratos

Oráculos (Oracles)

Eventos

Casos de Uso

Gestión de Propiedad

Subastas

Fideicomiso

Intro Smart Contracts

¿Partes de un SC?

Variables de estado y funciones

¿Donde se ejecuta el código?

EVM

¿Cual nodo ejecuta el código?

Todos

¿Lenguaje mas popular?

Solidity

¿Cómo interactuar con el mundo exterior?

Oráculos y eventos

¿Preguntas?

Programación de Smart Contracts

Herramientas

Editor de Texto

Compilador

Nodo

Compilador

solc

remix

truffle

Nodo

geth

parity

ganache

Ejemplo

remix + ganache

Variables de estado

pragma solidity ^0.4.0;

contract SimpleStorage {
    uint storedData; // State variable
    // ...
}

Funciones

pragma solidity ^0.4.0;

contract SimpleAuction {
    function bid() public payable { // Function
        // ...
    }
}

Modificadores de funciones

pragma solidity ^0.4.11;

contract Purchase {
    address public seller;

    modifier onlySeller() { // Modifier
        require(msg.sender == seller);
        _;
    }

    function abort() public onlySeller { // Modifier usage
        // ...
    }
}

Eventos

pragma solidity ^0.4.21;

contract SimpleAuction {
    event HighestBidIncreased(address bidder, uint amount); // Event

    function bid() public payable {
        // ...
        emit HighestBidIncreased(msg.sender, msg.value); // Triggering event
    }
}

Estructuras

pragma solidity ^0.4.0;

contract Ballot {
    struct Voter { // Struct
        uint weight;
        bool voted;
        address delegate;
        uint vote;
    }
}

Enumeraciones

pragma solidity ^0.4.0;

contract Purchase {
    enum State { Created, Locked, Inactive } // Enum
}

Tipo de datos

Booleanos: bool

Enteros: int, uint, uint256

Direcciones: address

Arreglos fijos: bytes1, bytes32

Arreglos dinámicos: bytes, string

Mapas: mapping(address => uint)

Variables especiales

msg.sender

msg.value

block.timestamp

tx.gasprice

Manejo de Errores

require()

assert()

Ejemplo: Token

pragma solidity ^0.4.8;

contract DemoToken {
    
    function DemoToken(uint256 _totalSupply) public {
        balances[msg.sender]=_totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function balanceOf(address _owner) view public returns (uint256 balance) {
        return balances[_owner];
    }

    mapping (address => uint256) balances;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);

}

Ejemplo: Escrow

pragma solidity ^0.4.8;

import "./DemoToken.sol";

contract DemoEscrow {
    
    address public tokenAddress;
    
    address public comprador;
    address public vendedor;
    address public arbitro;
    
    function DemoEscrow(address _tokenAddress) public {
        tokenAddress = _tokenAddress;
        arbitro = msg.sender;
    }

    ...

Ejemplo: Escrow

    ...

    function setComprador(address _comprador) public returns (bool success){
        require(comprador == address(0));
        comprador = _comprador;
        return true;
    }

    function setVendedor(address _vendedor) public returns (bool success){
        require(vendedor == address(0));
        vendedor = _vendedor;
        return true;
    }

    function setArbitro(address _arbitro) public returns (bool success){
        require(arbitro == msg.sender);
        arbitro = _arbitro;
        return true;
    }
    
    function getEscrowBalance() view public returns (uint256 _saldo) {
        DemoToken t = DemoToken(tokenAddress);
        return t.balanceOf(this);
    }

    ...

Ejemplo: Escrow

...

    function cancel() public returns (bool success){
        require( msg.sender == vendedor || msg.sender == arbitro);
        DemoToken t = DemoToken(tokenAddress);  
        uint256 balance = t.balanceOf(this) ;
        require( balance > 0);
        return t.transfer(comprador,balance);
    }

    function finish() public returns (bool success){
        require( msg.sender == comprador || msg.sender == arbitro);
        DemoToken t = DemoToken(tokenAddress);  
        uint256 balance = t.balanceOf(this) ;
        require( balance > 0);
        return t.transfer(vendedor,balance);
    }

    
}

¡Hasta mañana!

andres.junge@consensys.net

Curso Ethereum (2/5): Avanzado

By Andres Junge

Curso Ethereum (2/5): Avanzado

Curso Ethereum. Parte 2 de 5. Avanzado

Andres Junge PRO

ajunge_m