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 16:06:26 +00:00
Code Issues Releases Wiki Activity

Review 09_2

Browse Source
This commit is contained in:
namcios 2021-07-27 16:57:35 -03:00
parent e35c5ae4fd
commit 4330d0f779
No known key found for this signature in database
GPG Key ID: 8E3A368317269AB4
1 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
pt/09_2_Running_a_Bitcoin_Script.md
View File

@ -1,24 +1,24 @@
# 9.2: Executando um script do Bitcoin
# 9.2: Executando um Script no Bitcoin
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.
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 (_stack_).
## Compreendendo a linguagem do script
## Compreendendo a Linguagem de Programação
Um script Bitcoin possui três partes: Uma linha de entrada; uma pilha para o armazenamento e; comandos específicos para execução.
Um script Bitcoin possui três partes: uma linha de entrada; uma pilha para o armazenamento; e comandos específicos para execução.
### Compreendendo o pedido
### Compreendendo a Ordem
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._
Os scripts do Bitcoin são executados da esquerda para a direita. Para nós é fácil, porque é a mesma ordem na qual lemos. No entanto, pode na verdade ser o elemento menos intuitivo do Bitcoin Script, porque significa que as funções não têm a aparência que esperaríamos. Ao invés disso, _os operandos vêm antes do operador._
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.
> :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.
> :warning: **ATENÇÃO:** Tecnicamente, tudo em Bitcoin Script é 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 em [§10.2: Construindo a Estrutura do P2SH](10_2_Building_the_Structure_of_P2SH.md). Alguns escritores preferem também retirar o prefixo "OP" de todos os operadores, mas nós optamos por não fazê-lo.
### Compreendendo a pilha
### Compreendendo a Pilha
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.
> :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.
> :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.
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:
```
@ -31,13 +31,13 @@ Stack: [ 1 ]
Script: OP_ADD
Stack: [ 1 2 ]
```
_ Observe que, neste e nos exemplos seguintes, o topo da pilha está à direita e a parte inferior à esquerda._
_Observe que, neste e nos exemplos seguintes, o topo da pilha está à direita e a parte inferior à esquerda._
### Compreendendo os Opcodes
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.
> :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").
> :book: ***O que é um Opcode?*** O Opcode significa "código de operação" (no inglês, "_operation code_"). É normalmente associado a código de linguagem de máquina e é uma função simples (ou "operador").
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).
```
@ -46,7 +46,7 @@ Running: 1 2 OP_ADD
Stack: [ 3 ]
```
## Colocando mais complexidade
## Construindo Complexidade
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:
```
@ -71,15 +71,15 @@ Running: 5 4 OP_SUB
Stack: [ 1 ]
```
## Compreendendo o uso do script do Bitcoin
## Compreendendo o Uso do Bitcoin Script
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.
É basicamente programar no Bitcoin ... além de algumas complexidades de como essa linguagem de programação interage com o próprio Bitcoin.
### Compreendendo o scriptSig e scriptPubKey
### Compreendendo scriptSig e scriptPubKey
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.
Como vimos anteriormente, cada entrada de uma transação no 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.
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```.
Então, presuma que um UTXO foi bloqueado com um ```scriptPubKey``` que leia ```OP_ADD 99 OP_EQUAL```, exigindo como entrada dois números que somam noventa e nove, e presuma que o ```scriptSig``` de ```1 98``` foi executado para desbloqueá-lo. Os dois scripts seriam efetivamente executados em ordem como ```1 98 OP_ADD 99 OP_EQUAL```.
Avaliando o resultado:
```
@ -103,23 +103,23 @@ Script:
Running: 99 99 OP_EQUAL
Stack: [ True ]
```
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```.
Esta abstração não é muito precisa: por razões de segurança, o ```scriptSig``` é executado, então o conteúdo da pilha é transferido para o ```scriptPubKey``` para ser executado, mas é precisa o suficiente para entender como a chave do ```scriptSig``` se encaixa no cadeado de ```scriptPubKey```.
> :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.
> :warning: **AVISO:** O exemplo acima é um tipo de transação não-padrão. 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: Compreendendo a Base do P2SH](10_1_Understanding_the_Foundation_of_P2SH.md) iremos discutir como realmente _poderíamos_ executar um Script Bitcoin como este, usando o poder do P2SH.
### Obtendo os resultados
### Obtendo os Resultados
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```:
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;
2. O item no topo da pilha no final da execução é verdadeiro (diferente de zero).
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).
## Resumo: Executando um script do Bitcoin
## Resumo: Executando um Script no Bitcoin
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.
Para processar um script no Bitcoin, um ```scriptSig``` é executado seguido pelo ```scriptPubKey``` que ele 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, então o UTXO será desbloqueado.
## O que vem depois?
## O Que Vem Depois?
Vamos continuar "Apresentando os Scripts no Bitcoin" na seção [§9.3: Testando o Script do Bitcoin](09_3_Testing_a_Bitcoin_Script.md).
Vamos continuar "Apresentando Scripts no Bitcoin" na seção [§9.3: Testando um Script no Bitcoin](09_3_Testing_a_Bitcoin_Script.md).