Skip to content

Commit e9bda63

Browse files
shannonashannona
authored
Merge pull request #396 from KoreaComK/chapter16
Chapter 16 Translated by @KoreaComK need review
2 parents 122dae0 + 44c594d commit e9bda63

9 files changed

+1513
-28
lines changed

‎pt/17_0_Programming_with_Libwally.md‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
# Capítulo 17: Programando com Libwally
2+
3+
O capítulo anterior apresentou três bibliotecas C, para RPC, JSON e ZMQ, todas destinadas a interagir diretamente com o `bitcoind`, assim como você vem fazendo desde o início. Mas às vezes você pode querer codificar sem acesso direto a um `bitcoind`. Isso pode ser devido a um cliente offline ou apenas porque você deseja manter algumas funcionalidades internas de seu programa C. Você também pode querer se aprofundar na funcionalidade da carteira, como criação de palavras mnemônicas ou derivação de endereços. É aí que entra Libwally: é uma biblioteca de carteira para C, C ++, Java, NodeJS ou Python, com wrappers também disponíveis para outras linguagens, como Swift.
4+
5+
Este capítulo aborda a funcionalidade possível dentro do Libwally, a maioria das quais complementa o trabalho que você fez através do acesso RPC ao `bitcoind`, mas algumas das quais o replicam. Ele também mostra como integrar esse trabalho com os clientes RPC com os quais você está mais familiarizado. No entanto, observe que esta é apenas uma introdução básica ao Libwally. Vários de seus conjuntos de funções mais importantes são destacados, mas nunca fazemos mais do que apresentar uma introdução. Se você acha suas funções úteis ou intrigantes, então você precisará se aprofundar muito mais do que este curso pode cobrir.
6+
7+
## Objetivos Deste Capítulo
8+
9+
Depois de trabalhar neste capítulo, um desenvolvedor será capaz de:
10+
11+
* Usar as funções de carteira com o Libwally;
12+
* Realizar manipulações de PSBTs e transações com o Libwally;
13+
* Implementar designs que combinem o Libwally e o RPC.
14+
15+
Os objetivos secundários do capítulo incluem a capacidade de:
16+
17+
* Compreender palavras mnemônicas BIP39;
18+
* Conhecer mais sobre as carteiras hierárquicas BIP32;
19+
* Sintetizar a profundidade funcional do Libwally.
20+
21+
## Tabela de Conteúdo
22+
23+
* [Seção 1: Configurando a Libwally](17_1_Setting_Up_Libwally.md)
24+
* [Seção 2: Usando BIP39 na Libwally](17_2_Using_BIP39_in_Libwally.md)
25+
* [Seção 3: Usando BIP32 na Libwally](17_3_Using_BIP32_in_Libwally.md)
26+
* [Seção 4: Usando PSBTs na Libwally](17_4_Using_PSBTs_in_Libwally.md)
27+
* [Seção 5: Usando Scripts na Libwally](17_5_Using_Scripts_in_Libwally.md)
28+
* [Seção 6: Usando Outras Funções na Libwally](17_6_Using_Other_Functions_in_Libwally.md)
29+
* [Seção 7: Integrando Libwally e Bitcoin-CLI](17_7_Integrating_Libwally_and_Bitcoin-CLI.md)

‎pt/17_1_Setting_Up_Libwally.md‎

Lines changed: 195 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,195 @@
1+
# 16.1: Configurando a Libwally
2+
3+
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
4+
5+
Esta primeira seção explicará como fazer o download da Biblioteca Libwally C e como colocá-la em funcionamento.
6+
7+
> :book: ***O que é a Libwally?*** A Libwally é uma biblioteca de primitivas útil para a criação de carteiras que é totalmente multiplataforma, de modo que as mesmas funções possam ser usadas em qualquer lugar. Há uma [documentação online](https://wally.readthedocs.io/en/latest/), caso esteja interessado. A Libwally está disponível como parte do [Elements Project](https://github.com/ElementsProject) da Blockstream.
8+
9+
## Instalando a Libwally
10+
11+
Como de costume, precisaremos de alguns pacotes no nosso sistema:
12+
```
13+
$ sudo apt-get install git
14+
$ sudo apt-get install dh-autoreconf
15+
```
16+
Podemos então fazer o download do Libwally com base no seu repositório Git:
17+
```
18+
$ git clone https://github.com/ElementsProject/libwally-core
19+
```
20+
Depois, podemos começar com o processo de configuração.
21+
```
22+
$ ./tools/autogen.sh
23+
```
24+
Como no ```libbitcoinrpc```, podemos querer instalar no caminho `/usr/include` e no `/usr/lib` para facilitar o uso. Basta modificar a linha apropriada no arquivo `configure` do programa:
25+
```
26+
< ac_default_prefix=/usr
27+
---
28+
> ac_default_prefix=/usr/local
29+
```
30+
Depois, podemos terminar nossa preparação:
31+
```
32+
$ ./configure
33+
$ make
34+
```
35+
Agora, podemos verificar se os testes estão funcionando:
36+
```
37+
$ make check
38+
Making check in src
39+
make[1]: Entering directory '/home/standup/libwally-core/src'
40+
Making check in secp256k1
41+
make[2]: Entering directory '/home/standup/libwally-core/src/secp256k1'
42+
make check-TESTS
43+
make[3]: Entering directory '/home/standup/libwally-core/src/secp256k1'
44+
make[4]: Entering directory '/home/standup/libwally-core/src/secp256k1'
45+
============================================================================
46+
Testsuite summary for libsecp256k1 0.1
47+
============================================================================
48+
# TOTAL: 0
49+
# PASS: 0
50+
# SKIP: 0
51+
# XFAIL: 0
52+
# FAIL: 0
53+
# XPASS: 0
54+
# ERROR: 0
55+
============================================================================
56+
make[4]: Leaving directory '/home/standup/libwally-core/src/secp256k1'
57+
make[3]: Leaving directory '/home/standup/libwally-core/src/secp256k1'
58+
make[2]: Leaving directory '/home/standup/libwally-core/src/secp256k1'
59+
make[2]: Entering directory '/home/standup/libwally-core/src'
60+
make check-TESTS check-local
61+
make[3]: Entering directory '/home/standup/libwally-core/src'
62+
make[4]: Entering directory '/home/standup/libwally-core/src'
63+
PASS: test_bech32
64+
PASS: test_psbt
65+
PASS: test_psbt_limits
66+
PASS: test_tx
67+
============================================================================
68+
Testsuite summary for libwallycore 0.7.8
69+
============================================================================
70+
# TOTAL: 4
71+
# PASS: 4
72+
# SKIP: 0
73+
# XFAIL: 0
74+
# FAIL: 0
75+
# XPASS: 0
76+
# ERROR: 0
77+
============================================================================
78+
make[4]: Leaving directory '/home/standup/libwally-core/src'
79+
make[3]: Nothing to be done for 'check-local'.
80+
make[3]: Leaving directory '/home/standup/libwally-core/src'
81+
make[2]: Leaving directory '/home/standup/libwally-core/src'
82+
make[1]: Leaving directory '/home/standup/libwally-core/src'
83+
make[1]: Entering directory '/home/standup/libwally-core'
84+
make[1]: Nothing to be done for 'check-am'.
85+
make[1]: Leaving directory '/home/standup/libwally-core'
86+
```
87+
Finalmente, podemos instalar:
88+
```
89+
$ sudo make install
90+
```
91+
92+
## Nos Preparando Para a Libwally
93+
94+
Então, como usamos a Libwally em um programa? Como de costume, precisaremos incluir os arquivos e vincular as bibliotecas apropriadas em nosso código.
95+
96+
### Incluindo os Arquivos
97+
98+
Há um número considerável de arquivos que podemos incluir:
99+
100+
```
101+
$ ls /usr/include/wally*
102+
/usr/include/wally_address.h /usr/include/wally_bip39.h /usr/include/wally_elements.h /usr/include/wally_script.h
103+
/usr/include/wally_bip32.h /usr/include/wally_core.h /usr/include/wally.hpp /usr/include/wally_symmetric.h
104+
/usr/include/wally_bip38.h /usr/include/wally_crypto.h /usr/include/wally_psbt.h /usr/include/wally_transaction.h
105+
```
106+
Felizmente, os nomes dos arquivos correspondem amplamente às seções da [documentação](https://wally.readthedocs.io/en/latest/), então devemos ser capazes de incluir os arquivos corretos com base no que estamos fazendo, depois de incluir o onipresente `wally_core.h`.
107+
108+
### Vinculando as Bibliotecas
109+
110+
Também precisaremos vincular as bibliotecas apropriadas:
111+
```
112+
$ ls /usr/lib/libsecp* /usr/lib/libwally*
113+
/usr/lib/libsecp256k1.a /usr/lib/libwallycore.la /usr/lib/libwallycore.so.0
114+
/usr/lib/libsecp256k1.la /usr/lib/libwallycore.so /usr/lib/libwallycore.so.0.0.0
115+
```
116+
Usaremos principalmente a `libwallycore`.
117+
118+
## Configurando um Programa Libwally
119+
120+
Comparado com algumas das bibliotecas anteriores, a Libwally é ridiculamente fácil de ser inicializada:
121+
```
122+
lw_response = wally_init(0);
123+
```
124+
E então, quando terminarmos, há uma função útil para limpar qualquer memória alocada:
125+
```
126+
wally_cleanup(0);
127+
```
128+
Em ambos os casos, o argumento é para flags, mas atualmente está definido como `0`.
129+
130+
## Testando um Programa de Teste da Libwally
131+
132+
O diretório src contém o arquivo [testwally.c](src / 16_1_testwally.c), que apenas mostra como funcionam as funções de inicialização e de limpeza.
133+
134+
Podemos compilá-lo da seguinte maneira:
135+
```
136+
$ cc testwally.c -lwallycore -o testwally
137+
```
138+
Depois, podemos executá-lo:
139+
```
140+
$ ./testwally
141+
Startup: 0
142+
```
143+
O valor "Startup" é o retorno do comando `wally_init`. O valor `0` pode inicialmente parecer desanimador, mas é o que desejamos ver no momento:
144+
```
145+
include/wally_core.h:#define WALLY_OK 0 /** Success */
146+
```
147+
148+
## Instalando o Libsodium
149+
150+
Também precisamos instalar o Libsodium para obter acesso a um gerador de números aleatórios de alta qualidade para fins de teste.
151+
152+
> :warning: **AVISO:** A geração de números aleatórios pode ser um dos maiores pontos de vulnerabilidade em qualquer software do Bitcoin. Se fizermos isso de maneira errada, podemos expor nossos usuários a ataques porque eles acabam tendo chaves privadas do Bitcoin inseguras, e isso não é um [problema teórico](https://github.com/BlockchainCommons/SmartCustodyBook/blob/master/manuscript/03-adversaries.md#adversary-systemic-key-compromise). A BlockchainInfo gerou incorretamente 0,0002% das suas chaves, o que resultou na perda temporária de 250 Bitcoins. Resumindo: precisamos nos certificar de estar totalmente confortável com a geração de números aleatórios. Podemos usar o Libsodium ou qualquer outro método TRNG ainda mais robusto.
153+
154+
Podemos baixar um [Libsodium tarball](https://download.libsodium.org/libsodium/releases/) e seguir as instruções em [instalação do Libsodium](https://doc.libsodium.org/installation) para deixarmos tudo pronto em nosso computador.
155+
156+
Primeiro, descompactamos:
157+
```
158+
$ tar xzfv /tmp/libsodium-1.0.18-stable.tar.gz
159+
```
160+
Então, ajustamos o arquivo `configure` exatamente como fizemos nas outras bibliotecas até o momento:
161+
```
162+
< ac_default_prefix=/usr
163+
---
164+
> ac_default_prefix=/usr/local
165+
```
166+
Finalmente, usamos os comandos `make`,`check` e `install`:
167+
```
168+
$ make
169+
$ make check
170+
...
171+
============================================================================
172+
Testsuite summary for libsodium 1.0.18
173+
============================================================================
174+
# TOTAL: 77
175+
# PASS: 77
176+
# SKIP: 0
177+
# XFAIL: 0
178+
# FAIL: 0
179+
# XPASS: 0
180+
# ERROR: 0
181+
============================================================================
182+
...
183+
$ sudo make install
184+
```
185+
Este curso usará apenas `libsodium` para um pequeno (mas crucial!) bit de geração de entropia, mas precisamos prestar muita atenção na próxima seção.
186+
187+
## Resumo: Configurando a Libwally
188+
189+
Ao instalar os includes e as bibliotecas da Libwally (e do Libsodium), ganhamos acesso a uma série de funções criptográficas e de carteira, que podem complementar nossas bibliotecas RPC e ZMG (ou nossa linha de comando `bitcoin-cli`).
190+
191+
Então, o que exatamente podemos fazer agora? É para dar essa resposta que temos todas as seções deste capítulo.
192+
193+
## O Que Vem Depois?
194+
195+
Vamos aprender mais sobre "Programando Bitcoin com Libwally" na seção [§16.2: Usando BIP39 na Libwally](16_2_Using_BIP39_in_Libwally.md).

‎pt/17_2_Using_BIP39_in_Libwally.md‎

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
# 16.2: Usando BIP39 na Libwally
2+
3+
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
4+
5+
Um dos maiores poderes da Libwally é que ela pode revelar o trabalho oculto da geração de seeds, chaves privadas e, também, de endereços. Para começar, ela suporta o [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki), que é o BIP que define códigos mnemônicos para o Bitcoin, algo que era totalmente incompatível, na época, com o Bitcoin Core.
6+
7+
> :book: ***O que é um código mnemônico?*** Os endereços de Bitcoin (e suas chaves privadas correspondentes e as suas seeds) são listas longas e ininteligíveis de caracteres e números que não apenas são impossíveis de serem lembrados, mas também fáceis de serem digitados erroneamente. Os códigos mnemônicos são uma solução para isso que permitem aos usuários gravar 12 (ou 24) palavras em inglês, algo que é muito menos sujeito a erros. Esses códigos podem ser usados para restaurar totalmente uma seed BIP32 que é a base de uma carteira Determinística Hierárquica (HD).
8+
9+
> :book: ***O que é uma seed?*** Nós falamos brevemente das seeds na seção [§3.5: Compreendendo o Descritor](03_5_Understanding_the_Descriptor.md). É o número aleatório usado para gerar uma sequência inteira de chaves privadas (e, portanto, endereços) em uma carteira HD. Voltaremos às seeds na próxima seção, onde falaremos sobre as carteiras HD e a Libwally. Por enquanto, apenas é necessário saber que um código mnemônico BIP39 corresponde à seed para uma carteira HD do BIP32.
10+
11+
## Criando Códigos Mnemônicos
12+
13+
Todas as chaves Bitcoin começam com a entropia. Este primeiro uso da Libwally, e os mnemônicos BIP39, mostram como gerar entropia e obter um código mnemônico a partir disso.
14+
15+
> :book: ***O que é entropia?*** Entropia é uma maneira sofisticada de dizer aleatoriedade, mas é uma aleatoriedade medida cuidadosamente que é usada como a base de um número aleatório gerado verdadeiramente (no inglês, true-random-number generated, TRG). É medido em "bits", com mais bits de entropia resultando em mais aleatoriedade (e, portanto, mais proteção para o que está sendo gerado). Para o Bitcoin, a entropia é a base de nossa seed, que em uma carteira HD gera todos os seus endereços.
16+
17+
Sempre começaremos a trabalhar com a Libwally inicializando a biblioteca e testando os resultados, conforme demonstrado pela primeira vez na seção [§17.1](17_1_Setting_Up_Libwally.md):
18+
```
19+
int lw_response;
20+
21+
lw_response = wally_init(0);
22+
23+
if (lw_response) {
24+
25+
printf("Error: Wally_init failed: %d\n",lw_response);
26+
exit(-1);
27+
28+
}
29+
```
30+
Agora estamos prontos para a entropia.
31+
32+
### Criando Entropia
33+
34+
Usando o `libsodium`, podemos criar entropia com o comando `randombytes_buf`:
35+
```
36+
unsigned char entropy[16];
37+
randombytes_buf(entropy, 16);
38+
```
39+
Este exemplo, que será a única maneira de usarmos a biblioteca `libsodium`, cria 16 bytes de entropia. Geralmente, para criar um código mnemônico seguro, devemos usar entre 128 e 256 bits de entropia, que é 16 a 32 bytes.
40+
41+
> :warning: **AVISO:** Mais uma vez, certifique-se de estar muito confortável com o método de geração de entropia antes de usá-lo em um programa do mundo real.
42+
43+
### Traduzindo para um Mnemônico
44+
45+
16 bytes de entropia são suficientes para criar um código Mnemônico de 12 caracteres, que é feito com a função `bip39_mnemonic_from_bytes` da Libwally:
46+
```
47+
char *mnem = NULL;
48+
lw_response = bip39_mnemonic_from_bytes(NULL,entropy,16,&mnem);
49+
```
50+
Observe que temos que passar o tamanho do byte, então se quisermos aumentar o tamanho da entropia, para gerar uma frase mnemônica mais longa, também precisaríamos aumentar o valor nesta função.
51+
52+
> **NOTA:** Existem listas de palavras mnemônicas para diferentes idiomas! O padrão é usar a lista do idioma inglês, que é a variável `NULL` nesses comandos mnemônicos da Libwally, mas podemos, alternativamente, solicitar um idioma diferente!
53+
54+
É isso! Nós criamos uma frase mnemônica!
55+
56+
> :book: ***Como a frase mnemônica é criada?*** Podemos aprender mais sobre isso no [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki), mas, se preferir, Greg Walker tem um [excelente exemplo](https://learnmeabitcoin.com/technical/mnemonic): de maneira geral, adicionamos um checksum e convertemos cada conjunto de 11 bits em uma palavra da lista de palavras. Podemos fazer isso com os comandos `bip39_get_wordlist` e `bip39_get_word` se não confiarmos no comando `bip39_mnemonic_from_bytes`.
57+
58+
### Traduzindo para uma Seed
59+
60+
Existem algumas funções, como o `bip32_key_from_seed` (que veremos na próxima seção) que requerem que tenhamos os bits ao invés do Mnemônico. As duas coisas são funcionalmente idênticas: se temos a seed, podemos gerar o mnemônico e vice-versa.
61+
62+
Se precisarmos gerar a seed a partir do nosso mnemônico, basta usar o comando `bip39_mnemonic_to_seed`:
63+
```
64+
unsigned char seed[BIP39_SEED_LEN_512];
65+
size_t seed_len;
66+
67+
lw_response = bip39_mnemonic_to_seed(mnem,NULL,seed,BIP39_SEED_LEN_512,&seed_len);
68+
```
69+
Observe que todas as seeds do BIP39 têm 512 bytes; no entanto, devemos definir o tamanho de nossa variável apropriadamente e passar o tamanho para o `bip39_mnemonic_to_seed`.
70+
71+
### Vendo a Nossa Seed
72+
73+
Se quisermos ver como nossa seed é em hexadecimal, podemos usar a função `wally_hex_from_bytes` para transformar nossa seed em um código hexadecimal legível (mas isso não é muito bom para pessoas):
74+
```
75+
char *seed_hex;
76+
wally_hex_from_bytes(seed,sizeof(seed),&seed_hex);
77+
printf("Seed: %s\n",seed_hex);
78+
```
79+
Se dizermos tudo certo, devemos obter uma seed de 64 bytes. (Essa é a variável `BIP39_SEED_LEN_512` que estamos usando, que define um comprimento de seed padrão de 512 bits ou 64 bytes.)
80+
81+
> :warning: **ATENÇÃO:** Definitivamente devemos testar se o comprimento da nossa seed é de 64 bytes de alguma forma, porque é fácil errar em alguma coisa, por exemplo, usando o tipo de variável errado quando executamos o `bip39_mnemonic_to_seed`.
82+
83+
## Testando o Código Mnemônico
84+
85+
O código completo para gerar entropia, gerar um mnemônico BIP39, validar o mnemônico e gerar uma seed pode ser encontrado no [diretório src/](src/17_2_genmnemonic.c). Podemos fazer o download e compilar:
86+
```
87+
$ cc genmnemonic.c -lwallycore -lsodium -o genmnemonic
88+
```
89+
Então podemos executar o teste:
90+
```
91+
Mnemonic: parent wasp flight sweet miracle inject lemon matter label column canyon trend
92+
Mnemonic validated!
93+
Seed: 47b04cfb5d8fd43d371497f8555a27a25ca0a04aafeb6859dd4cbf37f6664b0600c4685c1efac29c082b1df29081f7a46f94a26f618fc6fd38d8bc7b6cd344c7
94+
```
95+
96+
## Resumo: Usando BIP39 na Libwally
97+
98+
O BIP39 nos permite gerar um conjunto de 12-24 palavras Mnemônicas a partir de uma seed (e a biblioteca Libwally também permite que a validemos!).
99+
100+
> :fire: ***Qual é o poder do BIP39?*** Seeds de Bitcoin e chaves privadas estão sujeitas a todos os tipos de perda. Se digitarmos errado um único dígito, nosso dinheiro será perdido para sempre. Palavras mnemônicas são uma forma muito mais amigável de representar os mesmos dados, mas como são palavras no idioma de escolha do usuário, são menos sujeitas a erros. O poder do BIP39 é, portanto, melhorar a acessibilidade, usabilidade e segurança do Bitcoin.
101+
102+
> :fire: ***Qual é o poder do BIP39 na Libwally?*** O Bitcoind atualmente não suporta palavras mnemônicas, então usar a Libwally pode permitir que geremos palavras mnemônicas em conjunto com endereços mantidos no `bitcoind`, embora como veremos na seção §17.7, é necessário um pouco de gambiarra para importar suas chaves para o Bitcoin Core.
103+
104+
## O Que Vem Depois?
105+
106+
Vamos aprender mais sobre "Programando o Bitcoind usando o Libwally" na seção [§17.3: Usando o BIP32 no Libwally](16_3_Using_BIP32_in_Libwally.md).

0 commit comments

Comments
 (0)