Skip to content

Commit 27c8bfc

Browse files
KoreaComKKoreaComK
committed
Finished translation of chapter 09
1 parent bb6dd6c commit 27c8bfc

6 files changed

Lines changed: 1010 additions & 0 deletions

‎pt/09_0_Introducing_Bitcoin_Scripts.md‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
# Capítulo 9: Apresentando os Scripts no Bitcoin
2+
3+
Até o momento, estamos interagindo com o Bitcoin em um nível relativamente alto de abstração. O programa ```Bitcoin-cli``` oferece acesso a uma variedade de comandos RPC que suportam a criação e controle de transações brutas de Bitcoin que incluem saldos, dados, timelocks e multisigs.
4+
5+
No entanto, o Bitcoin oferece muito mais complexidade do que isso. O software oferece uma linguagem de script simples que pode ser usada para criar condições de resgate ainda mais complexas. Se as multisigs e os timelocks fornecerem as bases para os contratos inteligentes, o script do Bitcoin constrói os alicerces. É o próximo passo para nos capacitar no mundo do bitcoin.
6+
7+
## Objetivos deste capítulo
8+
9+
Depois de trabalhar neste capítulo, um desenvolvedor será capaz de:
10+
11+
* Projetar um script do Bitcoin;
12+
* Aplicar um script do Bitcoin.
13+
14+
Os objetivos secundários do capítulo incluem a capacidade de:
15+
16+
* Compreender o propósito dos scripts do Bitcoin;
17+
* Entender os script P2PKH;
18+
* Entender como o P2WPKH funciona com os scripts;
19+
* Compreender as necessidades dos testes dos scripts do bitcoin.
20+
21+
## Tabela de Conteúdo
22+
23+
* [Seção 1: Entendendo o alicerce das transações](09_1_PriveStanding_the_foundation_of_transactions.md)
24+
* [Seção 2: Executando um script do Bitcoin](09_2_running_a_bitcoin_script.md)
25+
* [Seção 3: Testando um script do Bitcoin](09_3_testing_a_bitcoin_script.md)
26+
* [Seção 4: Criando um script P2PKH](09_4_scripting_a_p2pkh.md)
27+
* [Seção 5: Criando um script P2WPKH](09_5_scripting_a_p2wpkh.md)

‎pt/09_1_Understanding_the_Foundation_of_Transactions.md‎

Lines changed: 142 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
# 9.1: Entendendo o alicerce das transações
2+
3+
Os alicerces do Bitcoin são as capacidades de proteger as transações, algo que é feito com uma linguagem de scripts simples.
4+
5+
## Conhecendo as partes do quebra-cabeça criptográfico
6+
7+
Conforme descrito no [Capítulo 1](01_0_INTRODUCING_BITCOIN.MD), os saldos em cada transação Bitcoin estão travados com um quebra-cabeça criptográfico. Para sermos mais precisos, dissemos que o Bitcoin é composto de "uma sequência de transações atômicas". Observamos que: "Cada transação é autenticada por um remetente com a solução para um quebra-cabeça criptográfico anterior que foi armazenado como um script. A nova transação é bloqueada para o destinatário com um novo quebra-cabeça criptográfico que também é armazenado como um script". Esses scripts, que bloqueiam e desbloqueiam as transações, são escritos usando o script do bitcoin.
8+
9+
> :book: ***O que é o script do Bitcoin?*** O script do Bitcoin é uma linguagem baseada na linguagem de programação Forth que propositadamente evita loops, o que significa que ela não passa no processo de Turing. É composto de opcodes individuais. Cada transação única no Bitcoin é bloqueada com um script do Bitcoin. Quando a transação de bloqueio para um UTXO é executada com as entradas corretas, esse UTXO pode ser gasto.
10+
11+
O fato de que as transações estão bloqueadas com scripts significa que podem ser bloqueadas de várias maneiras diferentes, exigindo uma variedade de chaves diferentes. Na verdade, encontramos vários mecanismos de travamento diferentes até o momento, cada um dos quais usa diferentes opcodes:
12+
13+
* OP_CHECKSIG, que verifica uma chave pública contra uma assinatura, é a base do endereço P2PKH clássico, como será totalmente detalhado na seção [§9.3: Criando um script P2PKH](09_3_scripting_a_p2pkh.md);
14+
* OP_CHECKMULTISIG, faz a mesma coisa com as multisigs, como será totalmente detalhado na seção [§10.4: Criando um script multisig](10_4_scripting_a_multisig.md);
15+
* OP_CHECKLOCKTIMEVERIFY e OP_SEQUENCEVERIFY formam a base dos timelocks mais complexos, como será totalmente detalhado nas seções [§11.2: Usando CLTV nos scripts](11_2_using_cltv_in_scripts) e [§11.3: Usando o CSV nos scripts](11_3_using_csv_in_scripts.md).
16+
* OP_RETURN é a marca de uma transação não gasta, e é por isso que é usado para transportar dados, como falamos na seção [§8.2: Enviando uma transação com dados](08_2_sending_a_transaction_with_data.md).
17+
18+
## Accessando os scripts em nossas transações
19+
20+
Podemos não perceber, mas já vimos esses scripts de bloqueio e desbloqueio como parte das transações brutas que fizemos. A melhor maneira de analisar esses scripts com mais profundidade é, portanto, criar uma transação bruta e examiná-la.
21+
22+
### Criando uma transação de teste
23+
24+
Para examinar os scripts reais de desbloqueio e bloqueio, vamos criar uma transação bruta rapidamente, pegando um UTXO legado não gasto e reenviando-o a um endereço de troco legado, deixando uma parte para as taxas de transação:
25+
```
26+
$ utxo_txid=$(bitcoin-cli listunspent | jq -r '.[1] | .txid')
27+
$ utxo_vout=$(bitcoin-cli listunspent | jq -r '.[1] | .vout')
28+
$ recipient=$(bitcoin-cli -named getrawchangeaddress address_type=legacy)
29+
$ rawtxhex=$(bitcoin-cli -named createrawtransaction inputs='''[ { "txid": "'$utxo_txid'", "vout": '$utxo_vout' } ]''' outputs='''{ "'$recipient'": 0.0009 }''')
30+
$ signedtx=$(bitcoin-cli -named signrawtransactionwithwallet hexstring=$rawtxhex | jq -r '.hex')
31+
```
32+
Não precisamos enviá-la. O objetivo é simplesmente produzir uma transação para que possamos examiná-la.
33+
34+
>**NOTA:** Por que usar endereços legados? Porque nossos scripts são mais significativos. No entanto, também ofereceremos um exemplo de um endereço nativo Segwit P2WPKH na seção [§9.5](09_5_scripting_a_p2wpkh.md).
35+
36+
### Examinando nossa transação de teste
37+
38+
Agora podemos examinar nossa transação com profundida necessária usando ```decodivawtransaction``` no ```$signedtx```:
39+
```
40+
$ bitcoin-cli -named decoderawtransaction hexstring=$signedtx
41+
{
42+
"txid": "34151dac704d94a269cd33f80be34c122152edc9bfbb9323852966bf0ce937ed",
43+
"hash": "34151dac704d94a269cd33f80be34c122152edc9bfbb9323852966bf0ce937ed",
44+
"version": 2,
45+
"size": 191,
46+
"vsize": 191,
47+
"weight": 764,
48+
"locktime": 0,
49+
"vin": [
50+
{
51+
"txid": "bb4362dec15e67d366088f5493c789f22fb4a604e767dae1f6a631687e2784aa",
52+
"vout": 0,
53+
"scriptSig": {
54+
"asm": "304402201cc39005b076cb06534cd084fcc522e7bf937c4c9654c1c9dfba68b92cbab7d1022066f273178febc7a37568e2e9f4dec980a2e9a95441abe838c7ef64c39d85849c[ALL] 0315a0aeb37634a71ede72d903acae4c6efa77f3423dcbcd6de3e13d9fd989438b",
55+
"hex": "47304402201cc39005b076cb06534cd084fcc522e7bf937c4c9654c1c9dfba68b92cbab7d1022066f273178febc7a37568e2e9f4dec980a2e9a95441abe838c7ef64c39d85849c01210315a0aeb37634a71ede72d903acae4c6efa77f3423dcbcd6de3e13d9fd989438b"
56+
},
57+
"sequence": 4294967295
58+
}
59+
],
60+
"vout": [
61+
{
62+
"value": 0.00090000,
63+
"n": 0,
64+
"scriptPubKey": {
65+
"asm": "OP_DUP OP_HASH160 06b5c6ba5330cdf738a2ce91152bfd0e71f9ec39 OP_EQUALVERIFY OP_CHECKSIG",
66+
"hex": "76a91406b5c6ba5330cdf738a2ce91152bfd0e71f9ec3988ac",
67+
"reqSigs": 1,
68+
"type": "pubkeyhash",
69+
"addresses": [
70+
"mg8S7F1gY3ivV9M9GrWwe6ziWvK2MFquCf"
71+
]
72+
}
73+
}
74+
]
75+
}
76+
77+
```
78+
Os dois scripts são encontrados nas duas partes diferentes da transação.
79+
80+
O ```scriptSig``` está localizado no ```vin```. Este é o script de _desbloqueio_. É o que é executado para acessar o UTXO que está sendo usado para financiar esta transação. Haverá um ```scriptSig``` por UTXO em cada transação.
81+
82+
O ```scriptpubkey``` está localizado no ```vout```. Este é o script de _bloqueio_. É o que bloqueia a nova saída da transação. Haverá um ```scriptPubKey``` por cada saída em cada transação.
83+
84+
> :book: ***Como o scriptsig e o scriptpubkey interagem?*** O ```scriptSig``` de uma transação desbloqueia o UTXO anterior. A saída desta nova transação será bloqueada com um ```scriptPubKey```, que pode, por sua vez, ser desbloqueado pela ```scriptsig``` da transação que reutiliza esse UTXO.
85+
86+
### Lendo os scripts da transação
87+
88+
Se olharmos para os dois scripts e veremos que cada um possui duas representações diferentes: o ```hex``` é o que realmente é armazenado, mas a linguagem de montagem mais legível (```asm```) pode mostrar o que está acontecendo.
89+
90+
Vamos dar uma olhada no ```asm``` do script de desbloqueio para podermos ver em primeira mão como o Script do Bitcoin se parece:
91+
```
92+
04402201cc39005b076cb06534cd084fcc522e7bf937c4c9654c1c9dfba68b92cbab7d1022066f273178febc7a37568e2e9f4dec980a2e9a95441abe838c7ef64c39d85849c[ALL] 0315a0aeb37634a71ede72d903acae4c6efa77f3423dcbcd6de3e13d9fd989438b
93+
```
94+
Como acontece, essa bagunça de números é uma assinatura privada, seguida pela chave pública associada. Ou pelo menos isso é o esperado, porque é isso que é necessário para desbloquear o P2PKH UTXO que esta transação está usando.
95+
96+
Vamos ler o script de bloqueio e veremos que é algo muito mais óbvio:
97+
```
98+
OP_DUP OP_HASH160 06b5c6ba5330cdf738a2ce91152bfd0e71f9ec39 OP_EQUALVERIFY OP_CHECKSIG
99+
```
100+
Esse é o método padrão do script do Bitcoin para bloquear uma transação P2PKH.
101+
102+
Na seção [§9.4](09_4_scripting_a_p2pkh.md) será explicado como esses dois scripts andam juntos, mas primeiro precisamos saber como os scripts do Bitcoin são avaliados.
103+
104+
## Examinando um tipo diferente de transação
105+
106+
Antes de sairmos do alicerce, vamos olhar para um tipo diferente de script de bloqueio. Aqui está o ```scriptPubKey``` da transação multisig que criamos na seção [§6.1: Enviando uma Transação com Multisig](06_1_sending_a_transaction_to_a_multisig.md).
107+
```
108+
"scriptPubKey": {
109+
"asm": "OP_HASH160 a5d106eb8ee51b23cf60d8bd98bc285695f233f3 OP_EQUAL",
110+
"hex": "a914a5d106eb8ee51b23cf60d8bd98bc285695f233f387",
111+
"reqSigs": 1,
112+
"type": "scripthash",
113+
"addresses": [
114+
"2N8MytPW2ih27LctLjn6LfLFZZb1PFSsqBr"
115+
]
116+
}
117+
```
118+
119+
Vamos comparar isso com o ```ScriptPubkey``` da nossa nova transação P2PKH:
120+
```
121+
"scriptPubKey": {
122+
"asm": "OP_DUP OP_HASH160 06b5c6ba5330cdf738a2ce91152bfd0e71f9ec39 OP_EQUALVERIFY OP_CHECKSIG",
123+
"hex": "76a91406b5c6ba5330cdf738a2ce91152bfd0e71f9ec3988ac",
124+
"reqSigs": 1,
125+
"type": "pubkeyhash",
126+
"addresses": [
127+
"mg8S7F1gY3ivV9M9GrWwe6ziWvK2MFquCf"
128+
]
129+
}
130+
```
131+
132+
Essas duas transações são _definitivamente_ trancadas de maneiras diferentes. O Bitcoin reconhece o primeiro como sendo ```scripthash``` (P2SH) e o segundo como sendo ```pubkeyhash``` (P2PKH), mas também devemos ser capazes de ver a diferença nos diferentes códigos ```asm```:```OP_HASH160 a5d106eb8ee51b23cf60d8bd98bc285695f233f3 OP_EQUAL``` quando comparado com o ```OP_DUP OP_HASH160 06b5c6ba5330cdf738a2ce91152bfd0e71f9ec39 Op_equalverify op_checksig```. Este é o poder do script. Podemos simplesmente produzir alguns dos tipos drasticamente diferentes de transações que aprendemos nos capítulos anteriores.
133+
134+
## Resumo: Entendendo o alicerce das transações
135+
136+
Cada transação do bitcoin inclui pelo menos um script de desbloqueio (```scriptSig```), que resolve um quebra-cabeça criptográfico anterior, e pelo menos um script de bloqueio (```scriptPubKey```), que cria um novo quebra-cabeça criptográfico. Há um ```scriptSig``` para cada entrada e um ```scriptPubKey``` para cada saída. Cada um desses scripts é escrito usando o script do Bitcoin, uma linguagem semelhante a linguagem de programação Forth que fortalece ainda mais o Bitcoin.
137+
138+
> :fire: ***Qual é o poder dos scripts?*** Os scripts de desbloqueio são todo o poder dos contratos inteligentes. Com os opcodes apropriados, podemos tomar decisões muito precisas sobre quem pode resgatar os fundos, quando podem ser resgatados e como podem resgatá-los. Regras mais complexas para saldos corporativos, endereços de parceria, gastos com proxy e outras metodologias também podem ser codificados dentro de um script. Os scripts também conseguem capacitar serviços bitcoin mais complexos, como a lightning e as sidechains.
139+
140+
## O que vem depois?
141+
142+
Vamos continuar "Apresentando os Scripts no Bitcoin" na seção [§9.2: Executando um script do Bitcoin](09_2_running_a_bitcoin_script.md).

‎pt/09_2_Running_a_Bitcoin_Script.md‎

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
# 9.2: Executando um script do Bitcoin
2+
3+
Os scripts de Bitcoin podem não parecer tão intuitivos no começo, mas sua execução é bastante simples usando a notação polonesa reversa e uma pilha.
4+
5+
## Compreendendo a linguagem do script
6+
7+
Um script Bitcoin possui três partes: Uma linha de entrada; uma pilha para o armazenamento e; comandos específicos para execução.
8+
9+
### Compreendendo o pedido
10+
11+
Os scripts do Bitcoin são executados da esquerda para a direita. Para nós é fácil, porque é a mesma na qual lemos. No entanto, podemos ser o elemento mais não intuitivo do script do Bitcoin, porque significa que as funções não têm a aparência que nós esperávamos. Ao invés disso, _os operandos vêm antes do operador._
12+
13+
Por exemplo, se estivéssemos somando "1" e "2", nosso script do Bitcoin ficaria ```1 2 OP_ADD```, e _não_"1 + 2". Como sabemos que o operador OP_ADD recebe duas entradas, sabemos que as duas entradas anteriores são os operandos.
14+
15+
> :warning: **ATENÇÃO:** Tecnicamente, tudo no script do Bitcoin é um opcode, portanto, seria mais apropriado registrar o exemplo acima como ```OP_1 OP_2 OP_ADD```. Em nossos exemplos, não nos preocupamos sobre como as constantes serão avaliadas, pois esse é um tópico de tradução, como é explicado no capítulo [§10.2: Construindo a estrutura do P2SH](10_2_Building_the_Structure_of_P2SH.md). Alguns escritores preferem também não usar o prefixo "OP" nos operadores, mas optamos por não fazê-lo.
16+
17+
### Compreendendo a pilha
18+
19+
Na verdade, não é correto dizer que um operador se aplica às entradas anteriores. Na verdade, um operador se aplica às entradas principais na pilha do Bitcoin.
20+
21+
> :book: ***O que é uma pilha?*** Uma pilha é uma estrutura de dados LIFO (last in, first out, ou no português, primeiro a entrar, último a sair). Possui duas funções de acesso: Push e Pop. Empurrar (Push) coloca um novo objeto no topo da pilha, empurrando para baixo tudo que está abaixo dele. Retirar (Pop) remove o objeto superior da pilha.
22+
23+
Sempre que o script do Bitcoin encontrar uma constante, ele a coloca na pilha. Portanto, o exemplo acima de ```1 2 OP_ADD``` seria realmente parecido com o que foi processado:
24+
```
25+
Script: 1 2 OP_ADD
26+
Stack: [ ]
27+
28+
Script: 2 OP_ADD
29+
Stack: [ 1 ]
30+
31+
Script: OP_ADD
32+
Stack: [ 1 2 ]
33+
```
34+
_ Observe que, neste e nos exemplos seguintes, o topo da pilha está à direita e a parte inferior à esquerda._
35+
36+
### Compreendendo os Opcodes
37+
38+
Quando um script do Bitcoin encontra um operador, ele o avalia. Cada operador retira zero ou mais elementos da pilha como entradas, geralmente um ou dois. Em seguida, ele os processa de uma maneira específica antes de colocar zero ou mais elementos de volta na pilha, geralmente um ou dois.
39+
40+
> :book: ***O que é um Opcode?*** O Opcode significa "código de operação". É normalmente associado ao código de linguagem de máquina e é uma função simples (ou "operador").
41+
42+
OP_ADD retira dois itens da pilha (no nosso caso: 2 depois 1), adiciona-os e coloca o resultado de volta na pilha (no exemplo: 3).
43+
```
44+
Script:
45+
Running: 1 2 OP_ADD
46+
Stack: [ 3 ]
47+
```
48+
49+
## Colocando mais complexidade
50+
51+
Scripts mais complexos são criados executando mais comandos em ordem. Eles precisam ser avaliados cuidadosamente da esquerda para a direita, para que possamos entender o estado da pilha conforme cada novo comando é executado. Ele mudará constantemente, como resultado de operadores anteriores:
52+
```
53+
Script: 3 2 OP_ADD 4 OP_SUB
54+
Stack: [ ]
55+
56+
Script: 2 OP_ADD 4 OP_SUB
57+
Stack: [ 3 ]
58+
59+
Script: OP_ADD 4 OP_SUB
60+
Stack: [ 3 2 ]
61+
62+
Script: 4 OP_SUB
63+
Running: 3 2 OP_ADD
64+
Stack: [ 5 ]
65+
66+
Script: OP_SUB
67+
Stack: [ 5 4 ]
68+
69+
Script:
70+
Running: 5 4 OP_SUB
71+
Stack: [ 1 ]
72+
```
73+
74+
## Compreendendo o uso do script do Bitcoin
75+
76+
Acima, você viu basicamente, o que é o script do Bitcoin... Além de algumas complexidades de como essa, a linguagem script interage com o próprio Bitcoin.
77+
78+
### Compreendendo o scriptSig e scriptPubKey
79+
80+
Como vimos anteriormente, cada entrada da transação de Bitcoin contém um ```scriptSig``` que é usado para desbloquear o ```scriptPubKey``` para o UTXO associado. Eles são _efetivamente_ concatenados, o que significa que o ```scriptSig``` e o ```scriptPubKey``` são executados juntos, nessa ordem.
81+
82+
Então, podemos presumir que um UTXO foi bloqueado com um ```scriptPubKey``` que lê ```OP_ADD 99 OP_EQUAL```, exigindo como entrada dois números que somam noventa e nove, e podemos presumir que o ```scriptSig``` de ```1 98``` foi executado para desbloquear. Os dois scripts seriam efetivamente executados em ordem como ```1 98 OP_ADD 99 OP_EQUAL```.
83+
84+
Avaliando o resultado:
85+
```
86+
Script: 1 98 OP_ADD 99 OP_EQUAL
87+
Stack: []
88+
89+
Script: 98 OP_ADD 99 OP_EQUAL
90+
Stack: [ 1 ]
91+
92+
Script: OP_ADD 99 OP_EQUAL
93+
Stack: [ 1 98 ]
94+
95+
Script: 99 OP_EQUAL
96+
Running: 1 98 OP_ADD
97+
Stack: [ 99 ]
98+
99+
Script: OP_EQUAL
100+
Stack: [ 99 99 ]
101+
102+
Script:
103+
Running: 99 99 OP_EQUAL
104+
Stack: [ True ]
105+
```
106+
Esta abstração não é muito precisa, já que, por razões de segurança, o ```scriptSig``` é executado, então o conteúdo da pilha é transferido para o ```scriptPubKey``` para ser executado, mas é preciso o suficiente para entender como a chave do ```scriptSig``` se encaixa o bloqueio de ```scriptPubKey```.
107+
108+
> :warning: **AVISO:** O exemplo acima é um tipo de transação incomum. Na verdade, não seria aceito por nós que executamos o Bitcoin Core com as configurações padrões. Na seção [§10.1: Construindo um script do Bitcoin com P2SH](10_1_Understanding_the_Foundation_of_P2SH.md) iremos discutir como realmente _podemos_ executar um Script Bitcoin como este, usando o poder do P2SH.
109+
110+
### Obtendo os resultados
111+
112+
O Bitcoin irá verificar uma transação e permitir que o UTXO possa ser gasto novamente se dois critérios forem atendidos ao executar o ```scriptSig``` e o ```scriptPubKey```:
113+
114+
1. A execução não foi marcada como inválida em nenhum ponto, por exemplo, com um OP_VERIFY com falha ou com o uso de um opcode desativado;
115+
2. O item no topo da pilha no final da execução é verdadeiro (diferente de zero).
116+
117+
No exemplo acima, a transação seria bem-sucedida porque a pilha tem um ```True``` no final. Mas, seria igualmente permitido terminar com uma pilha completa e o número ```42``` no topo (os leitores do Guia do Mochileiro das Galáxias pegaram a referência).
118+
119+
## Resumo: Executando um script do Bitcoin
120+
121+
Para processar um script do Bitcoin, um ```scriptSig``` é executado seguido pelo ```scriptPubKey``` que está desbloqueando. Esses comandos são executados em ordem, da esquerda para a direita, com constantes sendo colocadas em uma pilha e os operadores retirando elementos dessa pilha e, em seguida, enviando os resultados de volta para ela. Se o Script não parar no meio e se o item no topo da pilha no final for diferente de zero, o UTXO será desbloqueado.
122+
123+
## O que vem depois?
124+
125+
Vamos continuar "Apresentando os Scripts no Bitcoin" na seção [§9.3: Testando o Script do Bitcoin](09_3_Testing_a_Bitcoin_Script.md).

0 commit comments

Comments
 (0)