Contrato Moneda {

    // La palabra clave "public" hace que esas variables

    // legible desde fuera.

    Dirección de minero público;

    Mapping (dirección => uint) saldos públicos;

    // Eventos permiten que los clientes ligeros reaccionen

    // cambia eficientemente.

    Evento Enviado (dirección de, dirección a, uint cantidad);

    // Este es el constructor cuyo código es

    // ejecutar sólo cuando se crea el contrato.

    Función Moneda () {

        Minter = msg.sender;

    }

    Función menta (receptor de dirección, cantidad uint) {

        If (msg.sender! = Minter) return;

        Saldos [receptor] + = cantidad;

    }

    Función de envío (receptor de dirección, uint cantidad) {

        If (saldos [msg.sender] <cantidad) return;

        Balances [msg.sender] - = cantidad;

        Saldos [receptor] + = cantidad;

        Enviado (msg.sender, receptor, cantidad);

    }

Solidez del pragma ^ 0,4.11;

/// @title Votación con delegación.

Contrato de boleta

    // Esto declara un nuevo tipo complejo que

    // se utiliza para las variables más adelante.

    // Representará a un solo votante.

    Struct Voter {

        Uint peso; // el peso se acumula por delegación

        Bool votado; // si es cierto, esa persona ya votó

        Delegado de la dirección; // persona delegada a

        Uint voto; // índice de la propuesta votada

    }
    // Este es un tipo para una sola propuesta.

    Struct Propuesta {

        Bytes32 nombre; // nombre abreviado (hasta 32 bytes)

        Uint voteCount; // número de votos acumulados

    }

    Dirigir al presidente público;

    // Esto declara una variable de estado que

    // almacena una estructura `Voter` para cada dirección posible.

    Mapeo (dirección => votante) votantes públicos;

    // Una matriz de tamaño dinámico de estructuras de 'Propuesta'.

    Propuesta [] propuestas públicas;

    /// Cree una nueva boleta para elegir uno de `proposalNames`.

    Función Ballot (bytes32 [] proposalNames) {

        Chairperson = msg.sender;

        Votantes [chairperson] .weight = 1;

        // Para cada uno de los nombres de propuesta proporcionados,

        // crear un nuevo objeto de propuesta y añadirlo

        // al final de la matriz.

        Para (uint i = 0; i <proposalNames.length; i ++) {

            // `Propuesta ({...})` crea un carácter temporal

            // Propuesta object y `proposals.push (...)`

            // la anexa al final de las «propuestas».

            Proposals.push (Propuesta ({

                Nombre: proposalNames [i],

                VoteCount: 0

            }));

        }

    }

    // Dar a votante el derecho a votar en esta boleta electoral.

    // Sólo puede ser llamado por `chairperson`.

    Function giveRightToVote (dirección del votante) {

        // Si el argumento de `require` se evalúa como` false`,

        // termina y revierte todos los cambios a

        // el estado y las balanzas de éter. A menudo es

        // una buena idea de usar esto si las funciones son

        // llamado incorrectamente. Pero ten cuidado, esto

        // también consumirá actualmente todo el gas suministrado

        // (esto está previsto que cambie en el futuro).

        Require ((msg.sender == chairperson) &&! Votantes [votante] .voted && (votantes

[votante] .weight == 0));

        Votantes [votante]. Peso = 1;

    }
    /// Delegar su voto al votante `to`.

    Delegado de función (dirección a) {

        // asigna referencia

        Votante remitente = votantes [msg.sender];

        Require (! Sender.voted);

        // La autodirección no está permitida.

        Require (to! = Msg.sender);

        // Reenviar la delegación siempre y cuando

        // `to` también delegado.

        // En general, tales bucles son muy peligrosos,

        // porque si funcionan demasiado tiempo, podrían

        // necesita más gas que el disponible en un bloque.

        // En este caso, la delegación no se ejecutará,

        // pero en otras situaciones, tales bucles podrían

        // hacer que un contrato se "atasque" completamente.

        Mientras que (votantes [a] .delegate! = Dirección (0)) {

            A = votantes [a] .delegar;

            // Encontramos un bucle en la delegación, no permitido.

            Require (to! = Msg.sender);

        }
        // Puesto que `sender` es una referencia, esto

        // modifica `votantes [msg.sender] .voted`

        Sender.voted = true;

        Sender.delegate = to;

        Delegado electoral = votantes [a];

        If (delegate.voted) {

            // Si el delegado ya votó,

            // añadir directamente al número de votos

            Propuestas [delegate.vote] .voteCount + = sender.weight;

        } Else {

            // Si el delegado no votó todavía,

            // añadir a su peso.

            Delegate.weight + = sender.weight;

        }

    }

    /// Dé su voto (incluyendo los votos delegados a usted)

    /// a propuesta `propuestas [propuesta] .name`.

    Voto de la función (uint propuesta) {

        Votante remitente = votantes [msg.sender];

        Require (! Sender.voted);

        Sender.voted = true;

        Sender.vote = propuesta;
        // Si `proposal` está fuera del rango de la matriz,

        // esto lanzará automáticamente y revertirá todo

        // cambios.

        Propuestas [propuesta] .voteCount + = sender.weight;

    }

    /// @dev C