Go Ethereum

Implementação oficial de Golang do protocolo Ethereum.

Link para Github:

Implementação oficial de Golang do protocolo Ethereum.

Referência API Boletim Go Travis Discórdia

Compilações automatizadas estão disponíveis para versões estáveis ​​e o branch master instável. Arquivos binários são publicados em https://geth.ethereum.org/downloads/ .

Construindo a fonte

Para os pré-requisitos e instruções detalhadas de construção, leia as Instruções de instalação .

A gethcompilação requer um Go (versão 1.13 ou posterior) e um compilador C. Você pode instalá-los usando seu gerenciador de pacotes favorito. Assim que as dependências forem instaladas, execute

fazer geth

ou, para construir o pacote completo de utilitários:

faça tudo

Executáveis

O projeto go-ethereum vem com vários wrappers / executáveis ​​encontrados no cmd diretório.

Comando Descrição
geth Nosso principal cliente Ethereum CLI. É o ponto de entrada na rede Ethereum (rede principal, teste ou privada), capaz de funcionar como um nó completo (padrão), nó de arquivo (retendo todo o estado histórico) ou um nó leve (recuperando dados ao vivo). Ele pode ser usado por outros processos como um gateway para a rede Ethereum por meio de terminais JSON RPC expostos na parte superior de transportes HTTP, WebSocket e / ou IPC. geth --helpe a página CLI para opções de linha de comando.
abigen Gerador de código-fonte para converter definições de contrato Ethereum em pacotes Go seguros para tipos em tempo de compilação e fáceis de usar. Ele opera em ABIs de contrato Ethereum simples com funcionalidade expandida se o bytecode de contrato também estiver disponível. No entanto, ele também aceita arquivos de origem do Solidity, tornando o desenvolvimento muito mais ágil. Consulte nossa página Native DApps para obter detalhes.
bootnode Versão simplificada de nossa implementação de cliente Ethereum que faz parte apenas do protocolo de descoberta de nó de rede, mas não executa nenhum dos protocolos de aplicativo de nível superior. Ele pode ser usado como um nó de bootstrap leve para ajudar a encontrar pares em redes privadas.
evm Versão do utilitário de desenvolvedor do EVM (Ethereum Virtual Machine) que é capaz de executar trechos de bytecode em um ambiente configurável e modo de execução. Seu objetivo é permitir a depuração isolada e refinada de opcodes EVM (por exemplo evm --code 60ff60ff --debug run).
gethrpctest Ferramenta de utilitário de desenvolvedor para oferecer suporte ao nosso conjunto de testes ethereum / rpc-test , que valida a conformidade básica com as especificações Ethereum JSON RPC . Consulte o leiame do conjunto de testes para obter detalhes.
rlpdump Ferramenta de utilitário de desenvolvedor para converter dumps RLP ( prefixo de comprimento recursivo ) binários ( codificação de dados usada pelo protocolo Ethereum tanto em rede quanto em consenso) em uma representação hierárquica mais amigável ao usuário (por exemplo rlpdump --hex CE0183FFFFFFC4C304050583616263).
puppeth um assistente CLI que ajuda a criar uma nova rede Ethereum.

Corrida geth

Percorrer todos os sinalizadores de linha de comando possíveis está fora do escopo aqui (consulte nossa página CLI Wiki ), mas enumeramos alguns combos de parâmetros comuns para que você possa rapidamente saber como executar sua própria gethinstância.

Nó completo na rede Ethereum principal

De longe, o cenário mais comum é de pessoas que desejam simplesmente interagir com a rede Ethereum: criar contas; transferir fundos; implantar e interagir com contratos. Para este caso de uso específico, o usuário não se preocupa com dados históricos de anos, portanto, podemos sincronizar rapidamente com o estado atual da rede. Para fazer isso:

console $ geth

Este comando irá:

  • Inicie gethem modo de sincronização rápida (padrão, pode ser alterado com o --syncmodesinalizador), fazendo com que baixe mais dados em troca de evitar o processamento de todo o histórico da rede Ethereum, que consome muito da CPU.
  • Inicie o console JavaScriptgeth interativo embutido (por meio do subcomando à direita ) por meio do qual você pode chamar todos os métodos oficiais , bem como as próprias APIs de gerenciamento . Esta ferramenta é opcional e, se você deixá-la de fora, poderá sempre anexar a uma instância já em execução com .consoleweb3gethgethgeth attach

Um nó completo na rede de teste Görli

Fazendo a transição para desenvolvedores, se você gostaria de brincar com a criação de contratos Ethereum, quase certamente gostaria de fazer isso sem nenhum dinheiro real envolvido, até pegar o jeito de todo o sistema. Em outras palavras, em vez de conectar-se à rede principal, você deseja conectar-se à rede de teste com seu nó, que é totalmente equivalente à rede principal, mas apenas com play-Ether.

$ geth --goerli console

O consolesubcomando tem exatamente o mesmo significado que acima e são igualmente úteis no testnet. Por favor, veja as explicações acima, caso você tenha pulado aqui.

Especificar o --goerlisinalizador, no entanto, reconfigurará gethum pouco sua instância:

  • Em vez de conectar a rede Ethereum principal, o cliente se conectará à rede de teste Görli, que usa diferentes bootnodes P2P, diferentes IDs de rede e estados de gênese.
  • Em vez de usar o diretório de dados padrão ( ~/.ethereumno Linux, por exemplo), geth se aninha um nível mais profundo em uma goerlisubpasta ( ~/.ethereum/goerlino Linux). Observe, no OSX e no Linux, isso também significa que a conexão a um nó testnet em execução requer o uso de um ponto de extremidade personalizado, pois geth attachtentará se conectar a um nó de extremidade de produção por padrão, por exemplo geth attach <datadir>/goerli/geth.ipc,. Os usuários do Windows não são afetados por isso.

Nota: Embora existam algumas medidas de proteção internas para evitar que as transações cruzem entre a rede principal e a rede de teste, você deve se certificar de sempre usar contas separadas para dinheiro de mentira e dinheiro real. A menos que você mova manualmente as contas, gethpor padrão separará corretamente as duas redes e não disponibilizará nenhuma conta entre elas.

Nó completo na rede de teste Rinkeby

Go Ethereum também oferece suporte à conexão com a rede de teste baseada em prova de autoridade mais antiga chamada Rinkeby, que é operada por membros da comunidade.

$ geth --rinkeby console

Nó completo na rede de teste Ropsten

Além de Görli e Rinkeby, Geth também suporta a antiga rede de teste Ropsten. A rede de teste Ropsten é baseada no algoritmo de consenso de prova de trabalho Ethash. Como tal, tem certa sobrecarga extra e é mais suscetível a ataques de reorganização devido à baixa dificuldade / segurança da rede.

$ geth --ropsten console

Nota: Configurações Geth mais antigas armazenam o banco de dados Ropsten no testnetsubdiretório.

Configuração

Como alternativa para passar os vários sinalizadores para o gethbinário, você também pode passar um arquivo de configuração por meio de:

$ geth --config /path/to/your_config.toml

Para ter uma ideia de como o arquivo deve ser, você pode usar o dumpconfigsubcomando para exportar sua configuração existente:

$ geth --your-favorite-flags dumpconfig

Nota: Isso funciona apenas com gethv1.6.0 e superior.

Início rápido do Docker

Uma das maneiras mais rápidas de colocar o Ethereum em funcionamento em sua máquina é usando o Docker:

docker run -d --name ethereum-node -v / Users / alice / ethereum: / root \            -p 8545: 8545 -p 30303: 30303 \            ethereum / client-go

Isso iniciará gethno modo de sincronização rápida com uma permissão de memória de banco de dados de 1 GB, assim como o comando acima faz. Ele também criará um volume persistente em seu diretório inicial para salvar seu blockchain, bem como mapear as portas padrão. Também existe uma alpinetag disponível para uma versão reduzida da imagem.

Não se esqueça --http.addr 0.0.0.0, se você deseja acessar o RPC de outros contêineres e / ou hosts. Por padrão, gethvincula-se à interface local e os pontos de extremidade RPC não podem ser acessados ​​externamente.

gethNós de interface programática

Como desenvolvedor, mais cedo ou mais tarde você vai querer começar a interagir com getha rede Ethereum por meio de seus próprios programas e não manualmente por meio do console. Para ajudar nisso, gethpossui suporte integrado para APIs baseadas em JSON-RPC ( APIs padrão e gethAPIs específicas ). Eles podem ser expostos via HTTP, WebSockets e IPC (soquetes UNIX em plataformas baseadas em UNIX e canais nomeados no Windows).

A interface IPC é habilitada por padrão e expõe todas as APIs com suporte geth, enquanto as interfaces HTTP e WS precisam ser habilitadas manualmente e expor apenas um subconjunto de APIs por motivos de segurança. Eles podem ser ligados / desligados e configurados conforme o esperado.

Opções de API JSON-RPC baseadas em HTTP:

  • --http Habilite o servidor HTTP-RPC
  • --http.addrInterface de escuta do servidor HTTP-RPC (padrão localhost:)
  • --http.portPorta de escuta do servidor HTTP-RPC (padrão 8545:)
  • --http.apiAPIs oferecidas na interface HTTP-RPC (padrão eth,net,web3:)
  • --http.corsdomain Lista separada por vírgulas de domínios dos quais aceitar solicitações de origem cruzada (navegador obrigatório)
  • --ws Habilite o servidor WS-RPC
  • --ws.addrInterface de escuta do servidor WS-RPC (padrão localhost:)
  • --ws.portPorta de escuta do servidor WS-RPC (padrão 8546:)
  • --ws.apiAPIs oferecidas na interface WS-RPC (padrão eth,net,web3:)
  • --ws.origins Origens das quais aceitar solicitações de websockets
  • --ipcdisable Desative o servidor IPC-RPC
  • --ipcapiAPIs oferecidas na interface IPC-RPC (padrão admin,debug,eth,miner,net,personal,shh,txpool,web3:)
  • --ipcpath Nome do arquivo para socket / pipe IPC dentro do datadir (caminhos explícitos escapam dele)

Você precisará usar os recursos de seus próprios ambientes de programação (bibliotecas, ferramentas, etc.) para se conectar via HTTP, WS ou IPC a um gethnó configurado com os sinalizadores acima e precisará falar JSON-RPC em todos os transportes. Você pode reutilizar a mesma conexão para vários pedidos!

Nota: Por favor, entenda as implicações de segurança de abrir um transporte baseado em HTTP / WS antes de fazer isso! Hackers na Internet estão ativamente tentando subverter nós Ethereum com APIs expostas! Além disso, todas as guias do navegador podem acessar servidores da web em execução local, portanto, páginas da web maliciosas podem tentar subverter APIs disponíveis localmente!

Operar uma rede privada

Manter sua própria rede privada envolve mais, pois muitas configurações consideradas óbvias nas redes oficiais precisam ser feitas manualmente.

Definindo o estado de gênese privado

Primeiro, você precisará criar o estado de gênese de suas redes, do qual todos os nós precisam estar cientes e concordar. Consiste em um pequeno arquivo JSON (por exemplo, chame-o genesis.json):

{    " config " : {      " chainId " : <arbitrary  positive  integer> ,      " homesteadBlock " : 0 ,      " eip150Block " : 0 ,      " eip155Block " : 0 ,      " eip158Block " : 0 ,      " byzantiumBlock " : 0 ,      " constantinopleBlock " :0 ,      "petersburgBlock " : 0 ,      " istanbulBlock " : 0   },   " alloc " : {},    " coinbase " : " 0x0000000000000000000000000000000000000000 " ,    " dificuldade " : " 0x20000 " ,    " extraData " : " " ,    " gasLimit " : " 0x2fefd8 " ,    " nonce " : " 0x0000000000000042 " ,    " mixhash " :"0x000000000000000000000000000000000000000000000000000000000000000000000000 " ,    " parentHash " : " 0x0000000000000000000000000000000000000000000000000000000000000000 " ,    " timestamp " : " 0x00 "  }

Os campos acima devem ser adequados para a maioria das finalidades, embora recomendamos alterar o noncepara algum valor aleatório para evitar que nós remotos desconhecidos possam se conectar a você. Se você gostaria de pré-financiar algumas contas para facilitar o teste, crie as contas e preencha o alloccampo com seus endereços.

" alocação " : {    " 0x0000000000000000000000000000000000000001 " : {      " saldo " : " 111111111 "   },   " 0x00000000000000000000000000000000000000000002 " : {      " saldo " : " 222222222 "   } }

Com o estado genesis definido no arquivo JSON acima, você precisará inicializar cada geth nó com ele antes de iniciá-lo para garantir que todos os parâmetros do blockchain sejam definidos corretamente:

$ geth init path / to / genesis.json

Criação do ponto de encontro

Com todos os nós que você deseja executar inicializados no estado genesis desejado, você precisará iniciar um nó de bootstrap que outros possam usar para se encontrarem em sua rede e / ou na Internet. A maneira limpa é configurar e executar um bootnode dedicado:

$ bootnode --genkey = boot.key $ bootnode --nodekey = boot.key

Com o bootnode online, ele exibirá uma enodeURL que outros nós podem usar para se conectar a ele e trocar informações de pares. Certifique-se de substituir as informações de endereço IP exibidas (provavelmente [::]) pelo seu IP acessível externamente para obter o enodeURL real .

Nota: Você também pode usar um gethcompleto como bootnode, mas é a forma menos recomendada.

Iniciando seus nós de membros

Com o bootnode operacional e externamente acessível (você pode tentar telnet <ip> <port>garantir que ele seja realmente alcançável), inicie cada gethsubsequente apontado para o bootnode para descoberta de pares por meio do --bootnodessinalizador. Provavelmente também será desejável manter o diretório de dados de sua rede privada separado, portanto, especifique também um --datadirsinalizador personalizado .

$ geth --datadir = caminho / para / custom / data / pasta --bootnodes = < bootnode-enode-url-from-above >

Nota: Como sua rede será completamente desligada da rede principal e de teste, você também precisará configurar um minerador para processar transações e criar novos blocos para você.

Executando um minerador particular

A mineração na rede pública Ethereum é uma tarefa complexa, pois só é viável usando GPUs, exigindo uma ethminerinstância habilitada para OpenCL ou CUDA . Para obter informações sobre essa configuração, consulte o subreddit EtherMining e o repositório ethminer .

Em uma configuração de rede privada, no entanto, uma única instância de minerador de CPU é mais do que suficiente para fins práticos, pois pode produzir um fluxo estável de blocos nos intervalos corretos sem a necessidade de recursos pesados ​​(considere a execução em um único thread, sem necessidade de vários outros ) Para iniciar uma gethinstância de mineração, execute-a com todos os seus sinalizadores usuais, estendidos por:

$ geth < usual-flags > --mine --miner.threads = 1 --miner.etherbase = 0x0000000000000000000000000000000000000000

Que iniciará a mineração de blocos e transações em um único encadeamento da CPU, creditando todos os procedimentos na conta especificada por --miner.etherbase. Você pode ajustar ainda mais a mineração alterando os blocos de limite de gás padrão convergem para ( --miner.targetgaslimit) e as transações de preço são aceitas em ( --miner.gasprice).

Contribuição

Obrigado por considerar ajudar com o código-fonte! Aceitamos contribuições de qualquer pessoa na Internet e somos gratos até mesmo pelas menores correções!

Se você gostaria de contribuir para o go-ethereum, por favor bifurque, conserte, confirme e envie uma solicitação pull para os mantenedores revisarem e fundirem na base de código principal. Se você deseja enviar alterações mais complexas, por favor, verifique primeiro com os desenvolvedores principais em nosso canal gitter para garantir que essas alterações estão alinhadas com a filosofia geral do projeto e / ou obtenha algum feedback inicial que pode tornar seus esforços muito mais leves, bem como nossos procedimentos de revisão e fusão rápidos e simples.

Certifique-se de que suas contribuições estejam de acordo com nossas diretrizes de codificação:

  • O código deve seguir as diretrizes oficiais de formatação do Go (ou seja, usa gofmt ).
  • O código deve ser documentado de acordo com as diretrizes oficiais de comentários do Go .
  • As solicitações pull precisam ser baseadas e abertas na masterramificação.
  • As mensagens de confirmação devem ser prefixadas com o (s) pacote (s) que elas modificam.
    • Por exemplo, "eth, rpc: tornar as configurações de rastreamento opcionais"

Consulte o Guia do desenvolvedor para obter mais detalhes sobre a configuração de seu ambiente, gerenciamento de dependências de projeto e procedimentos de teste.

Licença

A biblioteca go-ethereum (ou seja, todo o código fora do cmddiretório) é licenciada sob a GNU Lesser General Public License v3.0 , também incluída em nosso repositório no COPYING.LESSERarquivo.

Os binários go-ethereum (ou seja, todo o código dentro do cmddiretório) são licenciados sob a GNU General Public License v3.0 , também incluída em nosso repositório no COPYINGarquivo.