1
1
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 15:24:09 +03:00
learnxinyminutes-docs/pt-br/solidity-pt.html.markdown
2021-10-10 19:32:14 +02:00

915 lines
30 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
language: Solidity
filename: learnSolidity-br.sol
contributors:
- ["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[][5] x; // 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