Revise chapter 16 titles, fix typos

namcios · namcios · commit 41eefa15ff2e · 2021-09-21T11:02:18.000-03:00
diff --git a/pt/16_0_Talking_to_Bitcoind.md b/pt/16_0_Talking_to_Bitcoind.md
@@ -1,5 +1,4 @@
-
-# Capítulo 15: Conversando com Bitcoind usando C
+# Capítulo 16: Conversando com Bitcoind com 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.
 
@@ -19,9 +18,9 @@ Os objetivos secundários do capítulo incluem a capacidade de:
    * Compreender as capacidades do ZMQ;
    * Entender como usar uma biblioteca ZMQ.
 
-## Tabela de conteúdo
+## 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)
+  * [Seção 1: Acessando o Bitcoind em C com Bibliotecas RPC](16_1_Accessing_Bitcoind_with_C.md)
+  * [Seção 2: Programando o Bitcoind em C com Bibliotecas RPC](16_2_Programming_Bitcoind_with_C.md)
+  * [Seção 3: Recebendo Notificações em C com Bibliotecas ZMQ](16_3_Receiving_Bitcoind_Notifications_with_C.md)
    
diff --git a/pt/16_1_Accessing_Bitcoind_with_C.md b/pt/16_1_Accessing_Bitcoind_with_C.md
@@ -1,5 +1,4 @@
-
-# 15.1: Acessando o Bitcoind usando C com bibliotecas RPC
+# 16.1: Acessando o Bitcoind em 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.
 
@@ -29,7 +28,7 @@ $ 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.
+### Compilando o libbitcoinrpc
 
 Antes de compilarmos e instalarmos o pacote, provavelmente precisaremos ajustar nosso  ``$PATH``, para que  possamos acessar o ``/sbin/ldconfig``:
 ```
@@ -91,7 +90,7 @@ Installing man pages
 install -m 644 doc/man3/bitcoinrpc*.gz /usr/local/man/man3
 ```
 
-## Preparando o código
+## 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.
 
@@ -107,7 +106,7 @@ Precisaremos também vincular as bibliotecas apropriadas sempre que possamos com
 $ cc yourcode.c -lbitcoinrpc -ljansson -o yourcode
 ```
 
-## Construindo a conexão
+## Construindo a Conexão
 
 Para construir a conexão com o servidor ``bitcoind`` é necessário alguns simples passos.
 
@@ -154,7 +153,7 @@ Mais tarde, quando tivermos feito com a conexão de ``bitcoind``, poderemos fech
 bitcoinrpc_global_cleanup();
 ```
 
-### Testando o código de teste
+### 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).
 
@@ -167,7 +166,7 @@ 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
+## 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
@@ -188,7 +187,7 @@ Vamos usar a variável ``rpc_client`` que aprendemos no teste anterior e vamos a
 bitcoinrpc_call(rpc_client, getmininginfo, btcresponse, &btcerror);
 ```
 
-### Mostrando o retorno da chamada
+### 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
@@ -222,7 +221,7 @@ 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
+### Testando o Código de Informação
 
 Vamos recuperar o código de teste que está no [diretório src](15_1_GetMiningInfo.c).
 ```
@@ -253,11 +252,11 @@ Just the Result: {
 Block Count: 1804406
 ```
 
-## Fazendo uma chamada RPC usando argumentos
+## Fazendo uma Chamada RPC Usando Argumentos
 
 Mas e se a sua chamada RPC tiver argumentos?
 
-### Criando uma matriz JSON
+### 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.
 
@@ -275,20 +274,20 @@ Observe que existem duas variantes para o comando de anexação: ``json_array_ap
 
 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
+### 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
+## Resumo: Acessando o Bitcoind em 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.
+* :fire: ***Qual é o poder do 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).
+Vamos falar mais um pouco no "Conversando com o Bitcoind com C" no capítulo [16.2: Programando o Bitcoind em C com Bibliotecas RPC](16_2_Programming_bitcoind_with_c.md).
diff --git a/pt/16_2_Programming_Bitcoind_with_C.md b/pt/16_2_Programming_Bitcoind_with_C.md
@@ -1,11 +1,10 @@
-
-# 15.2: Programando o Bitcoind usando C com bibliotecas RPC
+# 16.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.
+A seção [§16.1](16_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
+## 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:
 
@@ -18,7 +17,7 @@ Esta seção irá criar uma versão simples do ``sendtoaddress``, permitindo ao
   7. Assinar a transação;
   8. Enviar a transação.
   
-### Planejando para o futuro
+### 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:
 
@@ -31,11 +30,11 @@ Como este é o nosso primeiro programa C funcional, vamos mantê-lo simples (ou
    
 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
+## 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
+### Etapa 1: Solicitando um Endereço e uma Quantia
 
 Inserir as informações é bem simples se usarmos os argumentos na linha de comando:
 ``` c
@@ -54,7 +53,7 @@ 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
+### 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:
 
@@ -65,9 +64,9 @@ 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
+### 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:
+Obviamente, precisaremos preparar todas as nossas variáveis novamente, conforme discutido na seção [§16.1: Acessando o Bitcoind com C](16_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);
@@ -157,7 +156,7 @@ if(!tx_id) {
 
 > **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
+### Etapa 5: Criando um Endereço de Troco
 
 Repita a metodologia padrão de pesquisa RPC para obter um endereço de troco:
 ``` c
@@ -188,7 +187,7 @@ A única diferença é quais informações específicas são extraídas do objet
 
 > :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
+### 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.
 
@@ -200,7 +199,7 @@ createrawtransaction [{"txid":"id","vout":n},...] {"address":amount,"data":"hex"
 
 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
+#### 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
@@ -220,7 +219,7 @@ inputparams = json_array();
 json_array_append(inputparams,inputtxid);
 ```
 
-#### Etapa 6.2: Criando os parâmetros de saída
+#### 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
@@ -248,7 +247,7 @@ json_array_append(params,inputparams);
 json_array_append(params,outputparams);
 ```
 
-#### Etapa 6.4: Fazendo a chamada ao RPC
+#### Etapa 6.4: Fazendo a Chamada ao RPC
 
 Vamos usar o método normal para criar uma chamada ao RPC:
 ``` c
@@ -271,7 +270,7 @@ lu_result = json_object_get(lu_response,"result");
 
 char *tx_rawhex = strdup(json_string_value(lu_result));
 ```
-### Etapa 7. Assinando a transação
+### 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
@@ -301,7 +300,7 @@ 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
+### Etapa 8. Enviando a Transação
 
 Agora podemos enviar a transação, usando todas as técnicas aprendidas anteriormente:
 ``` c
@@ -329,9 +328,9 @@ 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
+## Testando o Código
 
-O código completo pode ser encontrado no [diretório src/](src/15_2_sendtoaddress.c).
+O código completo pode ser encontrado no [diretório src/](src/16_2_sendtoaddress.c).
 
 Compile-o como de costume:
 ```
@@ -345,10 +344,10 @@ 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
+## Resumo: Programando o Bitcoind em 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).
+Aprenda mais sobre "Programando o Bitcoind com C" na próxima seção [16.3: Recebendo notificações usando C com a biblioteca ZMQ](16_3_Receiving_Bitcoind_Notifications_with_C.md).
diff --git a/pt/16_3_Receiving_Bitcoind_Notifications_with_C.md b/pt/16_3_Receiving_Bitcoind_Notifications_with_C.md
