flywithu/Learning-Bitcoin-from-the-Command-Line
1
1
Fork 0
mirror of https://github.com/ChristopherA/Learning-Bitcoin-from-the-Command-Line.git synced 2025-06-07 07:56:31 +00:00
Code Issues Releases Wiki Activity

Revise chapter 16 titles, fix typos

Browse Source
This commit is contained in:
namcios 2021-09-21 11:02:18 -03:00
parent c12abd1938
commit 41eefa15ff
No known key found for this signature in database
GPG Key ID: 8E3A368317269AB4
4 changed files with 45 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
pt/16_0_Talking_to_Bitcoind.md
View File

@ -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)

29
pt/16_1_Accessing_Bitcoind_with_C.md
View File

@ -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,7 +274,7 @@ 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
@ -283,12 +282,12 @@ 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).

41
pt/16_2_Programming_Bitcoind_with_C.md
View File

@ -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).

13
pt/16_3_Receiving_Bitcoind_Notifications_with_C.md
View File

@ -1,9 +1,8 @@
# 15.3 Recebendo notificações usando C com a biblioteca ZMQ
# 16.3 Recebendo Notificações em C com Bibliotecas 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.
As sessões [§16.1](16_1_Accessing_Bitcoind_with_C.md) e [§16.2](16_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).
@ -58,7 +57,7 @@ $ sudo apt-get install libczmq-dev
```
Agora estamos pronto para escrever o código!
## Escrevendo o programa de notificação
## 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.
@ -120,7 +119,7 @@ Claro, quando terminar o processo, precisamos limpar tudo:
}
```
### Testando o código de notificação
### 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:
```
@ -144,7 +143,7 @@ No: 70
.......
```
### Resumo do capítulo Recebendo Notificações Usando C com a Biblioteca ZMQ
### Resumo: Recebendo Notificações em C com Bibliotecas 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.
@ -152,4 +151,4 @@ Ao usar a estrutura ZMQ, podemos receber notificações facilmente, inscrevendo-
## 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).
Saiba mais sobre "Programando com RPC" no [Capítulo 17: Programando o Bitcoin com Libwally](17_0_Programming_with_Libwally.md).