Skip to content

Commit 4fb508a

Browse files
KoreaComKKoreaComK
committed
Chapter 16 translation finished
1 parent bb6dd6c commit 4fb508a

8 files changed

Lines changed: 1486 additions & 0 deletions

‎pt/16_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 16: 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 enfiar os pés no chão. Se você acha suas funções úteis ou intrigantes, então você precisará se aprofundar muito mais profundamente 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 da 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 o Libwally](16_1_Setting_Up_Libwally.md)
24+
* [Seção 2: Usando o BIP39 no Libwally](16_2_Using_BIP39_in_Libwally.md)
25+
* [Seção 3: Usando o BIP32 no Libwally](16_3_Using_BIP32_in_Libwally.md)
26+
* [Seção 4: Usando o PSBTs no Libwally](16_4_Using_PSBTs_in_Libwally.md)
27+
* [Seção 5: Usando Scripts no Libwally](16_5_Using_Scripts_in_Libwally.md)
28+
* [Seção 6: Usando Outras Funções no Libwally](16_6_Using_Other_Functions_in_Libwally.md)
29+
* [Seção 7: Integrando o Libwally ao Bitcoin-CLI](16_7_Integrating_Libwally_and_Bitcoin-CLI.md)

‎pt/16_1_Setting_Up_Libwally.md‎

Lines changed: 196 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,196 @@
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. Existem [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 o 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+
Afterward, you can begin the configuration process:
21+
Depois, podemos começar com o processo de configuração.
22+
```
23+
$ ./tools/autogen.sh
24+
```
25+
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:
26+
```
27+
< ac_default_prefix=/usr
28+
---
29+
> ac_default_prefix=/usr/local
30+
```
31+
Depois, podemos terminar nossa preparação:
32+
```
33+
$ ./configure
34+
$ make
35+
```
36+
Agora, podemos verificar se os testes estão funcionando:
37+
```
38+
$ make check
39+
Making check in src
40+
make[1]: Entering directory '/home/standup/libwally-core/src'
41+
Making check in secp256k1
42+
make[2]: Entering directory '/home/standup/libwally-core/src/secp256k1'
43+
make check-TESTS
44+
make[3]: Entering directory '/home/standup/libwally-core/src/secp256k1'
45+
make[4]: Entering directory '/home/standup/libwally-core/src/secp256k1'
46+
============================================================================
47+
Testsuite summary for libsecp256k1 0.1
48+
============================================================================
49+
# TOTAL: 0
50+
# PASS: 0
51+
# SKIP: 0
52+
# XFAIL: 0
53+
# FAIL: 0
54+
# XPASS: 0
55+
# ERROR: 0
56+
============================================================================
57+
make[4]: Leaving directory '/home/standup/libwally-core/src/secp256k1'
58+
make[3]: Leaving directory '/home/standup/libwally-core/src/secp256k1'
59+
make[2]: Leaving directory '/home/standup/libwally-core/src/secp256k1'
60+
make[2]: Entering directory '/home/standup/libwally-core/src'
61+
make check-TESTS check-local
62+
make[3]: Entering directory '/home/standup/libwally-core/src'
63+
make[4]: Entering directory '/home/standup/libwally-core/src'
64+
PASS: test_bech32
65+
PASS: test_psbt
66+
PASS: test_psbt_limits
67+
PASS: test_tx
68+
============================================================================
69+
Testsuite summary for libwallycore 0.7.8
70+
============================================================================
71+
# TOTAL: 4
72+
# PASS: 4
73+
# SKIP: 0
74+
# XFAIL: 0
75+
# FAIL: 0
76+
# XPASS: 0
77+
# ERROR: 0
78+
============================================================================
79+
make[4]: Leaving directory '/home/standup/libwally-core/src'
80+
make[3]: Nothing to be done for 'check-local'.
81+
make[3]: Leaving directory '/home/standup/libwally-core/src'
82+
make[2]: Leaving directory '/home/standup/libwally-core/src'
83+
make[1]: Leaving directory '/home/standup/libwally-core/src'
84+
make[1]: Entering directory '/home/standup/libwally-core'
85+
make[1]: Nothing to be done for 'check-am'.
86+
make[1]: Leaving directory '/home/standup/libwally-core'
87+
```
88+
Finalmente, podemos instalar:
89+
```
90+
$ sudo make install
91+
```
92+
93+
## Nos preparando para a Libwally
94+
95+
Então, como usamos a Libwally em nosso programa que estamos construindo? Como de costume, precisaremos incluir os arquivos e vincular as bibliotecas apropriadas em nosso código.
96+
97+
### Incluindo os arquivos
98+
99+
Há um número considerável de arquivos que podemos incluir:
100+
101+
```
102+
$ ls /usr/include/wally*
103+
/usr/include/wally_address.h /usr/include/wally_bip39.h /usr/include/wally_elements.h /usr/include/wally_script.h
104+
/usr/include/wally_bip32.h /usr/include/wally_core.h /usr/include/wally.hpp /usr/include/wally_symmetric.h
105+
/usr/include/wally_bip38.h /usr/include/wally_crypto.h /usr/include/wally_psbt.h /usr/include/wally_transaction.h
106+
```
107+
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`.
108+
109+
### Vinculando as bibliotecas
110+
111+
Também precisaremos vincular as bibliotecas apropriadas:
112+
```
113+
$ ls /usr/lib/libsecp* /usr/lib/libwally*
114+
/usr/lib/libsecp256k1.a /usr/lib/libwallycore.la /usr/lib/libwallycore.so.0
115+
/usr/lib/libsecp256k1.la /usr/lib/libwallycore.so /usr/lib/libwallycore.so.0.0.0
116+
```
117+
Usaremos principalmente a `libwallycore`.
118+
119+
## Configurando um programa Libwally
120+
121+
Comparado com algumas das bibliotecas anteriores, a Libwally é ridiculamente fácil de ser inicializada:
122+
```
123+
lw_response = wally_init(0);
124+
```
125+
E então, quando terminarmos, há uma função útil para limpar qualquer memória alocada:
126+
```
127+
wally_cleanup(0);
128+
```
129+
Em ambos os casos, o argumento é para flags, mas atualmente está definido como `0`.
130+
131+
## Testando um programa de teste da Libwally
132+
133+
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.
134+
135+
Podemos compilá-lo da seguinte maneira:
136+
```
137+
$ cc testwally.c -lwallycore -o testwally
138+
```
139+
Depois, podemos executá-lo:
140+
```
141+
$ ./testwally
142+
Startup: 0
143+
```
144+
O valor "Startup" é o retorno do comando `wally_init`. O valor `0` pode inicialmente parecer desanimador, mas é o que desejamos ver no momento:
145+
```
146+
include/wally_core.h:#define WALLY_OK 0 /** Success */
147+
```
148+
149+
## Instalando o Libsodium
150+
151+
Também precisamos instalar o Libsodium para obter acesso a um gerador de números aleatórios de alta qualidade para fins de teste.
152+
153+
> :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 export 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.
154+
155+
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.
156+
157+
Primeiro, descompactamos:
158+
```
159+
$ tar xzfv /tmp/libsodium-1.0.18-stable.tar.gz
160+
```
161+
Então, ajustamos o arquivo `configure` exatamente como fizemos nas outras bibliotecas até o momento:
162+
```
163+
< ac_default_prefix=/usr
164+
---
165+
> ac_default_prefix=/usr/local
166+
```
167+
Finalmente, usamos os comandos `make`,`check` e `install`:
168+
```
169+
$ make
170+
$ make check
171+
...
172+
============================================================================
173+
Testsuite summary for libsodium 1.0.18
174+
============================================================================
175+
# TOTAL: 77
176+
# PASS: 77
177+
# SKIP: 0
178+
# XFAIL: 0
179+
# FAIL: 0
180+
# XPASS: 0
181+
# ERROR: 0
182+
============================================================================
183+
...
184+
$ sudo make install
185+
```
186+
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.
187+
188+
## Resumo: Configurando a Libwally
189+
190+
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`).
191+
192+
Então, o que exatamente podemos fazer agora? É para dar essa resposta que temos todas as seções deste capítulo.
193+
194+
## O Que Vem Depois?
195+
196+
Vamos aprender mais sobre "Programando o Bitcoind usando o Libwally" na seção [§16.2: Usando o BIP39 no Libwally](16_2_Using_BIP39_in_Libwally.md).

‎pt/16_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 o BIP39 no 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 de Libwally é que ele pode revelar o trabalho oculto da geração de seeds, chaves privadas e, também, de endereços. Para começar, ele 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 é 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 são apenas 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.
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 Determinística Hierárquica. Voltaremos às seeds na próxima seção, onde falaremos sobre as carteiras Determinísticas Hierárquicas e a Libwally. Por enquanto, apenas é necessário saber que um código mnemônico BIP39 corresponde à seed para uma carteira determinística hierárquica do BIP32.
10+
11+
## Criando Códigos Mnemônicos
12+
13+
Todas as chaves Bitcoin começam com a entropia. Este primeiro uso de 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 Determinística Hierárquica que 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 [§16.1](16_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 a Entropia
33+
34+
Usando o `libsodium`, podemos criar a 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 quiser aumentar o tamanho da entropia, para gerar uma frase mnemônica mais longa, também precisaria 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 uma soma de verificação 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, pode gerar o mnemônico e vice-versa.
61+
62+
Se você 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+
### Mostrando na Tela a Nossa Seed
72+
73+
Se quisermos ver como nossa semente se parece 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/16_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 o BIP39 no Libwally
97+
98+
O BIP39 permite que possamos 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 §16.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 [§16.3: Usando o BIP32 no Libwally](16_3_Using_BIP32_in_Libwally.md).

0 commit comments

Comments
 (0)