diff options
| -rw-r--r-- | pt-br/solidity-pt.html.markdown | 914 |
1 files changed, 914 insertions, 0 deletions
diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown new file mode 100644 index 00000000..84d02e50 --- /dev/null +++ b/pt-br/solidity-pt.html.markdown @@ -0,0 +1,914 @@ +--- +language: Solidity +filename: learnSolidity.sol +contribuidors: + - ["Nemil Dalal", "https://www.nemil.com"] + - ["Joseph Chow", ""] +translators: + - ["João Farias", "http://thatsabug.com/"] +lang: pt-br +--- + +Solidity permite você programar para a [Ethereum] +(https://www.ethereum.org/), uma máquina virtual baseada na tecnologia blockhain +para criação e execução de contratos inteligentes, sem necessidade de partes +centralizadas ou de confiança. + +Solidity é uma linguagem de contratos estaticamente tipaada com similaridade com +Javascript e C. Como objetos em programação orientada a objetos, cada contrato +possue variáveis de estado, funções e tipos de dados comuns. Funcionalidades +particulares de contratados incluem cláusuras modificadoras (guarda), notifica +dores de eventos para listerners e variáveis globais customizadas. + + +Exemplos de contratos Ethereum incluem crowdfunding, votações e audições cegas. + +Erros em código Solidity causam grandes riscos e custos; portanto, você +deve ser muito cuidado com teste e divulgação. DEVIDO ÀS CONSTANTES MUDANÇAS +NO ETHEREUM, ESTE DOCUMENTOS PROVAVELMENTE NÃO ESTARÁ ATUALIZADO, VOCÊ DEVE +ACOMPANHAR A CHATROOM DO SOLIDITY E O BLOG DO ETHEREUM PARA NOTÍCIAS ATUALIZADAS. +TODO CÓDIGO AQUI É ENTREGUE COMO ESTÁ, COM SUBSTANCIAL RISCO DE ERRROS E PADRÕES +DE CÓDIGO DEPRECADOS. + +Diferentemente de outros tipo de código, você também deve adicionar padrões +como pausa, deprecação e retração para reduzir riscos. Este documento discute +sintaxe, então, muito padrões populares são excluídos. + +Como Solidity e Ethereum ainda estão sob desenvolvimento, funcionalidades beta +e experimentais são tipicamente marcadas e sujeitas à mudanças. Pull requests +são bem-vindos. + +```javascript +// Primeiramente, um contrato de um Banco simples +// Permite depósitos, retiradas e checagens de saldo + +// banco_simples.sol (note a extensão .sol) + +/* **** INCICIO DO EXEMPLO **** */ + +// Declare a versão do compilador. +pragma solidity ^0.4.2; + +// Inicie com comentários Natspec (as três barras) +// usados para documentação - e como dados descritivos para elementos/ação de UI + +/// @title BancoSimples +/// @author nemild + +/* 'contrato' tem similadirades com 'classes' em outras linguagens (variáveis de +class, herança, etc.) */ + +contract BancoSimples { // CamelCase + // Declare variáveis de estado fora da função, para persistí-la durante a + // duração do contrato + + // dicionário que mapeia endereços para saldos + // tenha cuidado sobre ataques de overflow com números + + mapping (address => uint) private saldos; + + // "private" significa que outros contratos não podem acessar saldos + // diretamente, mas o dado ainda é visível para outras partes da blockchain + + address public dono; + + // ´public´ é legível (mas sem acesso de escrita) por usuários e contratos + + // Eventos - ações públicas para ouvintes externo + event LogRealizacaoDeDeposito(address numeroDaConta, uint quantidade); + + // Construtor, pode receber uma ou várias variáveis; apenas uma opção é + // permitidas + + function BancoSimples() { + // msg dá detalhes sobre a mensagem mandada pelo contrato + // msg.sender é um chamador do contrato (endereço do criador do + // contrato) + + dono = msg.sender; + } + + /// @notice Deposita ether no banco + /// @return O saldo do usuário após o depósito + + function deposito() public returns (uint) { + saldos[msg.sender] += msg.value; + + // Sem necessidade de "this." ou "self." para variáveis de estado + // todos as variáveis são inciadas com seu valor default + + LogRealizacaoDeDeposito(msg.sender, msg.value); // dispara evento + + return saldos[msg.sender]; + } + + /// @notice Retira ether do banco + /// @dev Isto não retorna nenhum ether excendente + /// @param quantidadeDeRetirada quantidade que você quer retirar + /// @return O saldo restante do usuário + function retirada(uint quantidadeDeRetirada) public returns (uint saldoRestate) { + if(saldos[msg.sender] >= quantidadeDeRetirada) { + + // Observe como deduzimos o saldo imediatamente, antes de enviar - + // devido ao risco de uma chamada recursiva que permite o chamador + // pedir um valor maior que seu saldo + + saldos[msg.sender] -= quantidadeDeRetirada; + + if (!msg.sender.send(quantidadeDeRetirada)) { + // incremente de volta só se falhar, como pode estar enviando + // para o contrato que substituiu 'enviar' no final + // do recebimento + saldos[msg.sender] += quantidadeDeRetirada; + } + } + + return saldos[msg.sender]; + } + + /// @notice Retorna o saldo + /// @return O saldo do usuário + // 'constant' evita que a função edite variáveis de estado + // permite a função executar localmente/fora da blockchain + function saldo() constant returns (uint) { + return saldos[msg.sender]; + } + + // Função de fallback - Chamada se outras funções não forem chamadas ou + // se ether sem dados forem enviados + // Tipicamente chamada quando dados inválidos são enviados + // Adicionada para que ether enviado neste contrato seja revertido se o + // contrato falhar. Se não existisse, o dinheiro do enviante é transferido + // para o contrato + function () { + throw; // 'throw' reverte o estao para antes da chamada + } +} +// ** FIM DO EXEMPLO ** + +// Agora, o básico de Solidity + + +//1 TIPO DE DADOS E MÉTODOS ASSOCIADOS +// uint é usado para quantidade de moeda (não existem doubles ou floats) +// e para datas (no sistema de tempo Unix) + +uint x; + +// int de 256 bits, não pode ser mudado após sua instanciação +int constant a = 8; +int256 constant a = 8; // mesmo efeito, mas aqui os 256 bits são explícitos +uint constant VERSÃO_ID = 0x123A1; // uma constante hexadecimal + +// com 'constant', o compilador substitui cada ocorrência com o valor + +// Para int e uint, é possível determinar o espaço explicitamente, em intervalos +// de 8 a 256, e.g., int8, int16, int24 +uint8 b; +int64 c; +uint248 e; + +// Cuidado contra overflows, e proteja-se contra esse tipo de ataque + +// Não há funções randômicas padrão, use outros contratos para este objetivo + +// Casting de tipo +int x = int(b); + +bool b = true; // ou então 'var b = true;' para inferição de tipo + +// Endereços - comportam 20 bytes/160 bits endereços Ethereum +// Não permite operações aritiméticas +address public dono; + +// Tipos de contas: +// Conta de contrato: endereço criado ao criar (função do endereço do criador, +// número da transação) +// Conta externa: (pessoa/entidade externa): endereç criado a partir de chave +// pública + +// Adicione o campo 'public' para indicar visibilidade pública/externa +// um getter é automaticamente criado, mas NÃO um setter + +// Todos os endereços podem enviar ether +dono.send(ALGUM_SALDO); // returna falso caso falhe +if (dono.send) {} // LEMBRE-SE: encapsule num 'if', dado que endereços de +// contrato tem funções executadas no envio e estas podem falhar +//Também certifique-se que os saldos deduzidos ANTES de tentar enviar, dado que +// há um risco de chamada recursiva que pode drenar um contrato + +// pode sobrescrever seu próprio + +// Pode verificar o saldo +dona.balance; // o saldo do dono (usuário ou contrato) + +// Bytes permitidos de 1 a 32 +byte a; // byte é o mesmo que bytes1 +bytes2 b; +bytes32 c; + +// Bytes dinamicamente criados + +bytes m; // Um array especial, mesmo que byte[] (mas mais comprimido) + +// Mais custoso que byte1-byte32, então, prefira estes quando possível + +// mesmo que bytes, mas não permite verificar tamanho ou acesso por indíce (por +// enquanto) + +string n = "oi"; // guardado em UTF8, note as aspas duplas, não simples + +// funções de string serão adicionadas no futuro +// prefira bytes32/bytes, dado que UTF8 usa mais espaço + +// Inferência de tipo +// var não infere tipos baseados na primeira atribuição, +// não pode ser usado em paramêtros de funções + +var a = true; + +// use com cuidado, inferência pode resultar em tipos errados +// e.g., um int8, quando um contador precisa de int16 + +// var pode ser usado para assinalar uma função a uma variável +function a(uint x) returns (uint) { + return x * 2; +} +var f = a; +f(22); // chamada + +// por padrão, todos os valores são inicializados com 0 + +// Delete pode ser chamada na maioria dos tipos +// (NÃO destroi o valor, mas retorna para o valor 0, o incial) + +uint x = 5; + +// Desestruturação/Tuplas +(x, y) = (2, 7); // assinada/troca múltiplos valores + +// 2. ESTRUTURAS DE DADOS +// Arrays + +bytes32[5] apelidos; // array estático +bytes32[] nomes; // array dinâmico +uint novoTamanho = nomes.push("João"); // adicionando retorna o novo tamanho do + +// Tamanho +nomes.length; // pega o tamanho +nomes.length = 1; // tamanhos pode ser alterados (para arrays dinâmicos) + +// arrays multidimensionais +uint x[][5]; // array com 5 arrays dinâmicos como elementos (ordem da maioria +// das linguagens) + +// Dicionários (qualquer tipo para qualquer tipo) +mapping (string => uint) public saldos; +saldos["charles"] = 1; +console.log(saldos["ada"]); // é 0, toda chave não assinalada retorna zero +// 'public' permite o seguinte contrato +nomeDoContrato.saldos("charles"); // retorna 1 +// 'public' cria um getter (mas não um setter) como o seguinte +function saldos(string _conta) returns (uint saldo) { + return saldos[_conta]; +} + +// Mapeamentos aninhados +mapping (endereco => mapping (endereco => uint)) public guardioes; + +// Para deletar +delete saldos["John"]; +delete saldos; // assinala zero para todas as chaves + +// Diferentemente de outras linguages, NÃO É POSSÍVEL iterar sobre todos os +// elementos de um mapeamento, sem saber previamente as chaves - é possível +// construir estruturas de dados personalizadas para fazer isso + +// Structs e enums +struct Banco { + address dono; + uint saldo; +} +Banco b = Banco({ + dono: msg.sender, + saldo: 5 +}); +// ou +Banco c = Banco(msg.sender, 5); + +c.quantidade = 5; // cria novo valor +delete b; +// assinala todos os valores do enum para zero, exceto mapeamentos + +// Enums +enum Estado { Criado, Travado, Inativo }; // geralmente usado para máquina de +// estados +Estado public estado; // Declara variável para enum +estado = Estado.Criado; +// enums podem ser explicitamente convertidas em ints +uint estadoCriado = uint(Estado.Criado); // 0 + +// Localização de dados: Memória vs. disco vs. pilha - todos os tipos complexos +// (arrays, structs) tem uma localização de dados +// 'memória' não é persistida, 'disco' é +// Padrão é 'disco' para variáveis locais e de estado; 'memória' para paramêtros +// de função. Pilha guarda pequena variáveis locais + +// a maioria dos tipos podem ter sua localização de dados explicitamente assinalos + +// 3. Operações simples +// Comparações, operadores binários e aritimétricos são providos +// exponenciação: ** +// ou exclusivo: ^ +// negação binária: ~ + +// 4. Variáveis Globais de nota +// ** this ** +this; // endereço do contrato +// geralmente usado no final do contrato para enviar o saldo restante às partes +this.balance; +this.algumFuncao(); // chamada de função externa via call, não via jump interno + +// ** msg - Mensagem corrente recebida pelo contrato ** ** +msg.sender; // endereço do enviador +msg.value; // quantidade de ether provida para este contrato em wei +msg.data; // bytes, todos os dados da chamada +msg.gas; // gas restante + +// ** tx - Esta transação ** +tx.origin; // endereço do enviador da transação +tx.gasprice; // valor do gas da transação + +// ** block - Informação do bloco corrente ** +now; // tempo corrente (aproxiamdo), substituto para block.timestamp +//(usa tempo do Unix) +block.number; // número do bloco corrente +block.difficulty; // dificuldade do bloco corrente +block.blockhash(1); // retorna bytes32, só funciona para os 256 blocos mais +//recentes +block.gasLimit(); + +// ** storage - Hash de disco persistente ** +storage['abc'] = 'def'; // mapea palavras de 256 bits em palavras de 256 bits + + +// 4. FUNÇÕES E MAIS +// A. Funções +// Funções simples +function incremento(uint x) returns (uint) { + x += 1; + return x; +} + +// Funções podem retornar muito argumentos, e podem especificar argumentos +// retornados sem necessidade de explicitamente usar return +function incremento(uint x, uint y) returns (uint x, uint y) { + x += 1; + y += 1; +} +// Chamando a função anterior +uint (a,b) = incremento(1,1); + +// 'constant' indica que uam função não altera variáveis persistidas +// Funções constantes são executadas localmente, não na blockchain +uint y; + +function incremento(uint x) constant returns (uint x) { + x += 1; + y += 1; // Esta linha deve falhar + // y é uma variável de estado e não pode ser alterada por uma função local +} + +// 'Especificadores de visibilidade de funções' +// Estes podem substituitir 'constante', incluíndo: +// public - visbilidade externa e interna (padrão) +// private - apenas visível no contrato corrente +// internal - apenas visível no contrato corrente e seus derivados + +// Functions hosteada - e pode ser assinalada para variável +function a() { + var z = b; + b(); +} + +function b() { + +} + +// Prefira loops sobre recursões (pilha de chamada é no máximo 1024) + +// B. Eventos +// Eventos podem notificar partes externas; facilmente buscáveis e acessáveis +// de fora da blockchain (com clientes leves) +// tipicamente declarados após os parâmetros do contrato + +// Tipicamente, com letra maiúscula - e adicione Log na frente para +// ser explicito e previnir confusão na chamada da função + +// Declaração +event LogEnvio(address indexed de, address indexed para, uint quantidade); +// Observe a letra maíscula no início do nome + +// Chamada +Envio(de, para, quantidade); + +// Para partes externas (um contrato ou entidade externo), observe: +Coin.Envio().watch({}, '', function(erro, resultado) { + if (!erro) { + console.log("Moeda transferida: " + resultado.args.quantidade + + " moedas enviadas de " + resultado.args.de + + " para " + resultado.args.para + "."); + console.log("Saldo atual:\n" + + "Enviador: " + Coin.balances.call(resultado.args.de) + + "Recebedor: " + Coin.balances.call(resultado.args.para)); + } +} +// Paradigma comum para um contrato depender de outro (e.g., um contrato que +// depende da taxa de troca provida por outro) + +// C. ModifiCadores +// MOdificadores validam entradas de funções, como saldo mínimo e autorização +// do usuário; semelhantes a guardas em outras linguagens + +// '_' (subtraço) geralmente incluído como última linha do corpo, indica que a +// função sendo chamada deve ser colocada ali +modifier apenasDepois(uint _tempo) { if (agora <= _tempo) throw; _ } +modifier apenasDono { if (msg.sender == dono) _ } +// geralmente usado para máquina de estado +modifier apenasSeEmEstado (Estado estadoCorrente) +{ if (estadoCorrente != Estado.A) _ } + +// Concatenado logo após a chamada da função +function mudeDona(novoDono) +apenasDepois(algumTempo) +apenasDono() +apenasSeEmEstado(Estado.A) +{ + dono = novoDono; +} + +// subtração pode ser incluído antes do final do corpo, mas retorno explícitos +// pode ser ignorado, então, tome cuidado +modifier chequeValor(uint quantidade) { + _ + if (msg.value > quantidade) { + uint quantidadeASerDevolvida = quantidade - msg.value; + if (!msg.sender.send(quantidadeASerDevolvida)) { + throw; + } + } +} + +// 6. BRANCHES E LOOPS + +// Todas as lógicas básicas de bloco funcionam - incluindo if/else, +// while, break, continue, return - mas não há switch + +// A sintaxe é semelhante a Javascript, mas sem conversão de tipos +// de não-booleanos para booleanos (operadores de comparação precisam +// utilizar valores booleanos) + +// Loops que dependem o comportamento do usuário exigem cuidado - dado +// que contratos tem uma quantidade máxima de gas para cada bloco de +// de código - falhas acontecerão caso ele seja excedido +// Por exemplo: +for(uint x = 0; x < listaDeEnderecoDeRefundo.length; x++) { + if (!listaDeEnderecoDeRefundo[x].send(ALGUMA_QUANTIDADE)) { + throw; + } +} + +// Dois erros acima: +// 1. Uma falha no enviar para o loop completamente, travando dinheiro +// 2. Este loop pode ser abitrariamente longo (basado na quando que +// o usuário precisa de refundo), portanto, pode falhar quando exceder +// a quantidade máxima de gas do bloco +// Ao invés disso, você deve deixar as pessoas retirarem +// individualmente de suas subcontas e marcarem a retirada + + +// 7. OBJETOS/CONTRATOS + +// A. Chamando um contrato externo +contract FonteDeInformacoes { + function info() returns (uint ret) { return 42; } +} + +contract Consumidor { + FonteDeInformacoes fonte; // aponta para um contrato na blockchain + + // Assinala variável para uma instância do contrato + function setFonte(address endereco) { + // Cast automático, cuidado; construtor não é chamado + fonte = FonteDeInformacoes(endereco); + } + + // Assinala variável para uma nova instância do contrato + function createNewFeed() { + fonte = new FonteDeInformacoes(); // nova instância criada + // construtor é chamado + } + + function chameFonte() { + // último parenteses chama o contrato, podendo adicionar + // opcionalmente valores ou gas + fonte.info.value(10).gas(800)(); + } +} + +// B. Herança + +// Ordem importa, último contrato herdado (i.e., 'def') pode +// sobrescrever partes de contratos previamente herdados +contract MeuContratdo is abc, def("um argumento personalizado def") { + +// sobrescrevendo função + function z() { + if (msg.sender == dono) { + def.z(); // chama função sobrescrita de def + super.z(); // chama função do pai imeadiato + } + } +} + +// função abstrata +function umaFuncaoAbstrata(uint x); +// não pode ser compilada, usada em contratos base/abstratos que +// então, a implementam + +// C. Import + +import "filename"; +import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol"; + +// 'Import' está sobre desenvolvimento +// Atualmente não pode ser usada na linha de comando + + +// 8.OUTRAS PALAVRAS-CHAVE + +// A. Throwing +// Throwing +throw; // reverte estado e dinheiro NÃO-USADO é devolvido ao usuários +// Atualmente não pode ser capturado + +// Um padrão de design comum é: +if (!endereco.send(123)) { + throw; +} + +// B. Selfdestruct +// auto-destroe o contrato corrente, enviando fundos para o endereço +// (geralmente o criador) +selfdestruct(ALGUM_ENDERECO); + +// remove disco/código dos blocos corrente e futuros +// ajuda clientes leves, mas dados persistidos continuam no blockchain + +// Padrão comum, permite ao dono finalizar o contrato e receber fundos +// restantes +function remover() { + if(msg.sender == criador) { // Apenas o criador do contrato pode + // fazer isso + selfdestruct(criador); // Inativa o contrato e retorna os fundos + } +} + +// Talvez queria desativar o contrato manualmente, ao invés de usar +// selfdestruct (ether enviado para contratos selfdestructed é perdido) + + +// 9. NOTAS SOBRE DESIGN DE CONTRATOS + +// A. Obfuscação +// Todas as variáveis são publicamente visíveis na blockchain, então +// qualquer coisa privada precisa ser obfuscada (e.g., hash com segredo) + +// Passo-a-pass: 1. Comprometa-se com algo, 2. Revele compromisso +sha3("quantidade_de_lance", "algum segredo"); // compromisso + +// chame a função reveal (revelar) do contrato no futuros +// mostrando o lance mais o segredo para foi hasheado com SHA3 +reveal(100, "meuSegredo"); + +// B. Otimização de disco +// Escrever na blockchain pode ser caro, dado que os dados são guardados +// para sempre. É encorajado que contratos inteligentes usem memória ( +// enventualmente, compilação será melhor, mas por enquanto é benéfico +// usar estruturas de dados simples - armazenando minimamente na +// blockchain) + +// Custo pode ser alto para item como arrays multidimensionais +// (custo para guardar os dados - não declarar variáveis) + +// C. Acesso de dados da blockchain + +// Não pode restringir humanos ou computadores de ler os conteúdos +// de transações ou estado de transações + +// Enquanto 'private' previne outros *contratos* de ler dados ] +// diretamente - qualquer outra parte ainda pode ler dados da blockchain + +// Todos os dados são armazedos na blockchain, para que qualquer um +// possa observar dados antigos e mudanças + +// D. Jobs Cron +// Contratos deve ser manualmente chamados para lidar com agendamentos +// baseados em tempo; podendo criar código externo para pingar +// regularmente ou prover incentivos (ether) para outros fazê-lo + +// E. Padrão Observador +// O Padrão Observador permite que você registre um inscritor e +// registre uma função a ser chamada pelo Oráculo (nota, Oráculos pagam +// pela ação executada). Similarmente à subscrição em Pub/sub + +// Este é um contrato abstrato, tanto as classes cliente como a +// servidor importam o cliente que deve ser implementado +contract AlgumOraculoCallback { + function OraculoCallback(int _valor, uint _tempo, bytes32 info) external; +} + +contract AlgumOráculo { + AlgumOraculoCallback[] callbacks; // array com todos os inscritos + + // Registra inscrito + function addInscrito(AlgumOraculoCallback a) { + callbacks.push(a); + } + + function notificar(valor, tempo, info) private { + for(uint i = 0;i < callbacks.length; i++) { + // todos os inscritos precisam implementar AlgumOraculoCallback + callbacks[i].OraculoCallback(valor, tempo, info); + } + } + + function facaAlgo() public { + // Código para fazer algo + + // Notifica todos os inscrito + notificar(_valor, _tempo, _info); + } +} + +// Agora, seu contrato cliente pode addInscrito importando +// AlgumOraculoCallback e registrando algum Oráculo + +// F. Máquinas de estado +// veja o exemplo abaixo para o enum Estado e o modificador noEstado + +// *** EXEMPLO: Um exemplo de crowdfunding example (similar ao +// Kickstarter) *** +// ** INCIO DO EXEMPLO ** + +// FundadorDoCrowdFunding.sol + +/// @title FundadorDoCrowdFunding +/// @author nemild +contract FundadorDoCrowdFunding { + // Variáveis assinaladas na crição pelo criador + address public criador; + address public recipiente; // criador pode ser diferente do Recipiente + uint public minALevantar; // requisito para pagar, pelo contrário + // os doadores recebem o dinheiro de volta + string urlDaCampanha; + byte constant versao = 1; + + // Estruturas de dados + enum Estado { + LevantandoFundos, + RefundoExpirado, + Sucesso + } + struct Contribuicao { + uint quantidade; + address contribuidor; + } + + // Variáveis de Estado + State public estado = Estado.LevantandoFundos; // incializado na criação + uint public totalLevantado; + uint public levantadoPor; + uint public completadoEm; + Contribution[] contribuidores; + + event LogRecebimentoDeFundos(address endereco, + uint quantidade, + uint totalAtual); + event LogFundosPagos(address enderecoDoRecebedor); + + modifier noEstado(Estado _estado) { + if (estado != _estado) throw; + _ + } + + modifier eOCriador() { + if (msg.sender != criador) throw; + _ + } + + // Aguarda 6 meses após o final do contrato para destruí-lo + modifier noFimDoContrato() { + if(!((estado == Estado.RefundoExpirado || estado == Estado.Sucesso) && + completadoEm + 6 months < now)) { + throw; + } + _ + } + + function FundadorDoCrowdFunding( + uint tempoEmHorasParaFundraising, + string _urlDaCampanha, + address _recipiente, + uint _minALevantar) + { + criador = msg.sender; + recipiente = _recipiente; + urlDaCampanha = _urlDaCampanha; + minALevantar = _minALevantar; + levantadoPor = now + (tempoEmHorasParaFundraising * 1 hours); + } + + function contribuir() + public + noEstado(Estado.LevantandoFundos) + { + contribuidores.push( + Contribuicao({ + quantidade: msg.value, + contribuidor: msg.sender + }) // use array, para podermos iterar + ); + totalLevantado += msg.value; + + LogRecebimentoDeFundos(msg.sender, msg.value, totalRaised); + + verifiqueSeLevantamentoFoiCompletadoOuExpirado(); + return contribuicoes.length - 1; // retorna id + } + + function verifiqueSeLevantamentoFoiCompletadoOuExpirado() { + if (totalLevantado > minALevantar) { + estado = Estado.Sucesso; + pagar(); + + // pode incentivar enviador que iniciou a mudanção de estado + } else if ( now > levantadoPor ) { + estado = Estado.RefundoExpirado; // backers podem coletar + // o fundo chamando receberRefundo(id) + } + completadoEm = now; + } + + function pagar() + public + emEstado(Estado.Sucesso) + { + if(!recipiente.send(this.balance)) { + throw; + } + + + LogFundosPagos(fundRecipient); + } + + function receberRefundo(id) + public + emEstado(Estado.RefundoExpirado) + { + if (contribuicoes.length <= id || id < 0 || contribuicoes[id].amount == 0 ) { + throw; + } + + uint quantidadeDeRefundo = contribuicoes[id].amount; + contribuicoes[id].amount = 0; + + if(!contribuicoes[id].contribuidor.send(quantidadeParaEnviar)) { + contribuicoes[id].amount = quantidadeParaEnviar; + return false; + } + + return true; + } + + function removerContrato() + public + eOCriador() + noFimDoContrato() + { + selfdestruct(msg.sender); + // criador recebe todo o dinheiro restante{ + + } + + function () { throw; } +} +// ** FIM DO EXEMPLO ** + +// 10. OUTRAS FUNÇÕES NATIVAS + +// Unidades monetárias +// Moeda é definida usando wei, menor quantidade de ether +uint quantidadeMin = 1 wei; +uint a = 1 finney; // 1 ether == 1000 finney +// Para outras unidades, veja: http://ether.fund/tool/converter + +// Unidades temporais +1 == 1 second // segundos +1 minutes == 60 seconds // Minutos + +// Pode multiplicar uma variável de tempo, dado que unidades não são guardadas +// na variável +uint x = 5; +(x * 1 days); // 5 dias + +// Cuidado com o salto de segundos / anos com declarações de igualdade para o tempo +// (em vez disso, prefira maior que / menor que) + +// Criptografia +// Todas as string passadas são concatenadas antes de realizar hashing +sha3("ab", "cd"); +ripemd160("abc"); +sha256("def"); + +// 11. Segurança + +// Bugs são desastrosos para contratos Ethereum - até padrões Solidity populares +// podem ser considerados anti-padrões + +// Veja links para segurança no final deste documento + +// 12. FUNÇÕES DE BAIXO NÍVELS +// call - baixo nível, geralmente não usada, não tem segurança de tipos +booleanSucesso = algumEnderecoDeContrato.call('nome_da_funcao', 'arg1', 'arg2'); + +// callcode - Código no endereço alvo executado no *contexto* do contrato +// de chamada. Fornece funcionalidade de biblioteca +algumEnderecoDeContrato.callcode('nome_da_funcao'); + + +// 13. NOTAS DE ESTILO +// Baseado no guia de estilo PEP8 do Python + +// Resumo rápido: +// 4 espaços para identação +// Duas linhas separam declaração de contratos (e outras declarações de alto nível) +// Evite espaços estranhos entre parênteses +// Pode omitir chaves curly para uma declaração de linha(if, for, etc) +// else deve ser colocado na própria linha + + +// 14. COMENTÁRIOS NATSPEC +// usado para documentação, comentários e UIs externos + +// Contrato natspec - sempre acima da definição do contrato +/// @title Título do Contrato +/// @author Nome do autor + +// Função natspec +/// @notice informações sobre o que funciona; mostrado quando a função é executada +/// @dev Documentação de função para desenvolvedor + +// Parâmetro de função / valor de retorno natspec +/// @param algumParametro Alguma descrição do que o parametro faz +/// @return Descrição do valor de retorno +``` + +## Recursos adicionais +- [Documetanção Solidity](https://solidity.readthedocs.org/en/latest/) +- [Guia de Estilo do Solidity](https://ethereum.github.io/solidity//docs/style-guide/): + O guia de estilo Ethereum é derivado do guia de estilo do Python [pep8](https://www.python.org/dev/peps/pep-0008/). +- [Editor de Browser Solidity](http://chriseth.github.io/browser-solidity/) +- [Gitter Solidity Chat room](https://gitter.im/ethereum/solidity) +- [Estratégias de projeto modular para contratos Ethereum](https://docs.erisindustries.com/tutorials/solidity/) + +## Contratos de Exemplo +- [Dapp Bin](https://github.com/ethereum/dapp-bin) +- [Solidity Baby Step Contracts](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts) +- [ConsenSys Contracts](https://github.com/ConsenSys/dapp-store-contracts) +- [State of Dapps](http://dapps.ethercasts.com/) + +## Segurança +- [Thinking About Smart Contract Security](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/) +- [Smart Contract Security](https://blog.ethereum.org/2016/06/10/smart-contract-security/) +- [Hacking Distributed Blog](http://hackingdistributed.com/) + +## Informação excluída intencionalmente +- Libraries + +## Estilo +- [PEP8](https://www.python.org/dev/peps/pep-0008/) é usado como guia de estilo, + incluindo sua filosofia geral + +## Editores +- [Vim Solidity](https://github.com/tomlion/vim-solidity) +- Snippets de Editores ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc)) + +## Trabalhos Futuros +- Novas palavras-chave: protected, inheritable +- Lista de padrões de design comuns (throttling, RNG, atualização de versão) +- Padrões anti-segurança comuns + + +Sinta-se a vontade para enviar um pull request com quaisquer edições - ou email +para nemild - / at- / gmail |