Explicando o Bloco Genesis no Ethereum

Toda blockchain tem que começar em algum lugar, então há o que é chamado de bloco genesis no início. Este é o primeiro bloco, e nele os criadores do Ethereum tiveram a liberdade de dizer “Para começar, todas as contas a seguir têm X unidades da minha criptomoeda”. Qualquer transferência desse ether na blockchain terá origem em uma dessas contas iniciais (ou na mineração).

Toda vez que lançamos a Ethereum, na verdade, recriamos esse bloco de genesis do zero. Sincronização da blockchain com pares só começa no bloco 1.

Se você achar este post útil, não deixe de seguir meu Twitter, onde posto mais conteúdo e tutoriais sobre Ethereum.

Genesis

O bloco genesis é criado utilizando o arquivo de estado genesis ou genesis.json no Geth. Este arquivo contém todos os dados que serão necessários para gerar o bloco 0, incluindo quem começa com quanto de ether. Aqui está um exemplo de um arquivo de estado de genesis personalizado que inicializa este bloco.

// genesis.json
{
 "alloc": {
    "0xca843569e3427144cead5e4d5999a3d0ccf92b8e": {
      "balance": "1000000000000000000000000000"
    },
    "0x0fbdc686b912d7722dc86510934589e0aaf3b55a": {
      "balance": "1000000000000000000000000000"
    }
  },
 "config": {
   "chainID": 68,
   "homesteadBlock": 0,
   "eip155Block": 0,
   "eip158Block": 0
 },
 "nonce": "0x0000000000000000",
 "difficulty": "0x0400",
 "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 "coinbase": "0x0000000000000000000000000000000000000000",
 "timestamp": "0x00",
 "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 "extraData": "0x43a3dfdb4j343b428c638c19837004b5ed33adb3db69cbdb7a38e1e50b1b82fa",
 "gasLimit": "0xffffffff"
}

Vamos detalhar alguns dos campos no arquivo de estado genesis.

Configuração (Config)

A struct config em genesis.json tem a ver com a definição de variáveis ​​de configuração para Ethereum, e não tem nada a ver com o que está dentro do bloco 0. No entanto, esses valores são importantes, porque eles também precisam corresponder às informações de configuração de qualquer outro nó que você deseja interagir.

Existem três recursos que observamos ao examinar config.

• A struct na implementação do Go da Ethereum.

• Como config é realmente inicializada ao usar a Ethereum na mainnet.

• Onde as variáveis ​​são definidas a partir da inicialização da mainnet.

Abaixo está a struct config do primeiro link acima.

type ChainConfig struct {
  ChainId *big.Int `json:"chainId"` // Chain id identifica a corrente atual e é usado para proteção de replay

  HomesteadBlock *big.Int `json:"homesteadBlock,omitempty"` // Bloco de troca Homestead (nenhum valor = sem fork, 0 = já está como homestead)
  DAOForkBlock   *big.Int `json:"daoForkBlock,omitempty"`   // Bloco de switch do hard-fork da DAO (nenhum valor = sem fork)
  DAOForkSupport bool     `json:"daoForkSupport,omitempty"` // Se os nós suportam ou se opõem ao hard-fork da DAO

  // EIP150 implementa as mudanças de preço do gas (https://github.com/ethereum/EIPs/issues/150)
  EIP150Block *big.Int    `json:"eip150Block,omitempty"` // Bloco EIP150 HF (nenhum valor = sem fork)
  EIP150Hash comum.Hash `json:"eip150Hash,omitempty"`  // Hash EIP150 HF (auxílio de sincronização rápida)

  EIP155Block *big.Int `json:"eip155Block,omitempty"` // Bloco EIP155 HF
  EIP158Block *big.Int `json:"eip158Block,omitempty"` // bloco EIP158 HF

  // Vários mecanismos de consenso
  Ethash *EthashConfig `json:"ethash,omitempty"`
  ...
}

Configuração: chainID

Isto existe para dizer ao mundo em qual chain você está. O chainID da mainnet é 1, e é uma maneira rápida de dizer a outros clientes “quero participar da mainnet chain” em vez de “vou criar minha própria chain com a qual ninguém mais deveria se importar”.

chainID foi introduzido no EIP155 (discutirei o que é o EIP em breve). A intenção de adicioná-lo era fazer com que as transações na rede Ethereum parecessem diferentes daquelas na rede Ethereum classic. As transações são assinadas de forma diferente dependendo do chainID usado.

A partir do segundo link acima, MainnetChainConfig define ChainId como uma variável MainNetChainID:

// MainnetChainConfig são os parâmetros da cadeia para executar um nó na mainnet.
MainnetChainConfig = &ChainConfig{
  ChainId:        MainNetChainID,
  ...
}

Essa variável MainNetChainID é definida no utils.go como 1.

MainNetChainID = big.NewInt(1) // ID da cadeia padrão da mainnet

Para obter mais informações sobre discrepâncias de assinatura e uma lista de chanIDs conhecidos, acesse aqui.

Configuração: HomesteadBlock

HomesteadBlock, quando definido como 0, significa que você estará usando a versão Homestead da Ethereum. Isso é esperado, e a configuração do bloco gênesis na mainnet também tem isso definido como 0.

Configuração: DAOForkBlock

O número do bloco onde ocorre o fork da Organização Autônoma Descentralizada (DAO).

Algumas informações: em 2016, a DAO criou um smart contract para financiar dApps e fornecer aos contribuidores uma espécie de participação acionária nesses dApps através de tokens. Este contrato foi uma ideia nova que levantou quantidades sem precedentes de ether.

Infelizmente, um invasor descobriu um vetor de ataque que permitia que o ether fosse retirado do contrato várias vezes em troca dos mesmos tokens DAO. Milhões foram roubados.

Por fim, a maioria dos usuários da Ethereum votaram para criar um hard fork na blockchain que invalidaria o que os invasores fizeram, e o contrato seria atualizado. Esta foi uma decisão controversa, pois a facção anti-fork (legitimamente) afirmou que estabeleceu um precedente perigoso para o futuro: se a maioria dos usuários não gostar de nenhum resultado em particular, agora havia um precedente para desfazê-lo.

Como a maioria votou para prosseguir com este fork, a variável DAOForkBlock nasceu, e ocorreu no bloco 1920000 na mainnet. Aqui está a definição da variável em Geth:

// MainNetDAOForkBlock é o número do bloco onde o hard-fork DAO começa na
// mainnet Ethereum.
var MainNetDAOForkBlock = big.NewInt(1920000)

Assim, qualquer bloco minerado após este teria que seguir os protocolos estabelecidos por este novo fork, e seria rejeitado caso contrário. Se estivéssemos criando uma cadeia Ethereum local para testar, poderíamos definir esse valor como 0 para obter o comportamento de transação mais atualizado desde o início, em vez de usar um protocolo desatualizado para os primeiros 1919999 blocos.

Configuração: DAOForkBlockSupport

Um valor booleano que confirma se o nó obedece ao hard fork DAO.

Configuração: EIP150Block

EIP significa Ethereum Improvement Proposal. A Ethereum é de código aberto, então as pessoas fazem propostas na forma de discussões e código. Alguns são aceitos, outros rejeitados. EIP150 é uma das propostas que foi aceita.

Este EIP entrou em vigor no bloco 2463000 e teve principalmente a ver com o aumento dos preços do gas em resposta a preocupações de negação de serviço. Na implementação da mainnet de config, vemos:

EIP150Block:    MainNetHomesteadGasRepriceBlock // Comentário de Brandon: 
                                                // definido como big.NewInt(2463000)

Configuração: EIP150Hash

O hash do EIP150Block, que é necessário para sincronização rápida.

Configuração: EIP155Block

O EIP155 foi aceito para ajudar a evitar ataques de repetição.

Configuração: EIP158Block

EIP158 foi aceito para alterar como os clientes da Ethereum lidam com contas vazias. Este novo protocolo começou a tratá-las como inexistentes, economizando espaço na blockchain.

Configuração: Ethash

O protocolo de mineração Proof of Work para a mainnet. Na mainnet, esta variável config é inicializada assim:

 // MainnetChainConfig são os parâmetros da cadeia para executar um nó na mainnet.
  MainnetChainConfig = &ChainConfig{
    ...
    Ethash: new(EthashConfig),
  }

Isso simplesmente informa ao cliente que estamos usando Ethash, o algoritmo de Proof of Work da Ethereum, para mineração de blocos.

Agora que terminamos de examinar a variável config , podemos examinar o restante do arquivo genesis.json.

Alocação (alloc)

Este é o campo que determina quem começa com quantos ether para iniciar a blockchain. Na mainnet da Ethereum, isso consistia em todos os patinhos sortudos que participaram da pré-venda da Ethereum. Toda vez que iniciamos a Ethereum na mainnet, recriamos esse primeiro bloco e todas as transações iniciais para esses indivíduos.

Aqui estão alguns dos endereços na seção alloc do arquivo de estado genesis da mainnet:

{
  "alloc": {
    "3282791d6fd713f1e94f4bfd565eaa78b3a0599d": {
      "balance": "1337000000000000000000"
    },
    "17961d633bcf20a7b029a7d94b7df4da2ec5427f": {
      "balance": "229427000000000000000"
    },
    "493a67fe23decc63b10dda75f3287695a81bd5ab": {
      "balance": "880000000000000000000"
    },
    "01fb8ec12425a04f813e46c54c05748ca6b29aa9": {
      "balance": "259800000000000000000"
    }
    ...
}

Dificuldade

Este valor determina o quão difícil é minerar um bloco. Diferentes tecnologias de blockchain usam diferentes algoritmos de mineração – a mainnet da Ethereum ainda usa Proof of Work até o momento. difficulty pode ser interpretada por sua recíproca; em outras palavras, quando definido como 0x0400, significa que há uma chance de 1/1024 de sua primeira tentativa de mineração de um bloco ser bem-sucedida.

Obtemos esse valor porque 0x0400 em hexadecimal é equivalente a 1024 em decimal. A recíproca de 1024 é obviamente 1/1024, o que sugere que, em média, você pode esperar uma operação de mineração bem-sucedida após 1024 cálculos de hash. A rapidez com que você pode minerar esse bloco depende do poder de processamento que seu computador pode produzir em média 1024 cálculos de hash.

Pense nesse valor como o valor “semente” para determinar a dificuldade de minerar qualquer bloco na cadeia. Nem todo bloco terá essa dificuldade; em vez disso, esse valor é alimentado em outro lugar no cliente Ethereum para determinar algoritmicamente a dificuldade de um bloco subsequente. A dificuldade de minerar um bloco muda à medida que a blockchain cresce.

mixhash, nonce

mixhash e nonce são usados ​​juntos para determinar se o bloco foi minerado corretamente. A razão pela qual temos ambos é que, se um invasor forjar blocos com um nonce, ainda pode ser computacionalmente caro para outros nós na rede descobrir que o nonce foi falsificado. mixhash é um cálculo intermediário para encontrar o nonce que não é tão caro para determinar. Assim, se outros nós na rede descobrirem um mixhash errante ao validar um bloco, eles poderão descartar o bloco sem fazer trabalho adicional para verificar o nonce.

Eles não fazem sentido no bloco genesis, mas torná-los valores aleatórios é uma boa ideia para que outros pares não se conectem acidentalmente à sua cadeia tendo exatamente o mesmo arquivo genesis.json.

parentHash

O hash Keccak de 256 bits do cabeçalho do bloco anterior. Isso não tem sentido no bloco genesis, já que o bloco 0 não tem pai. No entanto, o objetivo ao criar o bloco genesis foi fazer com que ele tivesse o mesmo formato de qualquer outro bloco, então temos esse campo e atribuímos um valor a ele.

gasLimit

O número máximo de cálculos que qualquer bloco nessa cadeia pode suportar.

coinbase

As recompensas de ether obtidas com a “mineração” do bloco genesis vão para o endereço da coinbase de 160 bits. Isso não tem sentido no bloco genesis (especialmente porque você tem a liberdade de alocar tanto ether quanto quiser em qualquer conta), mas, novamente, o objetivo era fazer com que o bloco genesis parecesse idêntico a qualquer outro bloco na blockchain, então esses valores existem.

Timestamp

O output da função Unix time() quando o bloco foi criado.

Twitter

Para mais conteúdo Ethereum, detalhamentos e postagens de segurança de blockchain, siga @arvanaghi no Twitter.

Este artigo é uma tradução de Brandon Arvanaghi feita por Arnaldo Campos. Você pode encontrar o artigo original aqui.