From 6f18e057cd7f1c53f3b422ff61330631ca6cdb30 Mon Sep 17 00:00:00 2001 From: KoreaComK Date: Mon, 9 Aug 2021 12:47:20 -0300 Subject: [PATCH 1/6] Appendix translation concluded. --- pt/A0_Appendices.md | 22 +++ pt/A1_0_Understanding_Bitcoin_Standup.md | 51 ++++++ pt/A2_0_Compiling_Bitcoin_from_Source.md | 127 ++++++++++++++ pt/A3_0_Using_Bitcoin_Regtest.md | 206 +++++++++++++++++++++++ 4 files changed, 406 insertions(+) create mode 100644 pt/A0_Appendices.md create mode 100644 pt/A1_0_Understanding_Bitcoin_Standup.md create mode 100644 pt/A2_0_Compiling_Bitcoin_from_Source.md create mode 100644 pt/A3_0_Using_Bitcoin_Regtest.md diff --git a/pt/A0_Appendices.md b/pt/A0_Appendices.md new file mode 100644 index 0000000..c324e3f --- /dev/null +++ b/pt/A0_Appendices.md @@ -0,0 +1,22 @@ +# Apêndice + +O foco principal deste curso sugere uma configuração bastante padrão para os testes de Bitcoin. À seguir, vamos ver alguns apêndices que irão explicar melhor a configuração e algumas opções alternativas. + +## Objetivos deste apêndice + +Depois de trabalhar nestes apêndices, um desenvolvedor será capaz de: + + * Decidir entre vários métodos de como criar uma blockchain do Bitcoin. + +Os objetivos secundários do apêndice incluem a capacidade de: + + * Compreender a configuração do Bitcoin Standup; + * Fazer uma compilação de Bitcoin à mão; + * Compreender o poder do Regtest; + * Use um ambiente Regtest. + +## Tabela de conteúdo + + * [Apêndice 1: Compreendendo o Bitcoin Standup](A1_0_Understanding_Bitcoin_Standup.md) + * [Apêndice 2: Compilando Bitcoin na Fonte](A2_0_Compiling_Bitcoin_from_Source.md) + * [Apêndice 3: Usando o Bitcoin Regtest](A3_0_Using_Bitcoin_Regtest.md) \ No newline at end of file diff --git a/pt/A1_0_Understanding_Bitcoin_Standup.md b/pt/A1_0_Understanding_Bitcoin_Standup.md new file mode 100644 index 0000000..c10c2a1 --- /dev/null +++ b/pt/A1_0_Understanding_Bitcoin_Standup.md @@ -0,0 +1,51 @@ +# Apêndice 1: Compreendendo o Bitcoin Standup + +Na seção [§2.1: Configurando um Bitcoin Core VPS com StackScript](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) explicamos o processo de criação de um node de Bitcoin usando [Bitcoin-Standup-Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup -Scripts). O apêndice à seguir explica o que as principais seções do script fazem. Podemos acompanhar em [Linode Standup](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) em outra janela. + +## Etapa 1: Nome do host + +O nome do seu host é armazenado em `/etc/hostname` e definido com o comando `hostname`. Ele também aparece em `/etc/hosts`. + +## Etapa 2: Fuso horário + +O fuso horário do nosso host é armazenado em `/etc/timezone`, então um arquivo apropriado do `/usr/share/zoneinfo/` é copiado para o `/etc/localtime`. + +## Etapa 3: Atualizando o Debian + +O gerenciador de pacotes `apt-get` é usado para deixar nossa máquina atualizada e instalar o `gnupg`, o gerador de números aleatórios `haveged`, e o firewall simples `ufw`. + +Nossa máquina está configurada para se manter automaticamente atualizada com o `echo" unattended-upgrades unattended-upgrades / enable_auto_updates boolean true "| debconf-set-selections`. + +## Etapa 4: Configurando um usuário + +Um usuário `standup` é criado, o qual será usado para nossas aplicações do Bitcoin. Ele também tem permissões `sudo`, permitindo que executemos ações privilegiadas com esta usuário. + +Se fornecemos uma chave SSH, ela permitirá o acesso a esta conta (caso contrário, devemos usar a senha criada na configuração). + +Se fornecemos um endereço IP, o acesso `ssh` será limitado a esse endereço, de acordo com `/etc/hosts.allow`. + +## Etapa 5: Configurando o Tor + +O Tor é instalado para fornecer serviços protegidos (ocultos) para acessar os comandos RPC do Bitcoin através do nosso servidor. Podemos consultar a seção [§14.1: Verificando a Configuração do Tor]14_1_Verifying_Your_Tor_Setup.md) para obter mais informações sobre a configuração. + +Se criarmos um cliente autorizado para os serviços ocultos, o acesso será limitado a essa chave, que está em `/var/lib/tor/standup/authorized_clients`. Caso contrário, na seção [§14.2](14_2_Changing_Your_Bitcoin_Hidden_Services.md) explicamos como podemos fazê-la depois. + +## Etapa 6: Instalando o Bitcoin + +Bitcoin é instalado no `~standup/.bitcoin`. Nossa configuração é armazenada no `~standup/.bitcoin/bitcoin.conf`. + +Precisamos nos certificar de que as somas de verificação foram analisadas de acordo com a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), caso contrário, podemos estar expostos a um ataque à blockchain. + +## Etapa 7: Instalando o Codificador QR + +Para manter tudo compatível com [GordianSystem](https://github.com/BlockchainCommons/GordianSystem), um código QR é criado e está em `/qrcode.png`. Isso pode ser lido em um cliente QuickConnect como [GordianWallet](https://github.com/BlockchainCommons/GordianWallet-iOS). + +## Conclusão - Compreendendo o Bitcoin Standup + +O Bitcoin Standup usa scripts para tentar combinar muitas das funcionalidades de um [GordianNode](https://github.com/BlockchainCommons/GordianNode-macOS). Ele deve fornecer a nós um ambiente Bitcoin seguro construído em uma base de Bitcoin Core com Tor para nos comunicarmos com o RPC. + +## O Que Vem Depois? + +Se estivermos no processo de criação de um node Bitcoin para o uso neste curso, devemos voltar para a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md). + +Se estivermos lendo os apêndices, podemos continuar no [Apêndice 2: Compilando Bitcoin na Fonte](A2_0_Compiling_Bitcoin_from_Source.md). \ No newline at end of file diff --git a/pt/A2_0_Compiling_Bitcoin_from_Source.md b/pt/A2_0_Compiling_Bitcoin_from_Source.md new file mode 100644 index 0000000..88cf08f --- /dev/null +++ b/pt/A2_0_Compiling_Bitcoin_from_Source.md @@ -0,0 +1,127 @@ +# Apêndice 2: Compilando Bitcoin na Fonte + +Este curso presume que usará um script para criar um ambiente Bitcoin, seja usando o Bitcoin Standup do Linode de acordo com o especificado na seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), ou por algum outro meio de acordo com a seção [§2.2](02_2_Setting_Up_Bitcoin_Core_Other.md). No entanto, podemos querer compilar o Bitcoin manualmente. + +Isso tem os seguintes benefícios: + +1. Sempre estará atualizados com a versão mais recente. Mas atenção! Estar sempre atualizado não é necessário para o Bitcoin Core, pois o software é sempre compatível com versões anteriores, o que significa que uma versão antiga do Bitcoin Core ainda poderá participar da rede Bitcoin, embora possamos não ter os recursos mais recentes. Devemos sempre verificar os recursos de uma nova versão antes de atualizarmos. +2. Não precisaremos depender de binários do Bitcoin Core pré-compilados. Isso requer menos confiança. Mesmo que os mantenedores do Bitcoin Core façam um ótimo trabalho em manter a integridade do código, um binário pré-compilado é removido algumas etapas do código-fonte. Quando compilamos a partir do código-fonte, o código pode ser inspecionado antes da compilação. +3. Podemos personalizar a construção, fazendo coisas como desabilitar a carteira ou a GUI. + +## Preparando nosso ambiente + +Este tutorial usa o sistema operacional Debian 10.4.kv0 em uma arquitetura amd64 (computadores de 64 bits), mas podemos usar este tutorial em qualquer sistema baseado no Debian (por exemplo, Ubuntu, Mint, etc). Para outros sistemas Linux, podemos adaptar as etapas a seguir com o gerenciador de pacotes do sistema. + +Podemos ter pouca familiaridade ou nenhuma com a linha de comando, desde que tenhamos vontade de aprender. O terminal é o nosso aliado mais poderoso, não algo a ser temido. Podemos simplesmente copiar e colar os seguintes comandos para compilar Bitcoin. Um comando com um "$" é um comando do usuário normal e um com um "#" é um comando de super usuário/root. + +Se o nosso usuário não estiver na lista dos super usuários, podemos o seguinte: + +``` +$ su root + +# apt-get install sudo +# usermod -aG sudo +# reboot +``` + +## Instalando o Bitcoin + +### Etapa 1: atualizando nosso sistema + +Primeiro, vamos atualizar o sistema usando: +``` +$ sudo apt-get update +``` + +### Etapa 2: Instalando o Git e as dependências + +Vamos instalar o `git`, que permitirá que baixemos o código-fonte, e o `build-essential`, que compila o código: +``` +$ sudo apt-get install git build-essential -y +``` + +Depois, vamos instalar as dependências restantes: +``` +$ sudo apt-get install libtool autotools-dev automake pkg-config bsdmainutils python3 libssl-dev libevent-dev libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev libminiupnpc-dev libzmq3-dev libqt5gui5 libqt5core5a libqt5dbus5 qttools5-dev qttools5-dev-tools libprotobuf-dev protobuf-compiler ccache -y +``` + +### Etapa 3: Baixando o código-fonte + +Assim que as dependências forem instaladas, baixamos o repositório (repo) que contém o código-fonte do Bitcoin no github: +``` +$ git clone https://github.com/bitcoin/bitcoin.git +``` +Vamos verificar o conteúdo do repo: +``` +$ ls bitcoin +``` +Devemos corresponder aproximadamente ao seguinte conteúdo: + +![clonando o repo](./public/LBftCLI-compiling_bitcoin-git.png) + +### Etapa 4: Instalando o Berkley DB v4.8 + +1. Vamos entrar no diretório `contrib`:`$ cd bitcoin/contrib/`; +2. Vamos executar o seguinte comando: ```$ ./install_db4.sh `pwd` ```. + +Depois de fazer o download, veremos o seguinte retorno. Podemos observar o retorno, e o usaremos para configurar o bitcoin durante o build: + +![db4](./public/LBftCLI-compiling_bitcoin-db4.png) + +### Etapa 5: Compilando o Bitcoin Core + +É recomendado que compilemos a partir de um branch com tag, que é mais estável, a menos que queiramos experimentar as últimas novidades do desenvolvimento do bitcoin. Vamos executar o seguinte comando para obter a lista de tags, ordenada a partir das mais recentes: +``` +$ git tag -n | sort -V +``` +Em seguida, vamos escolha uma tag, por exemplo a `v0.20.0`: +``` +$ git checkout +``` + +Depois de selecionar um ramo da tag, vamos executar o seguinte, dentro do diretório `bitcoin`. O `` deve ser o retorno do script `install_db4.sh`. + +``` +$ ./autogen.sh +$ export BDB_PREFIX='/db4' +$ ./configure BDB_LIBS="-L${BDB_PREFIX}/lib -ldb_cxx-4.8" BDB_CFLAGS="-I${BDB_PREFIX}/include" +$ make # build bitcoin core +``` + +### Etapa 6: Testando o build + +Se quisermos verificar nossa compilação (o que é uma boa ideia), podemos executar os seguintes testes: + +1. `$ make check` irá executar os Testes de Unidade, que devem retornar `PASS`; +2. `$ test/functional/test_runner.py --extended` executará os testes funcionais estendidos. Podemos retirar a sinalização `--extended` se quisermos pular alguns testes. Isso vai demorar um pouco. + +### Etapa 7: Executando ou instalando o Bitcoin Core + +Agora que compilou o Bitcoin Core a partir da fonte, podemos começar a usá-lo ou instalá-lo. + +#### Executando o Bitcoin Core sem instalar + +Para executar o Bitcoin Core: + +`$ src/qt/bitcoin-qt` para iniciar a GUI; +`$ src/bitcoind` para executar bitcoin na linha de comando. + +### Instalando Bitcoin Core + +Para instalar: + +`$ sudo make install` irá instalar o Bitcoin Core globalmente. Uma vez instalado, podemos executar o bitcoin de qualquer lugar usando a linha de comando, assim como qualquer outro software, como: `$ bitcoin-qt` para a GUI ou `bitcoind` e então `bitcoin-cli` para a linha de comando. + +## Finalizando Nosso Sistema + +Ao compilar Bitcoin a partir da fonte, aumentamos a confiança que temos em nossa configuração. No entanto, estamos muito aquém de toda a segurança adicional fornecida por uma configuração Bitcoin Standup. Para resolver isso, podemos percorrer todo o [Linode Stackscript](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) e executar passo a passo todos os comandos. O único lugar que precisamos ter cuidado é na Etapa 6, que instala o Bitcoin. Pulando o ponto onde já verificamos os binários e continuemos a partir daí. + +## Resumo: Compilando Bitcoin na Fonte + +Se quisermos aumentar a segurança da instalação do Bitcoin a partir da fonte, agora podemos fazer ter isso. Felizmente, também passamos pelo Linode Stackscript para configurar um servidor mais seguro. + +## O Que Vem Depois? + +Se estávamos no processo de criação de um node de Bitcoin para usar neste curso, devemos continuar com o [Capítulo 3: Compreendendo a configuração do node Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md). + +Se estivermos lendo os apêndices, vamos continuar com o [Apêndice 3: Usando o Bitcoin Regtest](A3_0_Using_Bitcoin_Regtest.md). \ No newline at end of file diff --git a/pt/A3_0_Using_Bitcoin_Regtest.md b/pt/A3_0_Using_Bitcoin_Regtest.md new file mode 100644 index 0000000..362b5d9 --- /dev/null +++ b/pt/A3_0_Using_Bitcoin_Regtest.md @@ -0,0 +1,206 @@ +# Apêndice 3: Usando o Bitcoin Regtest + +> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. + +A maior parte deste curso presume que usaremos a Mainnet ou a Testnet. No entanto, essas não são as únicas opções. Ao desenvolver aplicações no Bitcoin, podemos querer manter nossos aplicativos isolados das blockchains públicas. Para fazer isso, podemos criar um blockchain do zero usando o Regtest, que tem uma outra grande vantagem sobre a Testnet. Escolhemos quando criar novos blocos, para ter controle total sobre o ambiente. + +## Iniciando o Bitcoind no Regtest + +Depois de [configurar nosso VPS no Bitcoin-Core ](02_0_Setting_Up_a_Bitcoin-Core_VPS.md) ou depois que o [compilamos na fonte](A2_0_Compiling_Bitcoin_from_Source.md), podemos usar o regtest. Para iniciar o `bitcoind` no regtest e criar uma Blockchain privada, iremos usar o seguinte comando: +``` +$ bitcoind -regtest -daemon -fallbackfee=1.0 -maxtxfee=1.1 +``` + +Os argumentos `-fallbackfee=1.0 -maxtxfee=1.1` irão prevenir o erro `Fee estimation failed. Fallbackfee is disabled`. + +No teste, geralmente não há transações suficientes, então o bitcoind não pode dar uma estimativa confiável e, sem ela, a carteira não criará transações a menos que seja explicitamente definida a taxa. + +### Redefinindo a Blockchain Regtest + +Se desejarmos, podemos reiniciar nossa Regtest posteriormente com uma nova blockchain. + +As carteiras do Regtest e o estado do blockchain (chainstate) são salvos no subdiretório regtest do diretório de configuração do Bitcoin: +``` +user@mybtc:~/.bitcoin# ls +bitcoin.conf regtest testnet3 +``` + +Para iniciar uma nova Blockchain usando o regtest, tudo que precisamos fazer é excluir a pasta `regtest` e reiniciar o Bitcoind: +``` +$ rm -rf regtest +``` +## Gerando uma carteira do Regtest + +Antes de gerar os blocos, é necessário carregar uma carteira usando `loadwallet` ou criar uma nova com `createwallet`. Desde a versão 0.21, o Bitcoin Core não cria automaticamente novas carteiras na inicialização. + +O argumento `descriptors=true` cria uma carteira de descritores nativos, que armazena informações no scriptPubKey usando descritores de saída. Se for `false`, ele criará uma carteira legada, onde as chaves são usadas para gerar scriptPubKeys e endereços implicitamente. +``` +$ bitcoin-cli -regtest -named createwallet wallet_name="regtest_desc_wallet" descriptors=true +``` + +## Geraando Blocos + +Podemos gerar (minerar) novos blocos em uma blockchain de regtest usando o método RPC `generate` com um argumento para quantos blocos queremos gerar. Só faz sentido usar esse método na regtest, devido à grande dificuldade, é muito improvável que ele produza novos blocos na rede principal ou na rede de teste: +``` +$ bitcoin-cli -regtest -generate 101 +[ + "57f17afccf28b9296048b6370312678b6d8e48dc3a7b4ef7681d18ed3d91c122", + "631ff7b8135ce633c774828be3b8505726459eb65c339aab981b10363befe5a7", + ... + "1162dbfe025c7da94ee1128dc26d518a94508f532c19edc0de6bc673a909d02c", + "20cb2e815c3d42d6a117a204a0b5e726ab641c826e441b5b3417aca33f2aba48" +] +``` + +> :warning: **AVISO**. Note que devemos adicionar o argumento `-regtest` após cada comando `bitcoin-cli` para acessar corretamente nosso ambiente Regtest. Se preferirmos, podemos incluir um comando `regtest=1` em nosso arquivo de configuração em `~/.bitcoin/bitcoin.conf`. + +Como um bloco deve ter 100 confirmações antes que a recompensa possa ser gasta, iremos gerar 101 blocos, fornecendo acesso à transação da coinbase do bloco #1. Como este é uma nova blockchain usando as regras padrão do Bitcoin, os primeiros blocos pagam uma recompensa de bloco de 50 bitcoins. Ao contrário do mainnet, no modo regtest apenas os primeiros 150 blocos pagam uma recompensa de 50 bitcoins. A recompensa diminui pela metade após 150 blocos, então paga 25, 12,5 e assim por diante... + +A saída é o hash de bloco de cada bloco gerado. + +> :book: ***O que é uma transação do tipo coinbase?*** Uma coinbase é a transação sem entrada criada quando um novo bloco é extraído e entregue ao minerador. É assim que novos bitcoins entram no ecossistema. O valor das transações coinbase decai com o tempo. Na rede principal, ele cai pela metade a cada 210.000 transações e termina inteiramente com o bloco 6.929.999, que está previsto atualmente para o século 22. Em maio de 2020, a recompensa pela coinbase é 6,25 BTC. + +### Verificando nosso saldo + +Depois de minerar blocos e receber as recompensas, podemos verificar o saldo em nossa carteira: +``` +$ bitcoin-cli -regtest getbalance +50.00000000 +``` + +## Usando o Regtest + +Agora devemos ser capazes de usar este saldo para qualquer tipo de interação em nossa Blockchain privada, como o envio de transações Bitcoin de acordo com o [Capítulo 4](04_0_Sending_Bitcoin_Transactions.md). + +É importante notar que para que qualquer transação seja concluída, teremos que gerar (minerar) novos blocos, para que as transações possam ser incluídas. + +Por exemplo, para criar uma transação e incluí-la em um bloco, devemos primeiro usar o comando `sendtoaddress`: +``` +$ bitcoin-cli -regtest sendtoaddress [address] 15.1 +e834a4ac6ef754164c8e3f0be4f34531b74b768199ffb244ab9f6cb1bbc7465a +``` + +A saída é o hash da transação incluída na blockchain. Podemos verificar os detalhes usando `gettransaction`: +``` +$ bitcoin-cli -regtest gettransaction e834a4ac6ef754164c8e3f0be4f34531b74b768199ffb244ab9f6cb1bbc7465a +{ + "amount": 0.00000000, + "fee": -0.00178800, + "confirmations": 0, + "trusted": false, + "txid": "e834a4ac6ef754164c8e3f0be4f34531b74b768199ffb244ab9f6cb1bbc7465a", + "walletconflicts": [ + ], + "time": 1513204730, + "timereceived": 1513204730, + "bip125-replaceable": "unknown", + "details": [ + { + "account": "", + "address": "mjtN3C97kuWMgeBbxdB7hG1bjz24Grx2vA", + "category": "send", + "amount": -15.10000000, + "label": "", + "vout": 1, + "fee": -0.00178800, + "abandoned": false + }, + { + "account": "", + "address": "mjtN3C97kuWMgeBbxdB7hG1bjz24Grx2vA", + "category": "receive", + "amount": 15.10000000, + "label": "", + "vout": 1 + } + ], + "hex": "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" +} +``` +No entanto, agora devemos finalizá-la criando blocos na blockchain. +A maioria das aplicações requer seis confirmações de bloco para considerar a transação como irreversível. Se for esse o nosso caso, podemos minerar seis blocos adicionais em nossa blockchain de teste: +``` +$ bitcoin-cli -regtest -generate 6 +[ + "33549b2aa249f0a814db4a2ba102194881c14a2ac041c23dcc463b9e4e128e9f", + "2cc5c2012e2cacf118f9db4cdd79582735257f0ec564418867d6821edb55715e", + "128aaa99e7149a520080d90fa989c62caeda11b7d06ed1965e3fa7c76fa1d407", + "6037cc562d97eb3984cca50d8c37c7c19bae8d79b8232b92bec6dcc9708104d3", + "2cb276f5ed251bf629dd52fd108163703473f57c24eac94e169514ce04899581", + "57193ba8fd2761abf4a5ebcb4ed1a9ec2e873d67485a7cb41e75e13c65928bf3" +] +``` + + +## Testando com NodeJS + +Quando estamos fazendo testes, somos capazes de simular casos extremos e ataques que podem acontecer no mundo real, como o problema de gasto duplo. + +Conforme discutido em outro lugar neste curso, o uso de bibliotecas de software pode fornecer acesso mais sofisticado a alguns comandos RPC. Nesse caso, o [bitcointest criado por dgarage](https://github.com/dgarage/bitcointest) para o NodeJS pode ser usado para simular uma transação de uma carteira para outra; podemos verificar [a documentação](https://www.npmjs.com/package/bitcointest) para simularmos ataque mais específicos, como o de gasto duplo. + +Vejamos a seção [§17.3](17_3_Accessing_Bitcoind_with_NodeJS.md) para as informações mais atualizadas sobre a instalação do NodeJS, em seguida, podemos adicionar ao `bitcointest`: +``` +$ npm install -g bitcointest +``` + +Depois de instalar o `bitcointest`, podemos criar um arquivo `test.js` com o seguinte conteúdo: +```javascript +file: test.js + +const { BitcoinNet, BitcoinGraph } = require('bitcointest'); +const net = new BitcoinNet('/usr/local/bin', '/tmp/bitcointest/', 22001, 22002); +const graph = new BitcoinGraph(net); + +try { + + console.log('Launching nodes...'); + + const nodes = net.launchBatchS(4); + const [ n1, n2 ] = nodes; + net.waitForNodesS(nodes, 20000); + + console.log('Connected!'); + const blocks = n1.generateBlocksS(110); + console.info('Generated 110 blocks'); + + console.log(`n2.balance (before) = ${n2.getBalanceS()}`); + + const sometxid = n1.sendToNodeS(n2, 100); + console.log(`Generated transaction = ${sometxid}`); + n1.generateBlocksS(110); + n2.waitForBalanceChangeS(0); + + const sometx = n2.getTransactionS(sometxid); + console.log(`n2.balance (after) = ${n2.getBalanceS()}`); + + +} catch (e) { + console.error(e); + net.shutdownS(); + throw e; +} +``` + +Conforme mostrado, isso irá gerar blocos e uma transação: +``` +$ node test.js +Launching nodes... +Connected! +Generated 110 blocks +n2.balance (before) = 0 +Generated transaction = 91e0040c26fc18312efb80bad6ec3b00202a83465872ecf495c392a0b6afce35 +n2.after (before) = 100 + +``` + +## Resumo: Usando o Bitcoin Regtest + +Um ambiente regtest para o Bitcoin funciona como qualquer ambiente testnet, exceto que teremos a capacidade de gerar blocos de maneira rápida e fácil. + + > :fire: ***Qual é o poder da regtest?*** O maior poder da regtest é que podemos minerar blocos rapidamente, permitindo que nos apressemos na blockchain, para testar transações, timelocks e outros recursos que podemos querer, caso contrário, teríamos de sentar e esperar. No entanto, o outro poder é que podemos executar de forma privada, sem nos conectarmos a uma blockchain pública, nos permitindo testar nossas ideias antes de liberá-las para o mundo. + +## O Que Vem Depois? + +Se estamos visitando o Apêndice enquanto trabalhamos em alguma outra parte do curso, devemos voltar para lá. + +Mas, caso contrário, chegamos ao fim! Outras pessoas que trabalharam neste curso tornaram-se desenvolvedores e engenheiros profissionais no mundo do Bitcoin, incluindo alguns dos quais contribuíram para o [Blockchain Commons](https://www.blockchaincommons.com/). Nós o encorajamos a fazer o mesmo! Basta sair e começar a trabalhar em alguns dos códigos do Bitcoin usando o que aprendemos. \ No newline at end of file From 00298f9e0d06b108f5f54a49ec6ca72016e56665 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 8 Sep 2021 10:45:46 -0300 Subject: [PATCH 2/6] Delete out of date files --- pt/15_0_Talking_to_Bitcoind.md | 27 -- pt/15_1_Accessing_Bitcoind_with_C.md | 294 --------------- pt/15_2_Programming_Bitcoind_with_C.md | 354 ------------------ ...Receiving_Bitcoind_Notifications_with_C.md | 155 -------- 4 files changed, 830 deletions(-) delete mode 100644 pt/15_0_Talking_to_Bitcoind.md delete mode 100644 pt/15_1_Accessing_Bitcoind_with_C.md delete mode 100644 pt/15_2_Programming_Bitcoind_with_C.md delete mode 100644 pt/15_3_Receiving_Bitcoind_Notifications_with_C.md diff --git a/pt/15_0_Talking_to_Bitcoind.md b/pt/15_0_Talking_to_Bitcoind.md deleted file mode 100644 index 88bde29..0000000 --- a/pt/15_0_Talking_to_Bitcoind.md +++ /dev/null @@ -1,27 +0,0 @@ - -# Capítulo 15: Conversando com Bitcoind usando C - -Enquanto trabalhamos com Bitcoin Scripts, atingimos os limites do que era possível com o `bitcoin-cli`: Atualmente, ele não pode ser usado para gerar transações contendo scripts incomuns. Os scripts shell também não são bons para algumas coisas, como criar programas de escuta que estão constantemente em polling. Felizmente, existem outras maneiras de acessar a rede Bitcoin: Através de APIs programáveis. - -Esta seção se concentra em três diferentes bibliotecas que podem ser usadas como base de programação C sofisticada: Uma biblioteca RPC e uma biblioteca JSON que juntas permitem recriar muito do que fazemos nos scripts de shell, porém, usando C; enquanto uma biblioteca ZMQ nos conecta a notificações, algo que não conseguiríamos acessar até agora. (O próximo capítulo cobrirá uma biblioteca ainda mais sofisticada chamada Libwally, para finalizar esta introdução à programação do Bitcoin com C). - -## Objetivos deste capítulo - -Depois de trabalhar neste capítulo, um desenvolvedor será capaz de: - - * Criar programas C que usam RPC para conversar com o Bitcoind; - * Criar programas C que usam ZMQ para conversar com o Bitcoind. - -Os objetivos secundários do capítulo incluem a capacidade de: - - * Entender como usar uma biblioteca RPC; - * Entender como usar uma biblioteca JSON; - * Compreender as capacidades do ZMQ; - * Entender como usar uma biblioteca ZMQ. - -## Tabela de conteúdo - - * [Seção 1: Acessando o Bitcoind usando C com Bibliotecas RPC](15_1_Accessing_Bitcoind_with_C.md) - * [Seção 2: Programando o Bitcoind usando C com Bibliotecas RPC](15_2_Programming_Bitcoind_with_C.md) - * [Seção 3: Recebendo notificações usando C com bibliotecas ZMQ](15_3_Receiving_Bitcoind_Notifications_with_C.md) - \ No newline at end of file diff --git a/pt/15_1_Accessing_Bitcoind_with_C.md b/pt/15_1_Accessing_Bitcoind_with_C.md deleted file mode 100644 index 2e97e1c..0000000 --- a/pt/15_1_Accessing_Bitcoind_with_C.md +++ /dev/null @@ -1,294 +0,0 @@ - -# 15.1: Acessando o Bitcoind usando C com bibliotecas RPC - -> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um esboço que ainda pode estar aguardando revisão. Portanto, leitor, tenha cuidado. - -Você já viu uma maneira alternativa de acessar as portas RPC do Bitcoind: Usando o ``curl``, que cobrimos no [Capítulo 4 Prefácio](04_4__interlude_using_curl.md). Interagir com o ``Bitcoind`` através de uma biblioteca de RPC usando C não é diferente do que já vimos, só precisamos de boas bibliotecas para nos auxiliar. Esta seção introduz um pacote chamado ``libbitcoinrpc``, que permite acessar a porta JSON-RPC do ``bitcoind``. Ele usa uma biblioteca ``curl`` para acessar os dados e usa a biblioteca ``jansson`` para codificar e decodificar o JSON. - -## Configurando o libbitcoinrpc - -Para usar o ``libbitcoinrpc``, precisaremos instalar uma configuração básica C e os pacotes dependentes, que são ``libcurl``, ``libjansson``, e ``libuuid``. Depois faremos isso no seu servidor Standup Bitcoin (ou em qualquer outro servidor Ubuntu). - -``` -$ sudo apt-get install make gcc libcurl4-openssl-dev libjansson-dev uuid-dev -Suggested packages: - libcurl4-doc libidn11-dev libkrb5-dev libldap2-dev librtmp-dev libssh2-1-dev -The following NEW packages will be installed: - libcurl4-openssl-dev libjansson-dev uuid-dev -0 upgraded, 3 newly installed, 0 to remove and 4 not upgraded. -Need to get 358 kB of archives. -After this operation, 1.696 kB of additional disk space will be used. -Do you want to continue? [Y/n] y -``` -Agora, podemos baixar o [libbitcoinrpc no github](https://github.com/gitmarek/libbitcoinrpc/blob/master/readme.md). Vamos clonar ou pegar um arquivo zip, do jeito que preferir. - -``` -$ sudo apt-get install git -$ git clone https://github.com/gitmarek/libbitcoinrpc -``` - -> :warning: **ATENÇÃO** Uma alteração no RPC "signrawtransaction" causou uma assinatura com ``libbitcoinrpc`` para o segfault no Bitcoin 0.17 ou superior. O [Pull Request foi submetido](https://github.com/gitmarek/libbitcoinrpc/pull/1/commits) para resolver o problema, mas se ainda não tiver sido feito o merge, podemos simplesmente fazer uma simples mudança no código-fonte para ``src/bitcoinrpc_method.c`` antes de compilarmos. - -### Compilando o libbitcoinrpc. - -Antes de compilarmos e instalarmos o pacote, provavelmente precisaremos ajustar nosso ``$PATH``, para que possamos acessar o ``/sbin/ldconfig``: -``` -$ PATH="/sbin:$PATH" -``` - -Para o Ubuntu, também precisaremos ajustar o ``install_libpath`` no ``makefile`` do ``libbitcoinrpc`` para instalar no ``/usr/lib`` ao invés do ``/usr/local/lib``: - -``` -$ emacs ~/libbitcoinrpc/Makefile -... -INSTALL_LIBPATH := $(INSTALL_PREFIX)/usr/lib -``` - -(Se preferir não usar o ``/usr/lib``, precisará alterar o ``etc/ld.so.conf`` ou os arquivos dependentes de maneira apropriada... Porém, para uma configuração de teste em uma máquina de teste, acredito que isso não seja um problema). - -Da mesma forma, vamos precisar ajustar o ``install_headerpath`` no ``Makefile`` do ``libbitcoinrpc`` para instalar no caminho ``/usr/include`` ao invés do ``/usr/local/inclusve``: - -``` -... -INSTALL_HEADERPATH := $(INSTALL_PREFIX)/usr/include -``` - -Agora, podemos compilar: -``` -$ cd libbitcoinrpc -~/libbitcoinrpc$ make - -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_err.o -c src/bitcoinrpc_err.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_global.o -c src/bitcoinrpc_global.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc.o -c src/bitcoinrpc.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_resp.o -c src/bitcoinrpc_resp.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_cl.o -c src/bitcoinrpc_cl.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_method.o -c src/bitcoinrpc_method.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -shared -Wl,-soname,libbitcoinrpc.so.0 \ -src/bitcoinrpc_err.o src/bitcoinrpc_global.o src/bitcoinrpc.o src/bitcoinrpc_resp.o src/bitcoinrpc_cl.o src/bitcoinrpc_method.o \ --o .lib/libbitcoinrpc.so.0.2 \ --Wl,--copy-dt-needed-entries -luuid -ljansson -lcurl -ldconfig -v -n .lib -.lib: - libbitcoinrpc.so.0 -> libbitcoinrpc.so.0.2 (changed) -ln -fs libbitcoinrpc.so.0 .lib/libbitcoinrpc.so -``` -Se tudo correr bem, podemos instalar o pacote: -``` -$ sudo make install -Installing to -install .lib/libbitcoinrpc.so.0.2 /usr/local/lib -ldconfig -n /usr/local/lib -ln -fs libbitcoinrpc.so.0 /usr/local/lib/libbitcoinrpc.so -install -m 644 src/bitcoinrpc.h /usr/local/include -Installing docs to /usr/share/doc/bitcoinrpc -mkdir -p /usr/share/doc/bitcoinrpc -install -m 644 doc/*.md /usr/share/doc/bitcoinrpc -install -m 644 CREDITS /usr/share/doc/bitcoinrpc -install -m 644 LICENSE /usr/share/doc/bitcoinrpc -install -m 644 Changelog.md /usr/share/doc/bitcoinrpc -Installing man pages -install -m 644 doc/man3/bitcoinrpc*.gz /usr/local/man/man3 -``` - -## Preparando o código - -``libbitcoinrpc`` tem métodos simples e bem estruturados para conectar-se ao nosso `bitcoind`, executando chamadas RPC e decodificando a resposta. - -Para usar o ``libbitcoinrpc``, é importante certificar de que nossos arquivos do código incluam os cabeçalhos apropriados: -``` c -#include -#include -``` - -Precisaremos também vincular as bibliotecas apropriadas sempre que possamos compilar: - -``` -$ cc yourcode.c -lbitcoinrpc -ljansson -o yourcode -``` - -## Construindo a conexão - -Para construir a conexão com o servidor ``bitcoind`` é necessário alguns simples passos. - -Primeiro, inicialize a biblioteca: -``` -bitcoinrpc_global_init(); -``` -Em seguida, vamos conectar ao ``Bitcoind`` com ``bitcoinrpc_cl_init_params``. Os quatro argumentos necessários para o ``bitcoinrpc_cl_init_params`` são o nome de usuário, a senha, o endereço IP e a porta. A esta altura, você deve saber todas essas informações, já que foram necessárias para realizar o trabalho com o [curl](04_4__interlude_using_curl.md). Apenas para recordar, o endereço de IP é 127.0.0.1 e a porta 18332 devem estar corretos para a configuração padrão da testenet descrita neste documento, enquanto podemos encontrar o usuário e a senha no arquivo ``~/.bitcoin/bitcoin.conf``. -``` -$ cat bitcoin.conf -server=1 -dbcache=1536 -par=1 -maxuploadtarget=137 -maxconnections=16 -rpcuser=StandUp -rpcpassword=6305f1b2dbb3bc5a16cd0f4aac7e1eba -rpcallowip=127.0.0.1 -debug=tor -prune=550 -testnet=1 -[test] -rpcbind=127.0.0.1 -rpcport=18332 -[main] -rpcbind=127.0.0.1 -rpcport=8332 -[regtest] -rpcbind=127.0.0.1 -rpcport=18443 -``` -Com essas informações, vamos colocá-las no ``bitcoinrpc_cl_init_params``: -``` c -bitcoinrpc_cl_t *rpc_client; -rpc_client = bitcoinrpc_cl_init_params("StandUp", "6305f1b2dbb3bc5a16cd0f4aac7e1eba", "127.0.0.1", 18332); -``` - -> **MAINNET VS TESTNET:** A porta seria a 8332 caso estivéssemos usando a configuração da rede principal. - -Se o ``rpc_client`` for inicializado com sucesso, poderemos enviar os comandos do RPC. - -Mais tarde, quando tivermos feito com a conexão de ``bitcoind``, poderemos fechar da seguinte maneira: -``` c -bitcoinrpc_global_cleanup(); -``` - -### Testando o código de teste - -O código de teste pode ser encontrado [no diretório src com o nome 15_1_testbitcoin.c](src/15_1_testbitcoin.c). Vamos fazer o download para a nossa máquina TestNet e depois inserir a senha correta do RPC (e alterar o usuário RPC se não tivermos criado o servidor com StandUp). - -Podemos compilar e executar o código da seguinte maneira: -``` -$ cc testbitcoin.c -lbitcoinrpc -ljansson -o testbitcoin -$ ./testbitcoin -Successfully connected to server! -``` - -> :warning: **ATENÇÃO:** Se esquecermos de inserir a senha RPC nesta ou em qualquer outro código que possuem dependências do RPC, receberemos um misterioso ``ERROR CODE 5``. - -## Fazendo uma chamada ao RPC - -Para usarmos um método RPC usando ``libbitcoinrpc``, devemos inicializar uma variável do tipo ``bitcoinrpc_method_t``. Podemos fazer com o valor apropriado para o método que desejamos utilizar, que estão todos listados na [Referências do BitcoinRPC](https://github.com/gitmarek/libbitcoinrpc/blob/master/doc/reference.md). -``` c -bitcoinrpc_method_t *getmininginfo = NULL; -getmininginfo = bitcoinrpc_method_init(BITCOINRPC_METHOD_GETMININGINFO); -``` -Normalmente definiríamos os parâmetros em seguida, mas o ``GetMiningInfo`` não requer parâmetros, por isso podemos pular essa parte. - -Também devemos criar outros dois objetos, um "objeto de resposta" e um "objeto de erro". Eles podem ser inicializados da seguinte forma: -``` c -bitcoinrpc_resp_t *btcresponse = NULL; -btcresponse = bitcoinrpc_resp_init(); - -bitcoinrpc_err_t btcerror; -``` -Vamos usar a variável ``rpc_client`` que aprendemos no teste anterior e vamos adicionar nosso método ``getmininginfo`` e os outros dois objetos: -``` c -bitcoinrpc_call(rpc_client, getmininginfo, btcresponse, &btcerror); -``` - -### Mostrando o retorno da chamada - -Com certeza iremos querer saber o que a RPC retornou. Para fazermos isso, vamos recuperar a saída da nossa chamada como sendo um objeto JSON com ``bitcoinrpc_resp_get`` e vamos salvá-la em um objeto padrão ``jansson``, do tipo ``json_t``: -``` c -json_t *jsonresponse = NULL; -jsonresponse = bitcoinrpc_resp_get(btcresponse); -``` -Se quisermos gerar os resultados completos da chamada RPC no JSON, podemos fazer com uma simples invocação do ``json_dumps``, da biblioteca ``jansson``: -``` c -printf("%s\n", json_dumps(j, JSON_INDENT(2))); -``` -No entanto, como agora estamos escrevendo programas completos, provavelmente iremos querer fazer um trabalho mais sutil, como retirar valores individuais do JSON para algum uso específico. A [Referência do Jansson](https6//jansson.readthedocs.Io/en/2.10/apiref.html) traz detalhes de como fazer. - -Assim como estávamos usando o [curl](04_4__interlude_using_curl.md), descobrimos que o RPC retorna um objeto JSON contendo um ``ID``, um ``error`` e, mais importante, um objeto JSON do tipo ``result``. - -A função ``json_object_get`` permite recuperar um valor (como o ``result``) de um objeto JSON usando chaves: -``` c -json_t *jsonresult = NULL; -jsonresult = json_object_get(jsonresponse,"result"); -printf("%s\n", json_dumps(jsonresult, JSON_INDENT(2))); -``` - -No entanto, provavelmente iremos querer analisar informações ainda mais profundas, para obter uma variável específica. Depois de recuperar o valor apropriado, precisaremos convertê-lo em um objeto C padrão usando a função ``JSON_*_value``. Por exemplo, para acessar um integer usamos o ``json_integer_value``: -``` c -json_t *jsonblocks = NULL; -jsonblocks = json_object_get(jsonresult,"blocks"); - -int blocks; -blocks = json_integer_value(jsonblocks); -printf("Block Count: %d\n",blocks); -``` - -> :warning: **ATENÇÃO:** É extremamente fácil ocasionar erros de segmentação no código C quando estivermos trabalhando com os objetos ``jansson`` caso fiquemos confusos com que tipo de objeto estamos recuperando. Por isso, precisamos fazer isso com cuidado usando o ``bitcoin-cli help`` para saber o que devemos esperar, e se tivermos uma falha de segmentação, primeiro precisamos analisar se nossas funções de recuperação JSON estão corretas. - -### Testando o código de informação - -Vamos recuperar o código de teste que está no [diretório src](15_1_GetMiningInfo.c). -``` -$ cc getmininginfo.c -lbitcoinrpc -ljansson -o getmininginfo -$ ./getmininginfo -Full Response: { - "result": { - "blocks": 1804406, - "difficulty": 4194304, - "networkhashps": 54842097951591.781, - "pooledtx": 127, - "chain": "test", - "warnings": "Warning: unknown new rules activated (versionbit 28)" - }, - "error": null, - "id": "474ccddd-ef8c-4e3f-93f7-fde72fc08154" -} - -Just the Result: { - "blocks": 1804406, - "difficulty": 4194304, - "networkhashps": 54842097951591.781, - "pooledtx": 127, - "chain": "test", - "warnings": "Warning: unknown new rules activated (versionbit 28)" -} - -Block Count: 1804406 -``` - -## Fazendo uma chamada RPC usando argumentos - -Mas e se a sua chamada RPC tiver argumentos? - -### Criando uma matriz JSON - -Para enviar parâmetros para a nossa chamada RPC usando ``libbitcoinrpc`` teremos que envolvê-los em uma matriz json. Como uma matriz é apenas uma simples listagem de valores, tudo o que precisamos fazer é codificar os parâmetros como elementos ordenados na matriz. - -Vamos criar a matriz JSON usando a função ``json_array do`` do ``jansson``: -``` c -json_t *params = NULL; -params = json_array(); -``` -Vamos fazer o processo inverso que fizemos para acessar valores do JSON: Vamos converter objetos no C para objetos no JSON usando as funções ``JSON_*``. Depois, vamos anexar tudo à matriz: -``` c -json_array_append_new(params,json_string(tx_rawhex)); -``` - -Observe que existem duas variantes para o comando de anexação: ``json_array_apend_new``, que acrescenta uma variável recém-criada, e ``json_array_apend``, que anexa uma variável existente. - -Esta metodologia simples ``json_array_apend_new`` servirá para a maioria dos comandos RPC com parâmetros, mas alguns dos comandos RPC exigem entradas mais complexas. Nesses casos, precisaremos criar objetos JSON ou arrays em JSON, que anexaremos ao parâmetros de array como de costume. A próxima seção contém um exemplo de como fazer isso usando o ``CrayAwTransaction``, que contém uma matriz JSON de objetos JSON para as entradas, um objeto JSON para as saídas e o parâmetro ``locktime``. - -### Atribuindo os parâmetros - -Quando criamos o parâmetro array no JSON, simplesmente o atribuímos depois de inicializar o método RPC, da seguinte maneira: -``` c -bitcoinrpc_method_set_params(rpc_method, params) -``` -Esta seção não inclui uma amostra abrangente dessa metodologia mais complexa, mas vamos vê-la em ação várias vezes no nosso primeiro programa C mais abrangente usando o RPC, na próxima seção. - -## Resumo do capítulo Acessando o Bitcoind usando C com bibliotecas RPC - -Ao vincular às bibliotecas ``BitcoinRPC`` do RPC e as bibliotecas ``jansson`` do JSON, podemos acessar facilmente o ``bitcoind`` usando chamadas RPC de uma biblioteca C. Para fazer isso, criamos uma conexão RPC, que faz as chamadas individuais de RPC, algumas delas passando alguns parâmetros. O ``jansson`` permite decodificar as respostas no formato JSON. A próxima seção demonstrará como isso pode ser usado para um programa de uso do mundo real. - -* :fire: ***Qual é o poder de C?*** O C permite que façamos o próximo passo muito além do script shell, permitindo a criação de programas mais complexos e robustos. - -## O Que Vem Depois? - -Vamos falar mais um pouco no "Conversando com o Bitcoind usando C" no capítulo [15.2: Programando o Bitcoind usando C com bibliotecas RPC](15_2_Programming_bitcoind_with_c.md). diff --git a/pt/15_2_Programming_Bitcoind_with_C.md b/pt/15_2_Programming_Bitcoind_with_C.md deleted file mode 100644 index c1fdc38..0000000 --- a/pt/15_2_Programming_Bitcoind_with_C.md +++ /dev/null @@ -1,354 +0,0 @@ - -# 15.2: Programando o Bitcoind usando C com bibliotecas RPC - -> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho que pode estar aguardando revisão. Portanto, leitor, tenha cuidado. - -A sessão [§15.1](15_1_Accessing_Bitcoind_with_C.md) apresentou a metodologia para a criação de programas C usando bibliotecas RPC e JSON. Agora vamos mostrar o potencial dessas bibliotecas C fazendo algumas coisas um pouco mais avançadas usando o programa real do Bitcoin. - -## Planejando o código - -Esta seção irá criar uma versão simples do ``sendtoaddress``, permitindo ao usuário enviar as moedas para um endereço, desde que tenha um UTXO grande o suficiente para isso. Aqui está o que precisamos fazer: - - 1. Solicitar um endereço e uma quantia; - 2. Definir uma taxa arbitrária; - 3. Preparar nosso RPC; - 4. Encontrar um UTXO que seja grande o suficiente para pagar o valor + a taxa; - 5. Criar uma mudança de endereço; - 6. Criar uma transação bruta que envie o UTXO para o endereço e altere o endereço; - 7. Assinar a transação; - 8. Enviar a transação. - -### Planejando para o futuro - -Como este é o nosso primeiro programa C funcional, vamos mantê-lo simples (ou seja, vamos usar a filosofia, _Keep it Simple_ ou também conhecida como KISS). Se estivéssemos produzindo um programa para estar em produção, desejaríamos pelo menos os seguintes passos: - - 1. Testar e/ou higienizar as entradas; - 2. Calcular uma taxa automaticamente; - 3. Pensar logicamente sobre qual UTXO seria válido utilizar; - 4. Combinar vários UTXOs, caso seja necessário; - 5. Ficar atento a mais erros nos comandos ``libbitcoinrpc`` ou no ``jansson``; - 6. Observar se há erros nas respostas RPC. - -Se deseja continuar a expandir este exemplo, seria ótimo começar a lidar com as inadequações do programa. - -## Escrevendo o sistema de transação - -Agora estamos prontos para realizar o passo a passo do nosso plano - -### Etapa 1: Solicitando um endereço e uma quantia - -Inserir as informações é bem simples se usarmos os argumentos na linha de comando: -``` c -if(argc != 3) { - - printf("ERROR: Only %i arguments! Correct usage is '%s [recipient] [amount]'\n",argc-1,argv[0]); - exit(-1); - -} - -char *tx_recipient = argv[1]; -float tx_amount = atof(argv[2]); - -printf("Sending %4.8f BTC to %s\n",tx_amount,tx_recipient); -``` - -> :aviso: **ATENÇÃO:** Um programa real precisaria de uma higienização muito melhor dessas variáveis. - -### Etapa 2: Definindo uma taxa arbitrária - -Este exemplo colocamos uma taxa arbitrária de 0.0005 BTC para garantir que as transações do teste sejam processadas rapidamente: - -``` c -float tx_fee = 0.0005; -float tx_total = tx_amount + tx_fee; -``` - -> :warning: **ATENÇÃO:** Um programa real calcularia uma taxa que minimizasse o custo, garantindo que a velocidade fosse aquela que o remetente estivesse disposto a utilizar. - -### Etapa 3: Preparando nosso RPC - -Obviamente, precisaremos preparar todas as nossas variáveis novamente, conforme discutido na sessão [§15.1: Acessando o Bitcoind usando C](15_1_Accessing_Bitcoind_with_C.md). Também precisaremos inicializar a nossa biblioteca, conectar o cliente RPC e preparar nosso objeto de resposta: -``` c -bitcoinrpc_global_init(); -rpc_client = bitcoinrpc_cl_init_params("bitcoinrpc", "YOUR-RPC-PASSWD", "127.0.0.1", 18332); -btcresponse = bitcoinrpc_resp_init(); -``` - -### Etapa 4: Encontrando um UTXO - -Para encontrar um UTXO, precisaremos chamar a função RPC ``listunspent``: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_LISTUNSPENT); -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); -``` - -No entanto, o verdadeiro trabalho consiste em decodificar a resposta. Na seção anterior vimos que a biblioteca ``jansson`` era "um tanto quanto desajeitada" e esta é a razão: Precisamos criar (e limpar) um conjunto muito grande de objetos ``json_t`` para descobrir o que queremos. - -Primeiro, precisamos nos recuperar o campo ``result`` do JSON: -``` c -json_t *lu_response = NULL; -json_t *lu_result = NULL; - -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); -``` - -> :warning: **ATENÇÃO:** Só obteremos um resultado se não houver nenhum erro. Aqui temos um momento para melhorar nossa verificação de erros no código que iremos colocar em produção. - -Em seguida, vamos fazer um laço, examinando cada transação que não foi gasta, que aparece como um elemento em sua matriz do resultado JSON: -``` c -int i; - -const char *tx_id = 0; -int tx_vout = 0; -double tx_value = 0.0; - -for(i = 0 ; i < json_array_size(lu_result) ; i++) { - - json_t *lu_data = NULL; - lu_data = json_array_get(lu_result, i); - - json_t *lu_value = NULL; - lu_value = json_object_get(lu_data,"amount"); - tx_value = json_real_value(lu_value); -``` - -O UTXO é grande o suficiente para pagar sua transação? Se sim, pegue-o! - -> :warning: **ATENÇÃO:** Um programa em produção pensaria com mais cuidado sobre qual UTXO utilizar, com base no tamanho e em outros fatores. Provavelmente não pegaria apenas o primeiro mais simples e pronto. - -``` c - if(tx_value > tx_total) { - - json_t *lu_txid = NULL; - lu_txid = json_object_get(lu_data,"txid"); - tx_id = strdup(json_string_value(lu_txid)); - - json_t *lu_vout = NULL; - lu_vout = json_object_get(lu_data,"vout"); - tx_vout = json_integer_value(lu_vout); - - json_decref(lu_value); - json_decref(lu_txid); - json_decref(lu_vout); - json_decref(lu_data); - break; - - } -``` -Você também deve limpar os principais elementos do JSON: -``` c -} - -json_decref(lu_result); -json_decref(lu_response); -``` - -> :warning: **ATENÇÃO:** Um programa em produção também se certificaria de que os UTXOs são passíveis de serem `gastos`. - -Se não encontramos nenhum UTXOs grande o suficiente, teremos que relatar este infortúnio ao usuário... E talvez, sugerir que ele deva usar um programa melhor, que irá mesclar os UTXOs de maneira correta. -``` c -if(!tx_id) { - - printf("Very Sad: You don't have any UTXOs larger than %f\n",tx_total); - exit(-1); -} -``` - -> **ATENÇÃO** Um programa em produção usaria sub-rotinas para este tipo de pesquisa, de forma que pudéssemos chamar vários RPCs de uma biblioteca de funções C. Vamos apenas colocar tudo em um `main` como parte da nossa filosofia KISS. - -### Etapa 5: Criando um endereço de troco - -Repita a metodologia padrão de pesquisa RPC para obter um endereço de troco: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_GETRAWCHANGEADDRESS); - -if(!rpc_method) { - - printf("ERROR: Unable to initialize listunspent method!\n"); - exit(-1); - -} - -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); - -if(btcerror.code != BITCOINRPCE_OK) { - -printf("Error: listunspent error code %d [%s]\n", btcerror.code,btcerror.msg); - - exit(-1); - -} - -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); -char *changeaddress = strdup(json_string_value(lu_result)); -``` -A única diferença é quais informações específicas são extraídas do objeto JSON. - -> :warning: **ATENÇÃO:** Aqui temos uma sub-rotina que seria bem legal: Abstrair toda a inicialização e chamada do método RPC. - -### Etapa 6: Criando uma transação bruta - -Criar a transação bruta real é outra parte complicada da programação da substituição do ``sendtoaddress``. Isso porque requer a criação de um objeto JSON complexo como parâmetro. - -Para criarmos esses parâmetros corretamente, precisaremos revisar o que o RPC ``createrawtransaction`` espera que passemos como argumento. Felizmente, isso é fácil de determinar usando a funcionalidade ``bitcoin-cli help``: -``` -$ bitcoin-cli help createrawtransaction -createrawtransaction [{"txid":"id","vout":n},...] {"address":amount,"data":"hex",...} ( locktime ) -``` - -Para relembrar, as entradas serão uma matriz JSON contendo um objeto JSON para cada UTXO. Então, as saídas estarão todas em um objeto JSON. É mais fácil criar esses elementos JSON de dentro para fora, usando os comandos ``jansson``. - -#### Etapa 6.1: Criando os parâmetros de entrada - -Para criar o objeto de entrada para nosso UTXO, vamos usar o ``json_object`` e preencher com os valores-chave usando ``json_object_set_new`` (para referências recém-criadas) ou ``json_object_set`` (para referências já existentes): -``` c -json_t *inputtxid = NULL; -inputtxid = json_object(); - -json_object_set_new(inputtxid,"txid",json_string(tx_id)); -json_object_set_new(inputtxid,"vout",json_integer(tx_vout)); -``` - -Pode-se notar que teremos que traduzir novamente cada tipo de variável C em um tipo de variável JSON usando a função apropriada, como ``json_string`` ou ``json_integer``. - -Para criar o array de entrada para todos os UTXOs, vamos usar o ``json_array`` e, em seguida, preenchê-lo com os objetos usando o ``json_array_append``: -``` c -json_t *inputparams = NULL; -inputparams = json_array(); -json_array_append(inputparams,inputtxid); -``` - -#### Etapa 6.2: Criando os parâmetros de saída - -Para criar a matriz de saída para a transação, vamos seguir o mesmo processo, criando um objeto JSON com ``json_object`` e, em seguida, vamos preenchê-lo com o ``json_object_set``: -``` c -json_t *outputparams = NULL; -outputparams = json_object(); - -char tx_amount_string[32]; -sprintf(tx_amount_string,"%.8f",tx_amount); -char tx_change_string[32]; -sprintf(tx_change_string,"%.8f",tx_value - tx_total); - -json_object_set(outputparams, tx_recipient, json_string(tx_amount_string)); -json_object_set(outputparams, changeaddress, json_string(tx_change_string)); -``` - -> :warning: **ATENÇÃO:** É possível pensar que teremos que inserir os valores do Bitcoin como sendo números, usando a função ``json_real``. Infelizmente, isso expõe um dos maiores problemas com a integração da biblioteca ``jansson`` e o Bitcoin. O Bitcoin só é válido até oito dígitos depois da casa decimal. Devemos nos lembrar que 0,00000001 BTC é um satoshi, e essa é a menor divisão possível de um Bitcoin. O tipo ``double`` no C oferecem mais dígitos do que precisamos, embora sejam frequentemente imprecisos depois das oito casas decimais. Se tentarmos convertê-los diretamente do nosso valor ``double`` no C (ou de um tipo ``float``, neste caso) para um valor Bitcoin, a imprecisão frequentemente criará um valor Bitcoin com mais de oito dígitos. Antes da versão Bitcoin Core 0.12, isso não era problema, e podíamos usar a função ``json_real``. Mas à partir dessa versão, se tentarmos usar a função ``createrawtransaction`` com mais do que oito dígitos, obteremos um erro e a transação não será criada. Como resultado, se o valor do Bitcoin _sempre_ se tornar um ``double`` ou ``float``, devemos deixar com apenas oito casas decimais antes de transformá-lo em uma ``string``. Obviamente, isso é um erro, portanto, certifique-se disso para que o código continue funcionando nas versões mais novas do Bitcoin Core. - -#### Etapa 6.3: Criando a Matriz de Parâmetros - -Para terminarmos de criar os parâmetros, só precisaremos agrupá-los em uma matriz JSON: -``` c -json_t *params = NULL; -params = json_array(); -json_array_append(params,inputparams); -json_array_append(params,outputparams); -``` - -#### Etapa 6.4: Fazendo a chamada ao RPC - -Vamos usar o método normal para criar uma chamada ao RPC: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_CREATERAWTRANSACTION); -``` -Agora, porém, devemos adicionar os nossos parâmetros. Isso pode ser feito facilmente com a função ``bitcoinrpc_method_set_params``: -``` c -if(bitcoinrpc_method_set_params(rpc_method, params) != BITCOINRPCE_OK) { - - fprintf(stderr, "Error: Could not set params for createrawtransaction"); - -} -``` -Depois, é só executar o RPC e obter os resultados: -``` c -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); - -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); - -char *tx_rawhex = strdup(json_string_value(lu_result)); -``` -### Etapa 7. Assinando a transação - -É muito mais fácil atribuir um parâmetro simples a uma função. Basta criar uma matriz JSON e, em seguida, atribuir o parâmetro à matriz: -``` c -params = json_array(); -json_array_append_new(params,json_string(tx_rawhex)); -``` -Por fim, vamos assinar a transação seguindo o rigamarole típico para criar uma chamada RPC: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_SIGNRAWTRANSACTION); -if(bitcoinrpc_method_set_params(rpc_method, params) != BITCOINRPCE_OK) { - - fprintf(stderr, "Error: Could not set params for signrawtransaction"); - -} - -json_decref(params); - -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); -lu_response = bitcoinrpc_resp_get(btcresponse); -``` -Novamente, usar a função ``jansson`` para acessar a saída pode ser complicado. Devemos lembrar que ``hex`` é parte de um objeto JSON, não um resultado independente, como era quando criamos a transação bruta. Claro, sempre podemos acessar essas informações a partir da ajuda da linha de comando: ``bitcoin-cli help signrawtransaction`` -``` c -lu_result = json_object_get(lu_response,"result"); -json_t *lu_signature = json_object_get(lu_result,"hex"); -char *tx_signrawhex = strdup(json_string_value(lu_signature)); -json_decref(lu_signature); -``` -> :warning: ***ATENÇÃO:*** Um programa em produção obviamente iria testar cuidadosamente a resposta de cada comando RPC para se certificar de que não teria erros. Isso é ainda mais verdadeiro para a função ``signrawtransaction``, porque podemos acabar com uma transação parcialmente assinada. Ou ainda pior, se não verificarmos os erros no objeto JSON, veremos apenas o ``hex`` e não iremos saber que ele não está assinado ou se está parcialmente assinado. - -### Etapa 8. Enviando a transação - -Agora podemos enviar a transação, usando todas as técnicas aprendidas anteriormente: -``` c -params = json_array(); -json_array_append_new(params,json_string(tx_signrawhex)); - -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_SENDRAWTRANSACTION); - -if(bitcoinrpc_method_set_params(rpc_method, params) != BITCOINRPCE_OK) { - - fprintf(stderr, "Error: Could not set params for sendrawtransaction"); - -} - -json_decref(params); - -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); - -char *tx_newid = strdup(json_string_value(lu_result)); - -printf("Txid: %s\n",tx_newid); -``` - -O código inteiro, com um _pouco_ mais verificação de erros, está disponível no Apêndice. - -## Testando o código - -O código completo pode ser encontrado no [diretório src/](src/15_2_sendtoaddress.c). - -Compile-o como de costume: -``` -$ cc sendtoaddress.c -lbitcoinrpc -ljansson -o sendtoaddress -``` -Agora, é possível utilizá-lo para enviar fundos para um endereço: - -``` -./sendtoaddress tb1qynx7f8ulv4sxj3zw5gqpe56wxleh5dp9kts7ns .001 -Txid: b93b19396f8baa37f5f701c7ca59d3128144c943af5294aeb48e3eb4c30fa9d2 -``` -Você pode ver as informações sobre esta transação que enviamos clicando [aqui](https://mempool.space/pt/testnet/tx/b93b19396f8baa37f5f701c7ca59d3128144c943af5294aeb48e3eb4c30fa9d2/). - -## Resumo do Programando o Bitcoind usando C com bibliotecas RPC - -Com acesso a uma biblioteca C, podemos criar programas com muito mais recursos quando comparados aos scripts no shell. Mas isso pode dar muito trabalho! Mesmo com 316 linhas de código, o ``sendtoaddress.c`` não cobre todos os detalhes necessários para transacionar bitcoins de forma segura e inteligente. - -## O Que Vem Depois? - -Aprenda mais sobre "Programando o Bitcoind usando C" na próxima sessão [15.3: Recebendo notificações usando C com a biblioteca ZMQ](15_3_Receiving_Bitcoind_Notifications_with_C.md). \ No newline at end of file diff --git a/pt/15_3_Receiving_Bitcoind_Notifications_with_C.md b/pt/15_3_Receiving_Bitcoind_Notifications_with_C.md deleted file mode 100644 index fe166ac..0000000 --- a/pt/15_3_Receiving_Bitcoind_Notifications_with_C.md +++ /dev/null @@ -1,155 +0,0 @@ - -# 15.3 Recebendo notificações usando C com a biblioteca ZMQ - -> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho que pode estar aguardando revisão. Portanto, leitor, tenha cuidado. - -As sessões [§15.1](15_1_Accessing_Bitcoind_with_C.md) e [§15.2](15_2_Programming_Bitcoind_with_C.md) introduziram as bibliotecas RPC e JSON no C e, também mostrou uma das vantagens de acessar os comandos RPC do Bitcoin por meio de uma linguagem de programação: A capacidade de criar programas razoavelmente complexos. Este capítulo apresenta uma terceira biblioteca, a [ZMQ](http://zeromq.org/) e, ao fazer isso, revela outra vantagem: A capacidade de monitorar as notificações. Iremos usá-la para codificar para ouvirmos a blockchain. - -> :book: ***O que é ZMQ?*** O ZeroMQ (ZMQ) é uma biblioteca de mensagens assíncronas de alto desempenho que fornece uma fila de mensagens. A biblioteca oferece suporte a padrões de mensagens comuns (pub/sub, request/reply, client/server e outros) em uma variedade de transportes (TCP, in-process, inter-process, multicast, WebSocket e mais), tornando mensagens entre processos tão simples quanto mensagens entre threads. Podemos encontrar mais detalhes sobre as notificações do ZMQ e outros tipos de mensagens [neste repositório](https://github.com/Actinium-project/ChainTools/blob/master/docs/chainlistener.md). - -## Configurando o ZMQ - -Antes de podemos ouvir a blockchain, precisaremos configurar o ``bitcoind`` para permitir as notificações ZMQ. Por isso, precisamos instalar a biblioteca ZMQ para tirar proveito dessas notificações. - -### Configurando o ``bitcoind`` para usar o ZMQ - -O Bitcoin Core está pronto para ZMQ, mas devemos especificar os endpoints do ZMQ. O ZeroMQ publish-sockets prefixa cada item de dados com um prefixo de tópico arbitrário que permite aos clientes assinantes solicitarem apenas os itens com um prefixo correspondente. Existem atualmente quatro tópicos suportados pelo ``bitcoind``: -``` -$ bitcoind --help | grep zmq | grep address - -zmqpubhashblock=
- -zmqpubhashtx=
- -zmqpubrawblock=
- -zmqpubrawtx=
-``` - -Podemos executar o ``bitcoind`` com argumentos de linha de comando para endpoints ZMQ, como mostrado acima, mas também podemos criar um endpoint acessível adicionando linhas apropriadas ao nosso arquivo ``~/.bitcoin/bitcoin.conf`` e reiniciando o sistema. - -``` -zmqpubrawblock=tcp://127.0.0.1:28332 -zmqpubrawtx=tcp://127.0.0.1:28333 -``` -Podemos então testar se os nossos endpoints estão funcionando usando o RPC ``getzmqnotifications``: - -``` -$ bitcoin-cli getzmqnotifications -[ - { - "type": "pubrawblock", - "address": "tcp://127.0.0.1:28332", - "hwm": 1000 - }, - { - "type": "pubrawtx", - "address": "tcp://127.0.0.1:28333", - "hwm": 1000 - } -] -``` -Nosso ``bitcoind`` agora irá emitir as notificações ZMQ - -### Instalando o ZMQ - -Para aproveitar essas notificações, precisamos de uma biblioteca ZMQ para usar com o C, portanto, estaremos usando uma nova biblioteca ZMQ ao invés da biblioteca ``libbitcoinrpc`` nesta seção, mas no futuro, podemos combinar ambas. - -Felizmente, as bibliotecas ZMQ estão disponíveis por meio de pacotes Debian padrão: -``` -$ sudo apt-get install libzmq3-dev -$ sudo apt-get install libczmq-dev -``` -Agora estamos pronto para escrever o código! - -## Escrevendo o programa de notificação - -O programa C à seguir é um cliente simples que se inscreve em um ponto da conexão ZMQ servido pelo ``bitcoind`` e lê as mensagens recebidas. - -O programa requer dois parâmetros: O primeiro é o "servidor", que é o ponto de conexão TCP exposto pelo ``bitcoind``. O segundo é o "tópico", que atualmente é o ``zmqpubhashblock``,``zmqpubhashtx``, ``zmqpubrawblock`` ou ``zmqpubrawtx``. O tópico precisa ter suporte do ``bitcoin.conf`` e o endereço IP e a porta do servidor devem corresponder ao que está definido no arquivo de configuração. - -``` c -#include -int main(int argc, char ** argv) { - - char *zmqserver; - char *topic; - - if(argc < 3) { - printf("\nUSAGE:\nchainlistener \n\n"); - return 0; - } else { - zmqserver = argv[1]; - topic = argv[2]; - } -``` -Abriremos um soquete ZMQ para o servidor e para o tópico definido: -``` c - zsock_t *socket = zsock_new_sub(zmqserver, topic); - assert(socket); -``` -Depois, vamos esperar: -``` c - while(1) { - zmsg_t *msg; - int rc = zsock_recv(socket, "m", &msg); - assert(rc == 0); - - char *header = zmsg_popstr(msg); - zframe_t *zdata = zmsg_pop(msg); - unsigned int *no = (unsigned int*)zmsg_popstr(msg); - - char *data = zframe_strhex(zdata); - int len = zframe_size(zdata); - printf("Size: %d\n", len); - printf("Data: %s", data); - printf("\nNo: %d\n", *no); - - free(header); - free(data); - free(no); - free(zdata); - zmsg_destroy(&msg); - sleep(1); - } -``` -Enquanto esperamos, observamos as mensagens no soquete ZMQ. Sempre que recebermos uma mensagem, iremos retirá-la da pilha, relatando o número, comprimento e, o os dados que foram importante para nós. - -É isso! - -Claro, quando terminar o processo, precisamos limpar tudo: -``` c - zsock_destroy(&socket); - return 0; -} -``` - -### Testando o código de notificação - -O código-fonte completo está no [diretório src/](src/15_3_chainlistener.c) como de costume. Precisamos compilá-lo: -``` -$ cc -o chainlistener chainlistener.c -I/usr/local/include -L/usr/local/lib -lzmq -lczmq -``` -Depois, podemos executá-lo com os tópicos e endereços que definimos no nosso ``bitcoin.conf``: -``` -$ ./chainlistener tcp://127.0.0.1:28333 rawtx -Size: 250 -Data: 02000000000101F5BD2032E5A9E6650D4E411AD272E391F26AFC3C9102B7C0C7444F8F74AE86010000000017160014AE9D51ADEEE8F46ED2017F41CD631D210F2ED9C5FEFFFFFF0203A732000000000017A9147231060F1CDF34B522E9DB650F44EDC6C0714E4C8710270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC02483045022100AE316D5F21657E3525271DE39EB285D8A0E89A20AB6413824E88CE47DCD0EFE702202F61E10C2A8F4A7125D5EB63AEF883D8E3584A0ECED0D349283AABB6CA5E066D0121035A77FE575A9005E3D3FF0682E189E753E82FA8BFF0A20F8C45F06DC6EBE3421079111B00 -No: 67 -Size: 249 -Data: 0200000000010165C986992F7DAD22BBCE3FCF0BF546EDBC3C599618B04CFA22D9E64EF0CE4C030000000017160014B58E0A5CD68B249F1C407E9AAE9CD0332AAA3067FEFFFFFF02637932000000000017A914CCC47261489036CB6B9AA610857793FF5752E5378710270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC0247304402206CCC3F3B4BE01D4E532A01C2DC6BC3B53E4FFB6B494C8B87DD603EFC648A159902201653841E8B16A814DC375129189BB7CF01CFF7D269E91178645B6A97F5C7F4F10121030E20F3D2F172281B8DC747F007DF24B352248AC09E48CA64016942A8F01D317079111B00 -No: 68 -Size: 250 -Data: 02000000000101E889CFC1FFE127BA49F6C1011388606A194109AE1EDAAB9BEE215E123C14A7920000000017160014577B0B3C2BF91B33B5BD70AE9E8BD8144F4B87E7FEFFFFFF02C34B32000000000017A914A9F1440402B46235822639C4FD2F78A31E8D269E8710270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC02483045022100B46318F53E1DCE63E7109DB4FA54AF40AADFC2FEB0E08263756BC3B7A6A744CB02200851982AF87DBABDC3DFC3362016ECE96AECFF50E24D9DCF264AE8966A5646FE0121039C90FCB46AEA1530E5667F8FF15CB36169D2AD81247472F236E3A3022F39917079111B00 -No: 69 -Size: 250 -Data: 0200000000010137527957C9AD6CFF0C9A74597E6EFCD7E1EBD53E942AB2FA34A831046CA11488000000001716001429BFF05B3CD79E9CCEFDB5AE82139F72EB3E9DB0FEFFFFFF0210270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC231E32000000000017A9146C8D5FE29BFDDABCED0D6F4D8E82DCBFD9D34A8B8702483045022100F259846BAE29EB2C7A4AD711A3BC6109DE69AE91E35B14CA2742157894DD9760022021464E09C00ABA486AEAA0C49FEE12D2850DC03F57F04A1A9E2CC4D0F4F1459C012102899F24A9D60132F4DD1A5BA6DCD1E4E4B6C728927BA482C2C4E511679F60CA5779111B00 -No: 70 -....... -``` - -### Resumo do capítulo Recebendo Notificações Usando C com a Biblioteca ZMQ - -Ao usar a estrutura ZMQ, podemos receber notificações facilmente, inscrevendo-as em um ponto de conexão exposto pelo ``bitcoind`` através do nosso arquivo de configuração. - -> :fire: ***Qual é o poder das notificações?*** Com as notificações, não dependemos mais dos usuários para emitir os comandos. Ou seja, podemos criar programas que monitoram o blockchain do Bitcoin e tomar as ações apropriadas quando certas coisas ocorrem. Isso, por sua vez, pode ser utilizado juntamente com os comandos RPC que programamos nas seções anteriores. Este também é um grande passo além do que poderíamos fazer com os scripts shell: Certamente, podemos criar scripts shell que fica ouvindo infinitamente, mas existem outras linguagens de programação que possuem ferramentas melhores para isso. - -## O Que Vem Depois? - -Saiba mais sobre "como Programar com RPC" no [Capítulo 16: Programando Bitcoin com Libwally](16_0_Programming_with_Libwally.md). \ No newline at end of file From 786c307a09688f43b88cc77a5519064e767c0c44 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 8 Sep 2021 10:51:13 -0300 Subject: [PATCH 3/6] Review A0 --- pt/A0_Appendices.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/pt/A0_Appendices.md b/pt/A0_Appendices.md index c324e3f..da03947 100644 --- a/pt/A0_Appendices.md +++ b/pt/A0_Appendices.md @@ -1,12 +1,12 @@ -# Apêndice +# Apêndices -O foco principal deste curso sugere uma configuração bastante padrão para os testes de Bitcoin. À seguir, vamos ver alguns apêndices que irão explicar melhor a configuração e algumas opções alternativas. +O foco principal deste curso sugere uma configuração bastante padrão para os testes de Bitcoin. À seguir, vamos ver alguns apêndices que irão explicar melhor dessa configuração e algumas opções alternativas. -## Objetivos deste apêndice +## Objetivos desta Seção Depois de trabalhar nestes apêndices, um desenvolvedor será capaz de: - * Decidir entre vários métodos de como criar uma blockchain do Bitcoin. + * Decidir entre vários métodos de como criar uma blockchain do Bitcoin. Os objetivos secundários do apêndice incluem a capacidade de: @@ -15,8 +15,8 @@ Os objetivos secundários do apêndice incluem a capacidade de: * Compreender o poder do Regtest; * Use um ambiente Regtest. -## Tabela de conteúdo +## Tabela de Conteúdo * [Apêndice 1: Compreendendo o Bitcoin Standup](A1_0_Understanding_Bitcoin_Standup.md) - * [Apêndice 2: Compilando Bitcoin na Fonte](A2_0_Compiling_Bitcoin_from_Source.md) - * [Apêndice 3: Usando o Bitcoin Regtest](A3_0_Using_Bitcoin_Regtest.md) \ No newline at end of file + * [Apêndice 2: Compilando Bitcoin da Fonte](A2_0_Compiling_Bitcoin_from_Source.md) + * [Apêndice 3: Usando o Regtest do Bitcoin](A3_0_Using_Bitcoin_Regtest.md) \ No newline at end of file From 787affa4d6e4a94fd83ea2332635fe8ad9e42f55 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 8 Sep 2021 10:56:31 -0300 Subject: [PATCH 4/6] Review A1 --- pt/A1_0_Understanding_Bitcoin_Standup.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/pt/A1_0_Understanding_Bitcoin_Standup.md b/pt/A1_0_Understanding_Bitcoin_Standup.md index c10c2a1..1e04418 100644 --- a/pt/A1_0_Understanding_Bitcoin_Standup.md +++ b/pt/A1_0_Understanding_Bitcoin_Standup.md @@ -1,12 +1,12 @@ # Apêndice 1: Compreendendo o Bitcoin Standup -Na seção [§2.1: Configurando um Bitcoin Core VPS com StackScript](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) explicamos o processo de criação de um node de Bitcoin usando [Bitcoin-Standup-Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup -Scripts). O apêndice à seguir explica o que as principais seções do script fazem. Podemos acompanhar em [Linode Standup](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) em outra janela. +Na seção [§2.1: Configurando um Bitcoin Core VPS com StackScript](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) explicamos o processo de criação de um node de Bitcoin usando [Bitcoin-Standup-Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). O apêndice à seguir explica o que as principais seções do script fazem. Podemos acompanhar em [Linode Standup](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) em outra janela. -## Etapa 1: Nome do host +## Etapa 1: Nome do Host O nome do seu host é armazenado em `/etc/hostname` e definido com o comando `hostname`. Ele também aparece em `/etc/hosts`. -## Etapa 2: Fuso horário +## Etapa 2: Fuso Horário O fuso horário do nosso host é armazenado em `/etc/timezone`, então um arquivo apropriado do `/usr/share/zoneinfo/` é copiado para o `/etc/localtime`. @@ -14,11 +14,11 @@ O fuso horário do nosso host é armazenado em `/etc/timezone`, então um arquiv O gerenciador de pacotes `apt-get` é usado para deixar nossa máquina atualizada e instalar o `gnupg`, o gerador de números aleatórios `haveged`, e o firewall simples `ufw`. -Nossa máquina está configurada para se manter automaticamente atualizada com o `echo" unattended-upgrades unattended-upgrades / enable_auto_updates boolean true "| debconf-set-selections`. +Nossa máquina está configurada para se manter automaticamente atualizada com o `echo "unattended-upgrades unattended-upgrades / enable_auto_updates boolean true "| debconf-set-selections`. -## Etapa 4: Configurando um usuário +## Etapa 4: Configurando um Usuário -Um usuário `standup` é criado, o qual será usado para nossas aplicações do Bitcoin. Ele também tem permissões `sudo`, permitindo que executemos ações privilegiadas com esta usuário. +Um usuário `standup` é criado, o qual será usado para nossas aplicações do Bitcoin. Ele também tem permissões `sudo`, permitindo que executemos ações privilegiadas com este usuário. Se fornecemos uma chave SSH, ela permitirá o acesso a esta conta (caso contrário, devemos usar a senha criada na configuração). @@ -26,7 +26,7 @@ Se fornecemos um endereço IP, o acesso `ssh` será limitado a esse endereço, d ## Etapa 5: Configurando o Tor -O Tor é instalado para fornecer serviços protegidos (ocultos) para acessar os comandos RPC do Bitcoin através do nosso servidor. Podemos consultar a seção [§14.1: Verificando a Configuração do Tor]14_1_Verifying_Your_Tor_Setup.md) para obter mais informações sobre a configuração. +O Tor é instalado para fornecer serviços protegidos (ocultos) para acessar os comandos RPC do Bitcoin através do nosso servidor. Podemos consultar a seção [§14.1: Verificando a Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md) para obter mais informações sobre a configuração do Tor. Se criarmos um cliente autorizado para os serviços ocultos, o acesso será limitado a essa chave, que está em `/var/lib/tor/standup/authorized_clients`. Caso contrário, na seção [§14.2](14_2_Changing_Your_Bitcoin_Hidden_Services.md) explicamos como podemos fazê-la depois. @@ -34,7 +34,7 @@ Se criarmos um cliente autorizado para os serviços ocultos, o acesso será limi Bitcoin é instalado no `~standup/.bitcoin`. Nossa configuração é armazenada no `~standup/.bitcoin/bitcoin.conf`. -Precisamos nos certificar de que as somas de verificação foram analisadas de acordo com a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), caso contrário, podemos estar expostos a um ataque à blockchain. +Precisamos nos certificar de que as somas de verificação (checksum) foram analisadas de acordo com a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), caso contrário, podemos estar expostos a um ataque de cadeia de produção. ## Etapa 7: Instalando o Codificador QR @@ -48,4 +48,4 @@ O Bitcoin Standup usa scripts para tentar combinar muitas das funcionalidades de Se estivermos no processo de criação de um node Bitcoin para o uso neste curso, devemos voltar para a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md). -Se estivermos lendo os apêndices, podemos continuar no [Apêndice 2: Compilando Bitcoin na Fonte](A2_0_Compiling_Bitcoin_from_Source.md). \ No newline at end of file +Se estivermos lendo os apêndices, podemos continuar no [Apêndice 2: Compilando Bitcoin da Fonte](A2_0_Compiling_Bitcoin_from_Source.md). \ No newline at end of file From fdd3234dac347bcad20d62ddcd0c12bdf4c3d8e3 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 8 Sep 2021 11:08:58 -0300 Subject: [PATCH 5/6] Review A2 --- pt/A2_0_Compiling_Bitcoin_from_Source.md | 44 ++++++++++++------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/pt/A2_0_Compiling_Bitcoin_from_Source.md b/pt/A2_0_Compiling_Bitcoin_from_Source.md index 88cf08f..cc24de8 100644 --- a/pt/A2_0_Compiling_Bitcoin_from_Source.md +++ b/pt/A2_0_Compiling_Bitcoin_from_Source.md @@ -1,39 +1,39 @@ -# Apêndice 2: Compilando Bitcoin na Fonte +# Apêndice 2: Compilando Bitcoin da Fonte -Este curso presume que usará um script para criar um ambiente Bitcoin, seja usando o Bitcoin Standup do Linode de acordo com o especificado na seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), ou por algum outro meio de acordo com a seção [§2.2](02_2_Setting_Up_Bitcoin_Core_Other.md). No entanto, podemos querer compilar o Bitcoin manualmente. +Este curso presume o uso de um script para criar um ambiente Bitcoin, seja usando o Bitcoin Standup do Linode de acordo com o especificado na seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), ou por algum outro meio de acordo com a seção [§2.2](02_2_Setting_Up_Bitcoin_Core_Other.md). No entanto, podemos querer compilar o Bitcoin manualmente. Isso tem os seguintes benefícios: -1. Sempre estará atualizados com a versão mais recente. Mas atenção! Estar sempre atualizado não é necessário para o Bitcoin Core, pois o software é sempre compatível com versões anteriores, o que significa que uma versão antiga do Bitcoin Core ainda poderá participar da rede Bitcoin, embora possamos não ter os recursos mais recentes. Devemos sempre verificar os recursos de uma nova versão antes de atualizarmos. -2. Não precisaremos depender de binários do Bitcoin Core pré-compilados. Isso requer menos confiança. Mesmo que os mantenedores do Bitcoin Core façam um ótimo trabalho em manter a integridade do código, um binário pré-compilado é removido algumas etapas do código-fonte. Quando compilamos a partir do código-fonte, o código pode ser inspecionado antes da compilação. +1. Sempre estará atualizado com a versão mais recente. Mas atenção! Estar sempre atualizado não é necessário para o Bitcoin Core, pois o software é sempre compatível com versões anteriores, o que significa que uma versão antiga do Bitcoin Core ainda poderá participar da rede Bitcoin, embora possamos não ter os recursos mais recentes. Devemos sempre verificar os recursos de uma nova versão antes de atualizarmos. +2. Não precisaremos depender de binários do Bitcoin Core pré-compilados. Isso requer menos confiança. Mesmo que os mantenedores do Bitcoin Core façam um ótimo trabalho em manter a integridade do código, algumas etapas do código-fonte são removidas de um binário pré-compilado. Quando compilamos a partir do código-fonte, o código pode ser inspecionado antes da compilação. 3. Podemos personalizar a construção, fazendo coisas como desabilitar a carteira ou a GUI. -## Preparando nosso ambiente +## Preparando Nosso Ambiente Este tutorial usa o sistema operacional Debian 10.4.kv0 em uma arquitetura amd64 (computadores de 64 bits), mas podemos usar este tutorial em qualquer sistema baseado no Debian (por exemplo, Ubuntu, Mint, etc). Para outros sistemas Linux, podemos adaptar as etapas a seguir com o gerenciador de pacotes do sistema. -Podemos ter pouca familiaridade ou nenhuma com a linha de comando, desde que tenhamos vontade de aprender. O terminal é o nosso aliado mais poderoso, não algo a ser temido. Podemos simplesmente copiar e colar os seguintes comandos para compilar Bitcoin. Um comando com um "$" é um comando do usuário normal e um com um "#" é um comando de super usuário/root. +Podemos ter pouca ou nenhuma familiaridade com a linha de comando, desde que tenhamos vontade de aprender. O terminal é o nosso aliado mais poderoso, e não algo a ser temido. Podemos simplesmente copiar e colar os seguintes comandos para compilar o Bitcoin. Um comando com um "$" é um comando do usuário normal e um com um "#" é um comando de super usuário/root. Se o nosso usuário não estiver na lista dos super usuários, podemos o seguinte: ``` $ su root - + # apt-get install sudo -# usermod -aG sudo +# usermod -aG sudo # reboot ``` ## Instalando o Bitcoin -### Etapa 1: atualizando nosso sistema +### Etapa 1: Atualizando Nosso Sistema Primeiro, vamos atualizar o sistema usando: ``` $ sudo apt-get update ``` -### Etapa 2: Instalando o Git e as dependências +### Etapa 2: Instalando o Git e as Dependências Vamos instalar o `git`, que permitirá que baixemos o código-fonte, e o `build-essential`, que compila o código: ``` @@ -45,7 +45,7 @@ Depois, vamos instalar as dependências restantes: $ sudo apt-get install libtool autotools-dev automake pkg-config bsdmainutils python3 libssl-dev libevent-dev libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev libminiupnpc-dev libzmq3-dev libqt5gui5 libqt5core5a libqt5dbus5 qttools5-dev qttools5-dev-tools libprotobuf-dev protobuf-compiler ccache -y ``` -### Etapa 3: Baixando o código-fonte +### Etapa 3: Baixando o Código-Fonte Assim que as dependências forem instaladas, baixamos o repositório (repo) que contém o código-fonte do Bitcoin no github: ``` @@ -64,7 +64,7 @@ Devemos corresponder aproximadamente ao seguinte conteúdo: 1. Vamos entrar no diretório `contrib`:`$ cd bitcoin/contrib/`; 2. Vamos executar o seguinte comando: ```$ ./install_db4.sh `pwd` ```. -Depois de fazer o download, veremos o seguinte retorno. Podemos observar o retorno, e o usaremos para configurar o bitcoin durante o build: +Depois de fazer o download, veremos o seguinte retorno. Devemos observar bem este retorno, porque o usaremos para configurar o bitcoin durante o build: ![db4](./public/LBftCLI-compiling_bitcoin-db4.png) @@ -88,25 +88,25 @@ $ ./configure BDB_LIBS="-L${BDB_PREFIX}/lib -ldb_cxx-4.8" BDB_CFLAGS="-I${BDB_PR $ make # build bitcoin core ``` -### Etapa 6: Testando o build +### Etapa 6: Testando o Build Se quisermos verificar nossa compilação (o que é uma boa ideia), podemos executar os seguintes testes: -1. `$ make check` irá executar os Testes de Unidade, que devem retornar `PASS`; +1. `$ make check` irá executar os Testes de Unidade (unit tests), que devem retornar `PASS`; 2. `$ test/functional/test_runner.py --extended` executará os testes funcionais estendidos. Podemos retirar a sinalização `--extended` se quisermos pular alguns testes. Isso vai demorar um pouco. -### Etapa 7: Executando ou instalando o Bitcoin Core +### Etapa 7: Executando ou Instalando o Bitcoin Core -Agora que compilou o Bitcoin Core a partir da fonte, podemos começar a usá-lo ou instalá-lo. +Agora que compilamos o Bitcoin Core a partir da fonte, podemos começar a usá-lo ou instalá-lo. -#### Executando o Bitcoin Core sem instalar +#### Executando o Bitcoin Core sem Instalar Para executar o Bitcoin Core: `$ src/qt/bitcoin-qt` para iniciar a GUI; `$ src/bitcoind` para executar bitcoin na linha de comando. -### Instalando Bitcoin Core +### Instalando o Bitcoin Core Para instalar: @@ -114,14 +114,14 @@ Para instalar: ## Finalizando Nosso Sistema -Ao compilar Bitcoin a partir da fonte, aumentamos a confiança que temos em nossa configuração. No entanto, estamos muito aquém de toda a segurança adicional fornecida por uma configuração Bitcoin Standup. Para resolver isso, podemos percorrer todo o [Linode Stackscript](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) e executar passo a passo todos os comandos. O único lugar que precisamos ter cuidado é na Etapa 6, que instala o Bitcoin. Pulando o ponto onde já verificamos os binários e continuemos a partir daí. +Ao compilar Bitcoin a partir da fonte, aumentamos a confiança que temos em nossa configuração. No entanto, estamos muito aquém de toda a segurança adicional fornecida por uma configuração Bitcoin Standup. Para resolver isso, podemos percorrer todo o [Linode Stackscript](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) e executar passo a passo todos os comandos. O único lugar que precisamos ter cuidado é na Etapa 6, que instala o Bitcoin, pulando o ponto onde já verificamos os binários e continando a partir daí. -## Resumo: Compilando Bitcoin na Fonte +## Resumo: Compilando Bitcoin da Fonte -Se quisermos aumentar a segurança da instalação do Bitcoin a partir da fonte, agora podemos fazer ter isso. Felizmente, também passamos pelo Linode Stackscript para configurar um servidor mais seguro. +Se quisermos aumentar a segurança da instalação do Bitcoin a partir da fonte, agora sabemos fazê-lo. Felizmente, também passamos pelo Linode Stackscript para configurar um servidor mais seguro. ## O Que Vem Depois? -Se estávamos no processo de criação de um node de Bitcoin para usar neste curso, devemos continuar com o [Capítulo 3: Compreendendo a configuração do node Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md). +Se estávamos no processo de criação de um node de Bitcoin para usar neste curso, devemos continuar com o [Capítulo 3: Compreendendo Sua Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md). Se estivermos lendo os apêndices, vamos continuar com o [Apêndice 3: Usando o Bitcoin Regtest](A3_0_Using_Bitcoin_Regtest.md). \ No newline at end of file From 15d860a289eca54080ef6eb07132020c2dcf6014 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 8 Sep 2021 11:21:04 -0300 Subject: [PATCH 6/6] Review A3 --- pt/A3_0_Using_Bitcoin_Regtest.md | 40 ++++++++++++++++---------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/pt/A3_0_Using_Bitcoin_Regtest.md b/pt/A3_0_Using_Bitcoin_Regtest.md index 362b5d9..387fbef 100644 --- a/pt/A3_0_Using_Bitcoin_Regtest.md +++ b/pt/A3_0_Using_Bitcoin_Regtest.md @@ -2,11 +2,11 @@ > :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. -A maior parte deste curso presume que usaremos a Mainnet ou a Testnet. No entanto, essas não são as únicas opções. Ao desenvolver aplicações no Bitcoin, podemos querer manter nossos aplicativos isolados das blockchains públicas. Para fazer isso, podemos criar um blockchain do zero usando o Regtest, que tem uma outra grande vantagem sobre a Testnet. Escolhemos quando criar novos blocos, para ter controle total sobre o ambiente. +A maior parte deste curso presume que usaremos a Mainnet ou a Testnet. No entanto, essas não são as únicas opções. Ao desenvolver aplicações no Bitcoin, podemos querer manter nossos aplicativos isolados das blockchains públicas. Para fazer isso, podemos criar uma blockchain do zero usando a Regtest, que tem uma outra grande vantagem sobre a Testnet. Escolhemos quando criar novos blocos, para ter controle total sobre o ambiente. -## Iniciando o Bitcoind no Regtest +## Iniciando o Bitcoind na Regtest -Depois de [configurar nosso VPS no Bitcoin-Core ](02_0_Setting_Up_a_Bitcoin-Core_VPS.md) ou depois que o [compilamos na fonte](A2_0_Compiling_Bitcoin_from_Source.md), podemos usar o regtest. Para iniciar o `bitcoind` no regtest e criar uma Blockchain privada, iremos usar o seguinte comando: +Depois de [configurar nosso Bitcoin-Core em um VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md) ou depois de [compilarmos da fonte](A2_0_Compiling_Bitcoin_from_Source.md), podemos usar a regtest. Para iniciar o `bitcoind` na regtest e criar uma blockchain privada, iremos usar o seguinte comando: ``` $ bitcoind -regtest -daemon -fallbackfee=1.0 -maxtxfee=1.1 ``` @@ -19,17 +19,17 @@ No teste, geralmente não há transações suficientes, então o bitcoind não p Se desejarmos, podemos reiniciar nossa Regtest posteriormente com uma nova blockchain. -As carteiras do Regtest e o estado do blockchain (chainstate) são salvos no subdiretório regtest do diretório de configuração do Bitcoin: +As carteiras da Regtest e o estado da blockchain (chainstate) são salvos no subdiretória regtest do diretório de configuração do Bitcoin: ``` user@mybtc:~/.bitcoin# ls bitcoin.conf regtest testnet3 ``` -Para iniciar uma nova Blockchain usando o regtest, tudo que precisamos fazer é excluir a pasta `regtest` e reiniciar o Bitcoind: +Para iniciar uma nova blockchain usando a regtest, tudo que precisamos fazer é excluir a pasta `regtest` e reiniciar o Bitcoind: ``` $ rm -rf regtest ``` -## Gerando uma carteira do Regtest +## Gerando uma Carteira da Regtest Antes de gerar os blocos, é necessário carregar uma carteira usando `loadwallet` ou criar uma nova com `createwallet`. Desde a versão 0.21, o Bitcoin Core não cria automaticamente novas carteiras na inicialização. @@ -38,9 +38,9 @@ O argumento `descriptors=true` cria uma carteira de descritores nativos, que arm $ bitcoin-cli -regtest -named createwallet wallet_name="regtest_desc_wallet" descriptors=true ``` -## Geraando Blocos +## Gerando Blocos -Podemos gerar (minerar) novos blocos em uma blockchain de regtest usando o método RPC `generate` com um argumento para quantos blocos queremos gerar. Só faz sentido usar esse método na regtest, devido à grande dificuldade, é muito improvável que ele produza novos blocos na rede principal ou na rede de teste: +Podemos gerar (minerar) novos blocos em uma blockchain de regtest usando o método RPC `generate` com um argumento para quantos blocos queremos gerar. Só faz sentido usar esse método na regtest; devido à grande dificuldade, é muito improvável que ele produza novos blocos na rede principal ou na rede de teste: ``` $ bitcoin-cli -regtest -generate 101 [ @@ -52,25 +52,25 @@ $ bitcoin-cli -regtest -generate 101 ] ``` -> :warning: **AVISO**. Note que devemos adicionar o argumento `-regtest` após cada comando `bitcoin-cli` para acessar corretamente nosso ambiente Regtest. Se preferirmos, podemos incluir um comando `regtest=1` em nosso arquivo de configuração em `~/.bitcoin/bitcoin.conf`. +> :warning: **AVISO**. Note que devemos adicionar o argumento `-regtest` após cada comando `bitcoin-cli` para acessar corretamente nosso ambiente Regtest. Ou, se preferirmos, podemos incluir um comando `regtest=1` em nosso arquivo de configuração em `~/.bitcoin/bitcoin.conf`. -Como um bloco deve ter 100 confirmações antes que a recompensa possa ser gasta, iremos gerar 101 blocos, fornecendo acesso à transação da coinbase do bloco #1. Como este é uma nova blockchain usando as regras padrão do Bitcoin, os primeiros blocos pagam uma recompensa de bloco de 50 bitcoins. Ao contrário do mainnet, no modo regtest apenas os primeiros 150 blocos pagam uma recompensa de 50 bitcoins. A recompensa diminui pela metade após 150 blocos, então paga 25, 12,5 e assim por diante... +Como um bloco deve ter 100 confirmações antes que a recompensa possa ser gasta, iremos gerar 101 blocos, fornecendo acesso à transação da coinbase do bloco #1. Como esta é uma nova blockchain usando as regras padrão do Bitcoin, os primeiros blocos pagam uma recompensa de bloco de 50 bitcoins. Ao contrário do mainnet, no moda regtest apenas os primeiros 150 blocos pagam uma recompensa de 50 bitcoins. A recompensa diminui pela metade após 150 blocos, então paga 25, 12,5 e assim por diante... -A saída é o hash de bloco de cada bloco gerado. +A saída é o hash de cada bloco gerado. -> :book: ***O que é uma transação do tipo coinbase?*** Uma coinbase é a transação sem entrada criada quando um novo bloco é extraído e entregue ao minerador. É assim que novos bitcoins entram no ecossistema. O valor das transações coinbase decai com o tempo. Na rede principal, ele cai pela metade a cada 210.000 transações e termina inteiramente com o bloco 6.929.999, que está previsto atualmente para o século 22. Em maio de 2020, a recompensa pela coinbase é 6,25 BTC. +> :book: ***O que é uma transação do tipo coinbase?*** Uma coinbase é a transação sem entrada criada quando um novo bloco é extraído e entregue ao minerador. É assim que novos bitcoins entram no ecossistema. O valor das transações coinbase decai com o tempo. Na rede principal, ele cai pela metade a cada 210.000 blocos e termina inteiramente com o bloco 6.929.999, que está previsto atualmente para o século 22. Em maio de 2020, a recompensa pela coinbase é 6,25 BTC. -### Verificando nosso saldo +### Verificando Nosso Saldo -Depois de minerar blocos e receber as recompensas, podemos verificar o saldo em nossa carteira: +Depois de minerar os blocos e receber as recompensas, podemos verificar o saldo em nossa carteira: ``` $ bitcoin-cli -regtest getbalance 50.00000000 ``` -## Usando o Regtest +## Usando a Regtest -Agora devemos ser capazes de usar este saldo para qualquer tipo de interação em nossa Blockchain privada, como o envio de transações Bitcoin de acordo com o [Capítulo 4](04_0_Sending_Bitcoin_Transactions.md). +Agora devemos ser capazes de usar este saldo para qualquer tipo de interação em nossa blockchain privada, como o envio de transações Bitcoin de acordo com o [Capítulo 4](04_0_Sending_Bitcoin_Transactions.md). É importante notar que para que qualquer transação seja concluída, teremos que gerar (minerar) novos blocos, para que as transações possam ser incluídas. @@ -118,7 +118,7 @@ $ bitcoin-cli -regtest gettransaction e834a4ac6ef754164c8e3f0be4f34531b74b768199 } ``` No entanto, agora devemos finalizá-la criando blocos na blockchain. -A maioria das aplicações requer seis confirmações de bloco para considerar a transação como irreversível. Se for esse o nosso caso, podemos minerar seis blocos adicionais em nossa blockchain de teste: +A maioria das aplicações requer seis confirmações de bloco para considerar a transação como irreversível. Se este for o nosso caso, podemos minerar seis blocos adicionais em nossa blockchain de teste: ``` $ bitcoin-cli -regtest -generate 6 [ @@ -138,7 +138,7 @@ Quando estamos fazendo testes, somos capazes de simular casos extremos e ataques Conforme discutido em outro lugar neste curso, o uso de bibliotecas de software pode fornecer acesso mais sofisticado a alguns comandos RPC. Nesse caso, o [bitcointest criado por dgarage](https://github.com/dgarage/bitcointest) para o NodeJS pode ser usado para simular uma transação de uma carteira para outra; podemos verificar [a documentação](https://www.npmjs.com/package/bitcointest) para simularmos ataque mais específicos, como o de gasto duplo. -Vejamos a seção [§17.3](17_3_Accessing_Bitcoind_with_NodeJS.md) para as informações mais atualizadas sobre a instalação do NodeJS, em seguida, podemos adicionar ao `bitcointest`: +Vejamos a seção [§18.3](18_3_Accessing_Bitcoind_with_NodeJS.md) para as informações mais atualizadas sobre a instalação do NodeJS, em seguida, podemos adicionar ao `bitcointest`: ``` $ npm install -g bitcointest ``` @@ -197,10 +197,10 @@ n2.after (before) = 100 Um ambiente regtest para o Bitcoin funciona como qualquer ambiente testnet, exceto que teremos a capacidade de gerar blocos de maneira rápida e fácil. - > :fire: ***Qual é o poder da regtest?*** O maior poder da regtest é que podemos minerar blocos rapidamente, permitindo que nos apressemos na blockchain, para testar transações, timelocks e outros recursos que podemos querer, caso contrário, teríamos de sentar e esperar. No entanto, o outro poder é que podemos executar de forma privada, sem nos conectarmos a uma blockchain pública, nos permitindo testar nossas ideias antes de liberá-las para o mundo. + > :fire: ***Qual é o poder da regtest?*** O maior poder da regtest é que podemos minerar blocos rapidamente, permitindo que nos apressemos na blockchain para testar transações, timelocks e outros recursos que podemos querer, caso contrário, teríamos de sentar e esperar. No entanto, o outro poder é que podemos executar de forma privada, sem nos conectarmos a uma blockchain pública, nos permitindo testar nossas ideias antes de liberá-las para o mundo. ## O Que Vem Depois? Se estamos visitando o Apêndice enquanto trabalhamos em alguma outra parte do curso, devemos voltar para lá. -Mas, caso contrário, chegamos ao fim! Outras pessoas que trabalharam neste curso tornaram-se desenvolvedores e engenheiros profissionais no mundo do Bitcoin, incluindo alguns dos quais contribuíram para o [Blockchain Commons](https://www.blockchaincommons.com/). Nós o encorajamos a fazer o mesmo! Basta sair e começar a trabalhar em alguns dos códigos do Bitcoin usando o que aprendemos. \ No newline at end of file +Mas, caso contrário, chegamos ao fim! Outras pessoas que trabalharam neste curso tornaram-se desenvolvedores e engenheiros profissionais no mundo do Bitcoin, incluindo alguns dos quais contribuíram para a [Blockchain Commons](https://www.blockchaincommons.com/). Nós o encorajamos a fazer o mesmo! Basta sair e começar a trabalhar em alguns dos códigos do Bitcoin usando o que aprendemos. \ No newline at end of file