mirror of
https://github.com/ChristopherA/Learning-Bitcoin-from-the-Command-Line.git
synced 2025-06-07 16:06:26 +00:00
Merge pull request #477 from namcios/portuguese-translation
Portuguese-Translation: Standardize chapters and files, update README
This commit is contained in:
commit
cf77bec66f
@ -1,5 +1,4 @@
|
||||
|
||||
# CAPÍTULO 1: Introdução à Aprendizagem do Bitcoin Core (& Lightning Network) pela linha de comando
|
||||
# Capítulo 1: Introdução à Aprendizagem do Bitcoin Core (& Lightning) pela Linha de Comando
|
||||
|
||||
## Introdução
|
||||
|
||||
@ -19,18 +18,18 @@ Você não precisa ser particularmente uma pessoa da área técnica para boa par
|
||||
|
||||
Uma minoria deste curso requer conhecimento de programação, e você deve pular essas seções, se necessário, conforme iremos discutir na próxima seção.
|
||||
|
||||
## Resumo dos tópicos
|
||||
## Resumo dos Tópicos
|
||||
|
||||
Este livro é dividido nas seguintes seções:
|
||||
|
||||
| Parte | Descrição | Habilidades |
|
||||
|-------|---------|---------|
|
||||
| **Parte 1: Se preparando para o Bitcoin** | Entendendo os fundamentos do Bitcoin e configurando um servidor para uso. | Linha de Comando |
|
||||
| **Parte 2: Usando o bitcoin-cli** | Usando o Bitcoin-cli para criar transações. | Linha de Comando |
|
||||
| **Parte 3: Fazendo scripts com Bitcoin** | Expandindo seu trabalho no bitcoin com scripts. | Conceitos de Programação |
|
||||
| **Parte 4: Usando o Tor** | Melhorando a segurança do _node_ com tor | Linha de Comando |
|
||||
| **Parte 5: Programando com RPC** | Acessando o RPC com C e outras linguagens. | Programando em C |
|
||||
| **Parte 6: Usando a lightning-cli** | Usando a Lightning-CLI para criar transações. | Linha de Comando |
|
||||
| **Parte Um: Se Preparando para o Bitcoin** | Entendendo os fundamentos do Bitcoin e configurando um servidor para uso. | Linha de Comando |
|
||||
| **Parte Dois: Usando o Bitcoin-CLI** | Usando o Bitcoin-CLI para criar transações. | Linha de Comando |
|
||||
| **Parte Três: Programando no Bitcoin** | Expandindo nosso trabalho no Bitcoin com scripts. | Conceitos de Programação |
|
||||
| **Parte Quatro: Privacidade** | Melhorando a segurança do nosso node com Tor ou I2P | Linha de Comando |
|
||||
| **Parte Cinco: Programando com RPC** | Acessando o RPC com C e outras linguagens. | Programando em C |
|
||||
| **Parte Seis: Usando a Lightning-CLI** | Usando a Lightning-CLI para criar transações. | Linha de Comando |
|
||||
| **Apêndices.** | Utilizando configurações incomuns no Bitcoin. | Linha de Comando |
|
||||
|
||||
## Como Usar Este Curso
|
||||
@ -39,12 +38,12 @@ Então, por onde você começa? Este livro é destinado principalmente para ser
|
||||
|
||||
Se você tem diferentes níveis de habilidade ou se quiser aprender coisas diferentes, poderá pular para algumas partes diferentes do livro:
|
||||
|
||||
* Se você já tem um ambiente pronto do Bitcoin para ser utilizado, vá para o [Capítulo 3: Entendendo sua configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
* Se você só se importa com os Scriptos em Bitcoin, pule para o [Capítulo 9: Apresentando os Scripts no Bitcoin](09_0_Introducing_Bitcoin_Scripts.md).
|
||||
* Se você quiser apenas ler sobre o uso das linguagens de programação, pule para o [Capítulo 15: Falando com o Bitcoin](15_0_Talking_to_Bitcoind.md).
|
||||
* Se não quer programar nada, definitivamente ignore os capítulos 15 ao 17 enquanto estiver lendo, e talvez seja melhor pular os capítulos 9 ao 13. O resto do curso ainda deve fazer sentido sem eles.
|
||||
* Se estiver interessado apenas na Lightning Network, corra para o [Capítulo 18: Entendendo sua configuração da Lightning Network](18_0_Understanding_Your_Lightning_Setup.md).
|
||||
* Se quiser ler o conteúdo novo adicionado na versão 2 do curso (2020), seguido da versão 1 (2017), leia [§3.5: Entendendo o descritor](03_5_Understanding_the_Descriptor.md), [§4.6: Criando uma transação SegWit](04_6_Creating_a_Segwit_Transaction.md), [Capítulo 7: Expandindo o Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md), [§9.5: Criando um script P2WPKH](09_5_Scripting_a_P2WPKH.md), [§10.5: Criando um script SegWit](10_5_Scripting_a_Segwit_Script.md), [Capítulo 14: Usando o Tor](14_0_Using_Tor.md), [Capítulo 15: Conversando com o Bitcoin com C](15_0_Talking_to_Bitcoind.md), [Capítulo 16: Programando com Libwally](16_0_Programming_with_Libwally.md), [Capítulo 17: Conversando com o Bitcoind usando outras linguagens](17_0_Talking_to_Bitcoind_Other.md), [Capítulo 18: Entendendo sua configuração da Lightning ](18_0_Understanding_Your_Lightning_Setup.md), e [Capítulo 19: Usando a Lightning](19_0_Using_Lightning.md).
|
||||
* Se você já tem um ambiente pronto do Bitcoin para ser utilizado, vá para o [Capítulo 3: Compreendendo Nossa Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
* Se você só se importa com programar no Bitcoin, pule para o [Capítulo 9: Apresentando os Scripts do Bitcoin](09_0_Introducing_Bitcoin_Scripts.md).
|
||||
* Se você quiser apenas ler sobre o uso das linguagens de programação, pule para o [Capítulo 16: Conversando com o Bitcoind com C](16_0_Talking_to_Bitcoind.md).
|
||||
* Se não quer programar nada, definitivamente ignore os capítulos 16 ao 18 enquanto estiver lendo, e talvez seja melhor pular os capítulos 9 ao 13. O resto do curso ainda deve fazer sentido sem eles.
|
||||
* Se estiver interessado apenas na Lightning Network, corra para o [Capítulo 19: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md).
|
||||
* Se quiser ler o conteúdo novo adicionado na versão 2 do curso (2020), seguido da versão 1 (2017), leia [§3.5: Entendendo o Descritor](03_5_Understanding_the_Descriptor.md), [§4.6: Criando uma Transação SegWit](04_6_Creating_a_Segwit_Transaction.md), [Capítulo 7: Expandindo Transações no Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md), [§9.5: Programando um P2WPKH](09_5_Scripting_a_P2WPKH.md), [§10.5: Programando um Script SegWit](10_5_Scripting_a_Segwit_Script.md), [Capítulo 14: Usando o Tor](14_0_Using_Tor.md), [Capítulo 16: Conversando com o Bitcoind com C](16_0_Talking_to_Bitcoind.md), [Capítulo 17: Programando o Bitcoin com Libwally](17_0_Programming_with_Libwally.md), [Capítulo 18: Conversando com o Bitcoind com Outras Linguagens](18_0_Talking_to_Bitcoind_Other.md), [Capítulo 19: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md), e [Capítulo 20: Usando a Lightning](20_0_Using_Lightning.md).
|
||||
|
||||
## Por Que Utilizar Este Curso
|
||||
|
||||
@ -52,13 +51,13 @@ Obviamente, você está querendo fazer este curso porque está interessado no Bi
|
||||
|
||||
## Como Ajudar Este Curso
|
||||
|
||||
* Por favor, use a área de [Issues](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line/issues) para quaisquer dúvidas. A Blockchain Commons não tem uma equipe ativa de suporte, e não podemos abordar problemas ou perguntas individuais, mas olharemos iremos tratá-los com o tempo e os usaremos para melhorar nossas futuras iterações no curso.
|
||||
* Por favor, use a área de [Issues](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line/issues) para quaisquer dúvidas. A Blockchain Commons não tem uma equipe ativa de suporte, e não podemos abordar problemas ou perguntas individuais, mas iremos tratá-los com o tempo e os usaremos para melhorar nossas futuras iterações no curso.
|
||||
* Por favor, use os [PRs](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line/pulls) para quaisquer correções de erros de digitação ou comandos incorretos (ou que foram alterados). Para alterações técnicas ou de linha de comando, é muito útil se você usar também os comentários para explicar por que fez o que você fez, para que não precisemos gastar tempo pesquisando o motivo.
|
||||
* Por favor, use nossa [Área de Discussão da Comunidade](https://github.com/BlockchainCommons/Community/discussions) para falar sobre carreiras e habilidades. A Blockchain Commons ocasionalmente oferece estágios, como falado em nosso repo da comunidade.
|
||||
* Por favor, [torne-se um patrono](https://github.com/sponsors/BlockchainCommons) se achar este curso útil ou se quiser ajudar a educar a próxima geração de programadores da blockchain.
|
||||
* Por favor, use nossa [Área de Discussão da Comunidade](https://github.com/BlockchainCommons/Community/discussions) para falar sobre carreiras e habilidades. A Blockchain Commons ocasionalmente oferece estágios, como falado em nosso repositório da comunidade.
|
||||
* Por favor, [torne-se um patrocinador](https://github.com/sponsors/BlockchainCommons) se achar este curso útil ou se quiser ajudar a educar a próxima geração de programadores da blockchain.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Se você quiser uma introdução básica ao Bitcoin, criptografia de chave pública, ECC, blockchains e Lightning Network, leia o prefácio [Introdução ao Bitcoin](01_1_Introducing_Bitcoin.md).
|
||||
Se você quiser uma introdução básica ao Bitcoin, criptografia de chave pública, ECC, blockchains e Lightning Network, leia o prefácio [Apresentando o Bitcoin](01_1_Introducing_Bitcoin.md).
|
||||
|
||||
Caso contrário, se já estiver pronto para mergulhar de cabeça no curso, vá para [Configurando um Bitcoin-Core no VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md).
|
||||
Caso contrário, se já estiver pronto para mergulhar de cabeça no curso, vá para [Configurando um Bitcoin-Core VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md).
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
# Prefácio: Apresentando o Bitcoin
|
||||
|
||||
Antes de começar a programar em Bitcoin (e Lightning), você deve ter uma compreensão básica do que são e como funcionam. Esta seção fornece essa visão geral. Várias outras definições irão aparecer mais à frente. O objetivo deste capítulo é apenas dar o conteúdo base.
|
||||
@ -25,11 +24,11 @@ Os fundos são protegidos pelo uso de hashes. As chaves públicas não são real
|
||||
|
||||
No entanto, esses scripts do Bitcoin são o nível mais baixo de funcionalidade deste protocolo. Grande parte do trabalho do Bitcoin é feito através do `bitcoind` do Bitcoin, que é controlado por meio de comandos RPC. Muitas pessoas enviam esses comandos RPC por meio do programa chamado `bitcoin-cli`, que fornece uma interface ainda mais simples. Os não programadores nem mesmo se preocupam com essas minúcias, permitindo o uso de carteiras programáveis com interfaces mais simples.
|
||||
|
||||
### Resumindo o Bitcoin
|
||||
### Bitcoin –– Em Resumo
|
||||
|
||||
Uma maneira de pensar no Bitcoin é como _uma sequência de transações atômicas_. 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. Cada transação é registrada no livro razão global imutável.
|
||||
|
||||
## Sobre criptografia de chave pública
|
||||
## Sobre Criptografia de Chave Pública
|
||||
|
||||
A criptografia de chave pública é um sistema matemático para proteção de dados e comprovação de propriedade por meio de um par assimétrico de chaves que estão vinculadas entre si: a chave pública e a chave privada.
|
||||
|
||||
@ -45,15 +44,15 @@ A criptografia de chave pública é um sistema matemático para proteção de da
|
||||
|
||||
O Bitcoin aproveita a capacidade do hash de disfarçar os dados originais, o que permite ocultar a chave pública real do usuário, tornando as transações resistentes à computação quântica.
|
||||
|
||||
### Resumindo a criptografia de chave pública
|
||||
### Criptografia de Chave Pública –– Em Resumo
|
||||
|
||||
Uma maneira de pensar na criptografia de chave pública é: _um jeito de qualquer pessoa proteger os dados de forma que apenas uma pessoa autorizada possa acessá-los e também possa provar que tem esse acesso._
|
||||
|
||||
## Sobre CCE
|
||||
|
||||
O CCE é um acrônimo para criptografia de curva elíptica. É um ramo específico da criptografia de chave pública que depende de cálculos matemáticos usando curvas elípticas definidas sobre campos finitos. É mais complexo e difícil de explicar do que a criptografia de chave pública clássica (que usava números primos), mas tem algumas vantagens interessantes.
|
||||
CCE é um acrônimo para criptografia de curva elíptica(em inglês: ECC, ou Elliptic-Curve Cryptography). É um ramo específico da criptografia de chave pública que depende de cálculos matemáticos usando curvas elípticas definidas sobre campos finitos. É mais complexo e difícil de explicar do que a criptografia de chave pública clássica (que usava números primos), mas tem algumas vantagens interessantes.
|
||||
|
||||
O CCE não terá tanta atenção neste tutorial. Isso porque falaremos mais sobre a integração com servidores Bitcoin Core e Lightning, que já cuidaram da parte criptografia para você. Na verdade, a intenção deste tutorial é que você não precise se preocupar com a criptografia, porque isso é algo que você _realmente_ deseja que os especialistas lidem.
|
||||
A CCE não receberá tanta atenção neste tutorial. Isso porque falaremos mais sobre a integração com servidores Bitcoin Core e Lightning, que já cuidaram da parte criptografia para você. Na verdade, a intenção deste tutorial é que você não precise se preocupar com a criptografia, porque isso é algo que você _realmente_ deseja que os especialistas lidem.
|
||||
|
||||
**_O que é uma curva elíptica?_** Uma curva elíptica é uma curva geométrica que assume a forma ``y`` <sup>`` 2`` </sup> = ``x`` <sup> ``3`` </sup> `` + ax + b``. Uma curva elíptica específica é escolhida selecionando valores específicos de ``a`` e ``b``. A curva deve ser examinada cuidadosamente para determinar se funciona bem para criptografia. Por exemplo, a curva secp256k1 usada pelo Bitcoin é definida como ``a = 0`` e ``b = 7``.
|
||||
|
||||
@ -67,11 +66,11 @@ Qualquer linha que cruze uma curva elíptica o fará em 1 ou 3 pontos... e essa
|
||||
|
||||
Essa metodologia específica também explica por que os campos finitos são usados em curvas elípticas: Ela garante que a chave privada não ficará muito grande. Observe que o campo finito para secp256k1 é ligeiramente menor que 256 bits, o que significa que todas as chaves públicas terão 256 bits, assim como as chaves privadas.
|
||||
|
||||
**_Quais são as vantagens do CCE?_** A principal vantagem do CCE é que ele permite a mesma segurança da criptografia de chave pública clássica com uma chave muito menor. Uma chave pública de curva elíptica de 256 bits corresponde a uma chave pública tradicional (RSA) de 3072 bits.
|
||||
**_Quais são as vantagens da CCE?_** A principal vantagem da CCE é que ele permite a mesma segurança da criptografia de chave pública clássica com uma chave muito menor. Uma chave pública de curva elíptica de 256 bits corresponde a uma chave pública tradicional (RSA) de 3072 bits.
|
||||
|
||||
### Resumindo o CCE
|
||||
### CCE –– Em Resumo
|
||||
|
||||
Uma maneira de pensar no CCE é: _Um jeito de permitir a criptografia de chave pública usando chaves muito pequenas e uma matemática bem obscura._
|
||||
Uma maneira de pensar na CCE é: _um jeito de permitir a criptografia de chave pública usando chaves muito pequenas e uma matemática bem obscura._
|
||||
|
||||
## Sobre Blockchains
|
||||
|
||||
@ -83,16 +82,16 @@ Embora precise entender os fundamentos de como uma blockchain funciona para ente
|
||||
|
||||
**_O que é um fork?_** Ocasionalmente, dois blocos são criados ao mesmo tempo. Isso cria, temporariamente, um fork de um bloco, onde qualquer um dos blocos atuais pode ser o "verdadeiro". De vez em quando, um fork pode se expandir para dois blocos, três blocos ou mesmo quatro blocos de comprimento, mas muito rapidamente um lado da bifurcação é determinado como o verdadeiro e o outro se torna o que chamamos de "órfão". Isso faz parte do processo estocástico de criação de bloco e demonstra por que vários blocos devem ser construídos sobre um bloco antes que ele possa ser considerado verdadeiramente confiável e não rejeitável.
|
||||
|
||||
### Resumindo a blockchain
|
||||
### Blockchain –– Em Resumo
|
||||
|
||||
Uma maneira de pensar na blockchain é: _Uma série vinculada de blocos de dados imutáveis, até o seu bloco inicial._
|
||||
Outra forma é: _Uma série de blocos vinculados para ordenar dados absolutos que podem ser conflitantes_.
|
||||
|
||||
## A Blockchain é adequada para mim?
|
||||
## A Blockchain é Adequada para Mim?
|
||||
|
||||
Se você deseja negociar bitcoins, então obviamente a Bitcoin é adequada para você. No entanto, de forma mais ampla, a blockchain se tornou uma cultura pop da atualidade, embora não seja uma solução mágica para todos os problemas técnicos. Dito isso, existem muitas situações específicas em que a blockchain é uma tecnologia superior.
|
||||
|
||||
Blockchains provavelmente _são_ úteis nos seguintes casos:
|
||||
Blockchains provavelmente _serão_ úteis nos seguintes casos:
|
||||
|
||||
* Os usuários não confiam uns nos outros.
|
||||
* Ou: Os usuários estão em diferentes localidades.
|
||||
@ -119,32 +118,32 @@ Blockchains provavelmente _não_ serão úteis caso:
|
||||
|
||||
Observe que ainda pode haver soluções para algumas dessas situações dentro do ecossistema Bitcoin. Por exemplo, os canais de pagamento estão lidando rapidamente com questões de liquidez e finalização do pagamento.
|
||||
|
||||
## Sobre a Lightning (Network)
|
||||
## Sobre a Lightning
|
||||
|
||||
A lightning é um protocolo de segunda camada que interage com o Bitcoin para permitir que os usuários troquem seus bitcoins "offchain" (fora da blockchain). Possui vantagens e desvantagens em relação ao uso da camada principal do Bitcoin.
|
||||
A Lightning é um protocolo de segunda camada que interage com o Bitcoin para permitir que os usuários troquem seus bitcoins "offchain" (fora da blockchain). Possui vantagens e desvantagens em relação ao uso da camada principal do Bitcoin.
|
||||
|
||||
A lightning também é um dos focos deste tutorial. Embora o ponto principal seja sobre a interação direta com o Bitcoin (e o `bitcoind`), vamos falar um pouco sobre a lightning e o porque é uma tecnologia que está prestes a se tornar uma alternativa popular ao Bitcoin, em um futuro próximo. Este livro tem a mesma abordagem para a lightning e para o Bitcoin: Ele ensina como interagir diretamente com a Lightning de maneira confiável à partir da linha de comando.
|
||||
A Lightning também é um dos focos deste tutorial. Embora o ponto principal seja sobre a interação direta com o Bitcoin (e o `bitcoind`), vamos falar um pouco sobre a Lightning e o porque é uma tecnologia que está prestes a se tornar uma alternativa popular ao Bitcoin, em um futuro próximo. Este livro tem a mesma abordagem para a Lightning e para o Bitcoin: Ele ensina como interagir diretamente com a Lightning de maneira confiável à partir da linha de comando.
|
||||
|
||||
Ao contrário do Bitcoin, existem várias variantes da lightning. Este tutorial usa a implementação compatível do padrão [C-lightning](https://github.com/ElementsProject/lightning) como sendo seu servidor lightning confiável.
|
||||
Ao contrário do Bitcoin, existem várias variantes da Lightning. Este tutorial usa a implementação compatível do padrão [c-lightning](https://github.com/ElementsProject/lightning) como sendo seu servidor Lightning confiável.
|
||||
|
||||
**_O que é um protocolo de segunda camada?_** Um protocolo de segunda camada no Bitcoin funciona tendo como base o Bitcoin. Nesse caso, a lightning trabalha em cima do Bitcoin, interagindo com ele por meio de contratos inteligentes.
|
||||
**_O que é um protocolo de segunda camada?_** Um protocolo de segunda camada no Bitcoin funciona tendo como base o Bitcoin. Nesse caso, a Lightning trabalha em cima do Bitcoin, interagindo com ele por meio de contratos inteligentes.
|
||||
|
||||
**_O que é um canal lightning?_** Um canal Lightning é uma conexão entre dois usuários utilizando a lightning. Cada um dos usuários bloqueia uma quantidade de bitcoins na blockchain do Bitcoin usando uma assinatura multi-sig, criada e assinada por ambos. Os dois usuários podem, então, trocar bitcoins por meio do canal lightning sem precisar gravar nada na blockchain Bitcoin. Somente quando desejam fechar o canal, eles liquidam os bitcoins, com base na divisão no saldo final das partes.
|
||||
**_O que é um canal Lightning?_** Um canal Lightning é uma conexão entre dois usuários utilizando a Lightning. Cada um dos usuários bloqueia uma quantidade de bitcoins na blockchain do Bitcoin usando uma assinatura multi-sig, criada e assinada por ambos. Os dois usuários podem, então, trocar bitcoins por meio do canal Lightning sem precisar gravar nada na blockchain Bitcoin. Somente quando desejam fechar o canal, eles liquidam os bitcoins, com base na divisão no saldo final das partes.
|
||||
|
||||
**_O que é a Lightning Network?_** A junção de todos os canais da lightning criam a Lightning Network. Isso permite que dois usuários que não tenham um canal entre si troquem bitcoins usando Lightning: O protocolo forma uma cadeia de canais entre os dois usuários e, em seguida, troca as moedas através da cadeia usando transações que chamamos de _time-locked transactions_.
|
||||
**_O que é a Lightning Network?_** A junção de todos os canais da Lightning criam a Lightning Network. Isso permite que dois usuários que não tenham um canal entre si troquem bitcoins usando Lightning: O protocolo forma uma cadeia de canais entre os dois usuários e, em seguida, troca as moedas através da cadeia usando transações que chamamos de _time-locked transactions_.
|
||||
|
||||
**_Quais são as vantagens da lightning?_** A lightning permite transações mais rápidas com taxas mais baixas. Isso cria a possibilidade real de micropagamentos usando bitcoin. Ela também oferece maior privacidade, uma vez que está fora da rede, com apenas o primeiro e o último estado da transação sendo gravados blockchain do Bitcoin.
|
||||
**_Quais são as vantagens da Lightning?_** A Lightning permite transações mais rápidas com taxas mais baixas. Isso cria a possibilidade real de micropagamentos usando bitcoin. Ela também oferece maior privacidade, uma vez que está fora da rede, com apenas o primeiro e o último estado da transação sendo gravados blockchain do Bitcoin.
|
||||
|
||||
**_Quais são as desvantagens do Lightning?_** A lightning ainda é uma tecnologia muito nova e não foi testada tão exaustivamente quanto o Bitcoin. Isso não é apenas uma questão de implementação tecnológica, mas também se o design que pode ser manipulado de maneiras não pensadas anteriormente.
|
||||
**_Quais são as desvantagens do Lightning?_** A Lightning ainda é uma tecnologia muito nova e não foi testada tão exaustivamente quanto o Bitcoin. Isso não é apenas uma questão de implementação tecnológica, mas também se o design que pode ser manipulado de maneiras não pensadas anteriormente.
|
||||
|
||||
### Resumindo a lightning
|
||||
### Resumindo a Lightning
|
||||
|
||||
Uma maneira de pensar na Lightning é: _Um jeito de transacionar bitcoins usando canais offchain entre duas pessoas, de modo que apenas o primeiro e o último estado precisem ser gravados na blockchain_.
|
||||
|
||||
## Resumo: Apresentando o Bitcoin
|
||||
|
||||
O Bitcoin é um sistema _peer-to-peer_ que permite a transferência de fundos por meio de transações bloqueadas por quebra-cabeças. Esses quebra-cabeças dependem da criptografia de curva elíptica de chave pública. Quando você generaliza as ideias por trás do Bitcoin, encontra-se as blockchains, uma tecnologia que atualmente está crescendo e inovando muitos setores. Quando você expande as ideias por trás do Bitcoin, obtém protocolos de segunda camada, como a lightning, que expandem o potencial da moeda.
|
||||
O Bitcoin é um sistema _peer-to-peer_ que permite a transferência de fundos por meio de transações bloqueadas por quebra-cabeças. Esses quebra-cabeças dependem da criptografia de curva elíptica de chave pública. Quando você generaliza as ideias por trás do Bitcoin, encontra-se as blockchains, uma tecnologia que atualmente está crescendo e inovando muitos setores. Quando você expande as ideias por trás do Bitcoin, obtém protocolos de segunda camada, como a Lightning, que expandem o potencial da moeda.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos avançar para "se preparar para o Bitcoin" com o [Capítulo Dois: Configurando um Bitcoin-Core no VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md).
|
||||
Vamos avançar em "Se Prepararando para o Bitcoin" com o [Capítulo Dois: Configurando um Bitcoin-Core VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md).
|
@ -1,5 +1,4 @@
|
||||
|
||||
# Capítulo 2: Configurando um Bitcoin-Core no VPS
|
||||
# Capítulo 2: Configurando um Bitcoin-Core VPS
|
||||
|
||||
Para começar a usar o Bitcoin, primeiro precisamos configurar uma máquina que execute o Bitcoin. Os artigos neste capítulo descrevem como fazer isso, principalmente usando um VPS (Virtual Private Server).
|
||||
|
||||
@ -23,5 +22,5 @@ Os objetivos secundários incluem a capacidade de:
|
||||
|
||||
Na verdade, não é preciso ler este capítulo inteiro. Decida se gostaria de executar um StackScript para configurar um node em um VPS Linode (§2.2); Ou você deseja configurar em um ambiente diferente, como em uma máquina AWS ou um Mac (§2.3). Em seguida, vá para a seção mais apropriada. Informações adicionais sobre nossas configurações sugeridas também podem ser encontradas no [Apêndice I](A1_0_Understanding_Bitcoin_Standup.md).
|
||||
|
||||
* [Seção Um: Configurando um Bitcoin Core VPS com Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md)
|
||||
* [Seção Dois: Configurando uma máquina Bitcoin Core usando outros meios](02_2_Setting_Up_Bitcoin_Core_Other.md)
|
||||
* [Seção Um: Configurando um Bitcoin-Core VPS com Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md)
|
||||
* [Seção Dois: Configurando uma Máquina Bitcoin-Core de Outras Maneiras](02_2_Setting_Up_Bitcoin_Core_Other.md)
|
@ -1,4 +1,4 @@
|
||||
# 2.1: Configurando um Bitcoin Core VPS com Bitcoin Standup
|
||||
# 2.1: Configurando um Bitcoin-Core VPS com Bitcoin Standup
|
||||
|
||||
Este documento explica como configurar um VPS (Virtual Private Server, ou no português, Servidor Privado Virtual) para rodar um node do Bitcoin usando o Linode.com, instalado usando um StackScript automatizado do [projeto Bitcoin Standup](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). Apenas precisamos copiar e colar alguns comandos e inicializar o VPS. Quase que imediatamente após a inicialização, encontraremos o nosso novo node do Bitcoin baixando os blocos.
|
||||
|
||||
@ -227,7 +227,7 @@ Mas quando estabilizar em um número, estaremos prontos para continuar!
|
||||
|
||||
Mesmo assim, pode ser uma boa hora para mais alguns cafézinhos. Mas logo logo o nosso sistema estará pronto, e nós também!
|
||||
|
||||
## Resumo: Configurando um Bitcoin Core VPS Manualmente
|
||||
## Resumo: Configurando um Bitcoin-Core VPS Manualmente
|
||||
|
||||
Criar um Bitcoin Core VPS com os scripts Standup fizeram com que todo o processo fique rápido, simples, e (esperamos), indolor.
|
||||
|
||||
@ -238,7 +238,7 @@ Temos algumas opções para o que podemos seguir:
|
||||
* Ler o [StackScript](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) para entender a configuração;
|
||||
* Ler o que o StackScript faz no [Apêndice I: Compreendendo o Bitcoin Standup](A1_0_Understanding_Bitcoin_Standup.md);
|
||||
* Escolher uma metodologia inteiramente alternativa, como descrito na seção [§2.2: Configurando uma Máquina Bitcoin-Core de Outras Maneiras](02_2_Setting_Up_Bitcoin_Core_Other.md);
|
||||
* Usar o "bitcoin-cli" com o [Capítulo Três: Compreendendo a Sua Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
* Usar o "bitcoin-cli" com o [Capítulo Três: Compreendendo Nossa Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
|
||||
## Sinopse: Tipos de Instalação do Bitcoin
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
# 2.2: Configurando uma Máquina Bitcoin Core de Outras Maneiras
|
||||
# 2.2: Configurando uma Máquina Bitcoin-Core de Outras Maneiras
|
||||
|
||||
A seção anterior, [§2.1: Configurando um Bitcoin Core VPS com Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), assumimos que iríamos criar um full node em um VPS usando um StackScript Linode. Entretanto, podemos querer criar uma instância do Bitcoin Core via qualquer outra metodologia a nossa escolha e ainda assim acompanhar as próximas etapas deste tutorial.
|
||||
A seção anterior, [§2.1: Configurando um Bitcoin-Core VPS com Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), assumimos que iríamos criar um full node em um VPS usando um StackScript Linode. Entretanto, podemos querer criar uma instância do Bitcoin Core via qualquer outra metodologia a nossa escolha e ainda assim acompanhar as próximas etapas deste tutorial.
|
||||
|
||||
|
||||
A seguir estão outras metodologias de configuração das quais temos conhecimento:
|
||||
@ -15,4 +15,4 @@ A seguir estão outras metodologias de configuração das quais temos conhecimen
|
||||
|
||||
A não ser que queiramos retornar a alguma das outras metodologias de criação de um node Bitcoin Core, devemos:
|
||||
|
||||
* Seguir em frente usando o "bitcoin-cli" com o [Capítulo Três: Compreendendo Sua Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
* Seguir em frente para o "bitcoin-cli" com o [Capítulo Três: Compreendendo Nossa Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
|
@ -1,8 +1,8 @@
|
||||
# Capítulo 3: Compreendendo a configuração do node Bitcoin
|
||||
# Capítulo 3: Compreendendo Nossa Configuração do Bitcoin
|
||||
|
||||
Agora que estamos prontos para começar a trabalhar com a interface de linha de comando `bitcoin-cli`. Mas isso requer primeiro que entendamos a configuração do Bitcoin e os recursos da carteira, que é o que será explicado neste capítulo.
|
||||
|
||||
Neste e nos próximos capítulos, presumimos que uma VPS com Bitcoin instalado esteja sendo utilizada, e que iremos executar o `bitcoind`. Também presumimos que estamos conectados à testnet, permitindo o acesso a bitcoins sem usar fundos reais. Podemos fazer isso com Bitcoin Standup em linode.com, como vimos na sessão [2.1: Configurando um Bitcoin-Core no VPS c Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), ou usando os demais métodos, descritos na sessão [2.2: Configurando um node Bitcoin Core por outros métodos](02_2_Setting_Up_Bitcoin_Core_Other.md).
|
||||
Neste e nos próximos capítulos, presumimos que uma VPS com Bitcoin instalado esteja sendo utilizada, e que iremos executar o `bitcoind`. Também presumimos que estamos conectados à testnet, permitindo o acesso a bitcoins sem usar fundos reais. Podemos fazer isso com Bitcoin Standup em linode.com, como vimos na sessão [2.1: Configurando um Bitcoin-Core VPS com Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md), ou usando os demais métodos, descritos na sessão [2.2: Configurando uma Máquina Bitcoin Core de Outras Maneiras](02_2_Setting_Up_Bitcoin_Core_Other.md).
|
||||
|
||||
## Objetivos deste Capítulo
|
||||
|
||||
@ -23,9 +23,9 @@ Os objetivos secundários incluem a capacidade de:
|
||||
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção Um: Verificando a configuração do seu node Bitcoin](03_1_Verifying_Your_Bitcoin_Setup.md)
|
||||
* [Seção Dois: conhecendo a configuração do seu node Bitcoin](03_2_Knowing_Your_Bitcoin_Setup.md)
|
||||
* [Seção Três: Configurando sua carteira](03_3_Setting_Up_Your_Wallet.md)
|
||||
* [Usando variável de linha de comando](03_3__Interlude_Using_Command-Line_Variables.md)
|
||||
* [Seção Quatro: Recebendo uma transação](03_4_Receiving_a_Transaction.md)
|
||||
* [Seção Cinco: Entendendo um descritor](03_5_Understanding_the_Descriptor.md)
|
||||
* [Seção Um: Verificando Nossa Configuração do Bitcoin](03_1_Verifying_Your_Bitcoin_Setup.md)
|
||||
* [Seção Dois: Conhecendo Nossa Configuração do Bitcoin](03_2_Knowing_Your_Bitcoin_Setup.md)
|
||||
* [Seção Três: Configurando Nossa Carteira](03_3_Setting_Up_Your_Wallet.md)
|
||||
* [Usando Variáveis de Linha de Comando](03_3__Interlude_Using_Command-Line_Variables.md)
|
||||
* [Seção Quatro: Recebendo uma Transação](03_4_Receiving_a_Transaction.md)
|
||||
* [Seção Cinco: Compreendendo o Descritor](03_5_Understanding_the_Descriptor.md)
|
@ -1,9 +1,8 @@
|
||||
|
||||
# 3.1: Verificando a configuração do node Bitcoin
|
||||
# 3.1: Verificando Nossa Configuração do Bitcoin
|
||||
|
||||
Antes de começarmos a brincar com Bitcoin, devemos nos certificar de que tudo está configurado corretamente.
|
||||
|
||||
## Crie os aliases
|
||||
## Crie os Aliases
|
||||
|
||||
Sugerimos a criação de alguns aliases (um tipo de atalho) para facilitar o uso do Bitcoin.
|
||||
|
||||
@ -32,7 +31,7 @@ standup 455 1.3 34.4 3387536 1392904 ? SLsl Jun16 59:30 /usr/local/bin/
|
||||
|
||||
Se ele não estiver listado, podemos executar o `/usr/local/bin/bitcoind -daemon` manualmente e também colocá-lo em crontab.
|
||||
|
||||
## Verificando os blocos
|
||||
## Verificando os Blocos
|
||||
|
||||
Vamos partir do pressuposto que já tenhamos baixado todo o blockchain antes de começarmos a brincar. Basta executar o comando `bitcoin-cli getblockcount` para ver tudo está carregado corretamente.
|
||||
```
|
||||
@ -59,7 +58,7 @@ $ btcblock
|
||||
|
||||
Se a nossa blockchain não estiver atualizada, mas nosso `getblockcount` estiver aumentando, não há problema. O tempo total de download pode levar de uma a várias horas, dependendo da configuração.
|
||||
|
||||
## Opcional: Conhecendo os tipos de servidores
|
||||
## Opcional: Conhecendo os Tipos de Servidores
|
||||
|
||||
> **TESTNET vs MAINNET:** Ao configurar o node Bitcoin, precisamos escolher se vamos criá-lo como sendo um Mainnet, Testnet ou Regtest. Embora este documento presuma uma configuração de Testnet, vale a pena entender como podemos acessar e usar os outros tipos de configuração, inclusive, como ter todos na mesma máquina! Mas, se formos iniciantes, podemos pular isso, pois não é necessário para uma configuração básica.
|
||||
|
||||
@ -95,10 +94,10 @@ EOF
|
||||
```
|
||||
Para ainda mais complexidade, podemos fazer com que cada um dos aliases 'start' use o sinalizador -conf para carregar a configuração de um arquivo diferente. Isso vai muito além do escopo deste tutorial, mas o oferecemos como um ponto de partida para quando nossas explorações de Bitcoin atingirem o próximo nível.
|
||||
|
||||
## Resumo do Verificando a configuração do seu node Bitcoin
|
||||
## Resumo: Verificando Nossa Configuração do Bitcoin
|
||||
|
||||
Antes de começar a brincar com o Bitcoin, devemos nos certificar de que nossos aliases estão configurados, nosso bitcoind está rodando e os blocos foram baixados. Também podemos querer configurar algum acesso a configurações alternativas de Bitcoin, se formos usuários mais avançados.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Continue "Understanding Your Bitcoin Setup" com [3.2: Knowing Your Bitcoin Setup](03_2_Knowing_Your_Bitcoin_Setup.md).
|
||||
Continue "Compreendendo Nossa Configuração do Bitcoin" com [3.2: Conhecendo Nossa Configuração do Bitcoin](03_2_Knowing_Your_Bitcoin_Setup.md).
|
@ -1,9 +1,8 @@
|
||||
|
||||
# 3.2: Conhecendo a configuração do node Bitcoin
|
||||
# 3.2: Conhecendo Nossa Configuração do Bitcoin
|
||||
|
||||
Antes de começarmos a brincar com Bitcoin, é sempre bom entender melhor nossa configuração.
|
||||
|
||||
## Conhecendo o diretório do Bitcoin
|
||||
## Conhecendo o Diretório do Bitcoin
|
||||
|
||||
Para começar, devemos entender onde tudo está guardado: O diretório `~/.bitcoin`.
|
||||
|
||||
@ -24,7 +23,7 @@ Não deve mexer com a maioria desses arquivos e diretórios, particularmente os
|
||||
|
||||
> :link: **TESTNET vs MAINNET:** Se estivermos usando a Mainnet, então _tudo_ será colocado no diretório principal `~/.bitcoin`. Então se estivermos usando a Mainnet, Testnet e a Regtest, veremos que o `~/.bitcoin` contém nosso arquivo de configuração e nossos dados da mainnet, o diretório `~/.bitcoin/testnet3` contém nossos dados da Testnet, e o diretório `~/.bitcoin/regtest` contém os dados do regtest.
|
||||
|
||||
## Conhecendo os comandos do Bitcoin-cli
|
||||
## Conhecendo os Comandos do Bitcoin-CLI
|
||||
|
||||
A maior parte do nosso trabalho inicial será feito com o comando `bitcoin-cli`, que oferece uma interface simples para o `bitcoind`. Se quisermos mais informações sobre como utilizá-lo, basta executá-lo com o argumento `help`. Sem nenhum outro argumento, ele mostrara todos os possíveis comandos:
|
||||
```
|
||||
@ -202,7 +201,7 @@ Examples:
|
||||
```
|
||||
> :book: ***O que é o RPC?*** O`bitcoin-cli` é apenas uma interface útil que permite enviar comandos para o`bitcoind`. Mais especificamente, é uma interface que permite enviar comandos RPC (Remote Procedure Protocol ou, protocolo de procedimento remoto, no português) para o `bitcoind`. Frequentemente, o comando `bitcoin-cli` e o comando RPC possuem nomes e interfaces idênticos, mas alguns comandos no `bitcoin-cli` fornecem atalhos para solicitações RPC mais complexas. Geralmente, a interface `bitcoin-cli` é muito mais limpa e simples do que tentar enviar comandos RPC manualmente, usando `curl` ou algum outro método. No entanto, ele também tem limitações quanto ao que podemos fazer.
|
||||
|
||||
## Opcional: Conhecendo as informações do node Bitcoin
|
||||
## Opcional: Conhecendo as Informações do Node Bitcoin
|
||||
|
||||
Uma variedade de comandos bitcoin-cli podem fornecer informações adicionais sobre nossos node Bitcoin. Os mais comuns são:
|
||||
|
||||
@ -307,10 +306,10 @@ $ bitcoin-cli getnetworkinfo
|
||||
|
||||
Vamos testar à vontade qualquer um deles e usar `bitcoin-cli help` se quisermos saber mais informações sobre o que qualquer um deles faz.
|
||||
|
||||
## Resumo do Conhecendo a configuração do seu node Bitcoin
|
||||
## Resumo: Conhecendo Nossa Configuração do Bitcoin
|
||||
|
||||
O diretório `~/.bitcoin` contém todos os arquivos, enquanto o `bitcoin-cli help` nos retorna uma variedade de informações de comandos que podem ser usados para obter mais informações sobre como nossa configuração e o Bitcoin funcionam.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Compreendendo a configuração do node Bitcoin" na sessão [3.3: Configurando nossa carteira](03_3_Setting_Up_Your_Wallet.md).
|
||||
Vamos continuar "Compreendendo Nossa Configuração do Bitcoin" na sessão [3.3: Configurando Nossa Carteira](03_3_Setting_Up_Your_Wallet.md).
|
@ -1,9 +1,8 @@
|
||||
|
||||
# 3.3: Configurando nossa carteira
|
||||
# 3.3: Configurando Nossa carteira
|
||||
|
||||
Agora estamos prontos para começar a brincar com o Bitcoin. Para começar, precisaremos criar um endereço para receber fundos.
|
||||
|
||||
## Criando um endereço
|
||||
## Criando um Endereço
|
||||
|
||||
A primeira coisa que precisamos fazer é criar um endereço para recebimento de pagamentos. Podemos fazer isso usando o comando `bitcoin-cli getnewaddress`. Temos que lembrar que se quisermos mais informações sobre este comando, podemos digitar `bitcoin-cli help getnewaddress`. Atualmente, existem três tipos de endereços: Os `legacy` e os dois tipos de endereço SegWit, `p2sh-segwit` e `bech32`. Se não especificarmos qual queremos criar, sempre teremos por padrão o `bech32`.
|
||||
|
||||
@ -28,7 +27,7 @@ Anote cuidadosamente o endereço. Precisaremos utilizá-lo para quando recebermo
|
||||
|
||||
Com um único endereço em mãos, podemos pular direto para a próxima seção e começar a receber alguns satoshinhos. No entanto, antes de chegarmos lá, vamos discutir brevemente os outros tipos de endereços que encontraremos no futuro e falar sobre alguns outros comandos de carteira que podemos querer usar mais pra frente.
|
||||
|
||||
### Conhecendo os endereços do Bitcoin
|
||||
### Conhecendo os Endereços do Bitcoin
|
||||
|
||||
Existem três tipos de endereços Bitcoin que podemos criar com o comando RPC `getnewaddress`. Usaremos um endereço `legacy` (P2PKH) aqui, mas iremos utilizar um endereço SegWit (P2SH-SegWit) ou Bech32 na sessão [4.6: Criação de uma transação Segwit](04_6_Creating_a_Segwit_Transaction.md).
|
||||
|
||||
@ -50,7 +49,7 @@ Existem dois endereços desse tipo:
|
||||
|
||||
Existem outros tipos de endereços de Bitcoin, como P2PK (que paga a uma chave pública simples e está obsoleto devido à sua insegurança futura) e P2SH (que paga a um Hash de script e que é usado pelo SegWit e esta aninhado com a primeira geração endereços. Vamos conhecê-lo mais detalhadamente nos próximos capítulos).
|
||||
|
||||
## Opcional: Assinando uma mensagem
|
||||
## Opcional: Assinando uma Mensagem
|
||||
|
||||
Às vezes, precisamos provar que controlamos um endereço Bitcoin (ou melhor, que controlamos a chave privada). Isso é importante porque permite que as pessoas saibam que estão enviando fundos para a pessoa certa. Isso pode ser feito criando uma assinatura com o comando `bitcoin-cli signmessage`, na forma `bitcoin-cli signmessage [endereço] [mensagem]`. Por exemplo:
|
||||
|
||||
@ -77,7 +76,7 @@ error message:
|
||||
Invalid address
|
||||
```
|
||||
|
||||
## Opcional: Fazendo o dump da nossa carteira
|
||||
## Opcional: Fazendo o Dump da Nossa Carteira
|
||||
|
||||
Pode parecer perigoso ter todas as chaves privadas insubstituíveis em um único arquivo. É para isso que serve o comando `bitcoin-cli dumpwallet`. Ele permite que façamos uma cópia do nosso arquivo `wallet.dat`:
|
||||
```
|
||||
@ -97,7 +96,7 @@ error message:
|
||||
Importing wallets is disabled when blocks are pruned
|
||||
```
|
||||
|
||||
## Opcional: Visualizando as chaves privadas
|
||||
## Opcional: Visualizando as Chaves Privadas
|
||||
|
||||
Às vezes, podemos querer realmente olhar para as chaves privadas associadas aos nossos endereços Bitcoin. Talvez queremos assinar uma mensagem ou gastar bitcoins em uma máquina diferente. Talvez só estamos querendo fazer backup de algumas chaves privadas importantes. Também pode fazer isso com nosso arquivo criado acima, já que ele pode ser lido por humanos.
|
||||
```
|
||||
@ -123,10 +122,10 @@ Novamente, é esperado que isso exija um node não prunado. Isso provavelmente v
|
||||
|
||||
_Nós digitamos aquele endereço Bitcoin que gerou, enquanto assinávamos uma mensagem e agora estamos fazendo o dump as chaves. Se por acaso achar que isso é muito complicado, os autores e tradutores também concordam com isso. Também estamos sujeitos a erros, um tópico que abordaremos na próxima sessão._
|
||||
|
||||
## Resumo do Configurando nossa carteira
|
||||
## Resumo: Configurando Nossa carteira
|
||||
|
||||
Precisamos criar um endereço para receber fundos. Nosso endereço é armazenado em uma carteira, da qual podemos fazer o backup. Podemos fazer muito coisas com nosso endereço, como fazer o dump da nossa chave privada ou usá-la para assinar mensagens. Mas, realmente, criar esse endereço é _tudo_ que precisaremos fazer para receber alguns satoshinhos.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos dar uma pausa no capítulo "Compreendendo a configuração do node Bitcoin" na sessão [Usando variáveis de linha de comando](03_3__Interlude_Using_Command-Line_Variables.md).
|
||||
Vamos dar uma pausa no capítulo "Compreendendo Nossa Configuração do Bitcoin" com o [Prefácio: Usando Variáveis de Linha de Comando](03_3__Interlude_Using_Command-Line_Variables.md).
|
@ -1,4 +1,4 @@
|
||||
# Usando variáveis de linha de comando
|
||||
# Usando Variáveis de Linha de Comando
|
||||
|
||||
A sessão anterior demonstrou vários comandos de linha de comando usados sem ofuscação ou interferência. No entanto, geralmente essa não é a melhor maneira de executar o Bitcoin usando a linha de comando. Como estamos lidando com variáveis longas, complexas e difíceis de serem lidas, é fácil cometer um erro se estivermos copiando essas variáveis (ou, perder alguns satoshis, se as digitarmos manualmente). Como essas variáveis podem significar a diferença entre receber e perder dinheiro quando usarmos a Mainnet, não _queremos_ cometer erros. Por esses motivos, sugerimos enfaticamente o uso de variáveis de linha de comando para salvar endereços, assinaturas ou outras cadeias de informações longas sempre que isso for razoável.
|
||||
|
||||
@ -31,10 +31,10 @@ O restante deste tutorial usará esse estilo de armazenamento de informações q
|
||||
|
||||
> :book: ***Quando não é prático usar variáveis de linha de comando?*** Variáveis de linha de comando não são práticas se precisarmos usar as informações em algum lugar diferente da linha de comando. Por exemplo, salvar a assinatura pode não ser útil se tivermos que enviá-la a outra pessoa por e-mail. Além disso, alguns comandos futuros produzirão objetos JSON ao invés de informações simples, e as variáveis não podem ser usadas para capturar essas informações, ao menos não sem um _pouco_ mais de mais trabalho.
|
||||
|
||||
## Resumo do Usando variáveis de linha de comando
|
||||
## Resumo: Usando Variáveis de Linha de Comando
|
||||
|
||||
Variáveis de shell podem ser usadas para manter longas strings, minimizando as chances de erros.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Compreendendo a configuração do node Bitcoin" na sessão [3.4: Recebendo uma transação](03_4_Receiving_a_Transaction.md).
|
||||
Vamos continuar "Compreendendo Nossa Configuração do Bitcoin" na sessão [3.4: Recebendo uma Transação](03_4_Receiving_a_Transaction.md).
|
@ -2,7 +2,7 @@
|
||||
|
||||
O ```bitcoin-cli``` oferece três principais maneiras de enviar bitcoins: Utilizando um simples comando; Utilizando uma transação bruta e; Utilizando uma transação bruta com cálculos. Cada uma possui seus prós e contras. Este primeiro método de envio será o mais simples.
|
||||
|
||||
## Definindo Sua Taxa de Transação
|
||||
## Definindo Nossa Taxa de Transação
|
||||
|
||||
Antes de enviar qualquer bitcoin pela rede, devemos pensar sobre as taxas de transação que iremos pagar.
|
||||
|
||||
|
@ -270,4 +270,4 @@ Quando satoshinhos entram na nossa carteira Bitcoin, eles permanecem em quantida
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos fazer uma pausa do "Enviando Transações no Bitcoin" para lermos o [Prefácio: Usando JQ](04_2__Interlude_Using_JQ.md).
|
||||
Vamos fazer uma pausa em "Enviando Transações no Bitcoin" para lermos o [Prefácio: Usando JQ](04_2__Interlude_Using_JQ.md).
|
@ -182,6 +182,6 @@ Para enviar moedas usando transações brutas, precisamos criar uma transação
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Veja uma forma alternativa de inserir comandos no [Prefácio: Usando JQ](04_4__Interlude_Using_Curl.md).
|
||||
Veja uma forma alternativa de inserir comandos no [Prefácio: Usando Curl](04_4__Interlude_Using_Curl.md).
|
||||
|
||||
Ou, se preferir pular o que é francamente uma digressão, podemos aprender mais uma forma de enviar transações no Bitcoin na seção [§4.5 Enviando Moedas com Transações Brutas Automatizadas](04_5_Sending_Coins_with_Automated_Raw_Transactions.md).
|
@ -1,8 +1,8 @@
|
||||
# Capítulo 5: Controlando as transações de Bitcoin
|
||||
# Capítulo 5: Controlando Transações no Bitcoin
|
||||
|
||||
O envio de uma transação nem sempre termina com um "viveram felizes para sempre". Usando os protocolos RBF (Replace-By-Fee, ou Substituindo-A -Taxa no português) e CPFP (Child-Pays-For-Parent, ou Filho-Paga-Pelo-Pai), um desenvolvedor pode continuar a controlar a transação após ela ter sido enviada, para melhorar a eficiência ou para recuperar transações que estava presas na _mempool_. Esses métodos irão começar a mostrar o verdadeiro poder do Bitcoin.
|
||||
|
||||
## Objetivos deste capítulo
|
||||
## Objetivos deste Capítulo
|
||||
|
||||
Depois de trabalhar neste capítulo, um desenvolvedor será capaz de:
|
||||
|
||||
@ -16,8 +16,8 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
* Entender a diferença entre o RBF e o CPFP;
|
||||
* Planejar a taxa do RBF.
|
||||
|
||||
## Tabela de conteúdo
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção 1: Observando as transações presas na mempool](05_1_Watching_for_Stuck_Transactions.md)
|
||||
* [Seção 2: Reenviando uma transação com o RBF](05_2_Resending_a_Transaction_with_RBF.md)
|
||||
* [Seção 3: Financiando uma transação com o CPFP](05_3_Funding_a_Transaction_with_CPFP.md)
|
||||
* [Seção 1: Atentando-se para Transações Presas](05_1_Watching_for_Stuck_Transactions.md)
|
||||
* [Seção 2: Reenviando uma Transação com RBF](05_2_Resending_a_Transaction_with_RBF.md)
|
||||
* [Seção 3: Financiando uma Transação com CPFP](05_3_Funding_a_Transaction_with_CPFP.md)
|
@ -1,8 +1,8 @@
|
||||
# 5.1: Observando as transações presas na mempool
|
||||
# 5.1: Atentando-se para Transações Presas
|
||||
|
||||
Às vezes, uma transação de Bitcoin pode ficar presa. Isso normalmente ocorre porque não havia taxa de transação suficiente, mas também pode ser devido a uma falha da rede ou do software.
|
||||
|
||||
## Observando as transações enviadas
|
||||
## Observando as Transações Enviadas
|
||||
|
||||
Nós devemos _sempre_ observar as transações para garantir que tenham sido encerradas. O ```bitcoin-cli listtransactions``` mostrará todas as nossas transações de entrada e saída, enquanto o ```bitcoin-cli gettransaction``` juntamente com um txid, irá mostrar uma transação específica.
|
||||
|
||||
@ -50,10 +50,10 @@ Se sua transação ficar paralisada por mais tempo do que esperamos, normalmente
|
||||
|
||||
**4. Use o CPFP como sendo o destinatário.** Se nós formos os recebedores do saldo, podemos usar o CPFP (Child-Pays-For-Parent) para usar a transação não confirmada como um input para uma nova transação. Podemos consultar a sessão [§5.3: Financiando uma transação com o CPFP](05_3_Funding_a_Transaction_with_CPFP.md).
|
||||
|
||||
## Resumo do Observando as transações presas na mempool
|
||||
## Resumo: Atentando-se para Transações Presas
|
||||
|
||||
Esta é uma introdução ao poder das transações do Bitcoin. Se sabemos que uma transação está presa, podemos decidir como liberá-la com recursos como o RBF ou o CPFP.
|
||||
|
||||
## O que vem depois?
|
||||
## O Que Vem Depois?
|
||||
|
||||
Continuemos "Controlando as transações de Bitcoin" com a sessão [§5.2: Reenviando uma transação com o RBF](05_2_Resending_a_Transaction_with_RBF.md).
|
||||
Continuemos "Controlando Transações no Bitcoin" com a sessão [§5.2: Reenviando uma Transação com RBF](05_2_Resending_a_Transaction_with_RBF.md).
|
||||
|
@ -1,10 +1,10 @@
|
||||
# 5.2: Reenviando uma transação com o RBF
|
||||
# 5.2: Reenviando uma Transação com RBF
|
||||
|
||||
Se a nossa transação Bitcoin travar e formos a parte que está enviando o saldo, podemos reenviá-la usando o RBF (Replace-By-Fee). No entanto, isso não é tudo que o RBF pode fazer: Geralmente é um recurso poderoso que permite aos remetentes do Bitcoin recriar transações por vários motivos.
|
||||
|
||||
> :warning: **AVISO DE VERSÃO:** Esta é uma inovação do Bitcoin Core v0.12.0, que atingiu a maturidade total na carteira do Bitcoin Core na versão 0.14.0. Obviamente, a maioria das pessoas já deveria estar usando-a.
|
||||
|
||||
## Opt-In para o RBF
|
||||
## Optando pelo RBF
|
||||
|
||||
O RBF é um recurso opcional do Bitcoin. As transações só são elegíveis para usar o RBF se tiverem sido criadas com um sinalizador RBF especial. Isso é feito configurando qualquer um dos números de sequência UTXO da transação (que normalmente são configurados automaticamente), de modo que seja maior que 0 e menor que 0xffffffff-1 (4294967294).
|
||||
|
||||
@ -42,19 +42,19 @@ O sinalizador ```bip125-replaceeable``` permanecerá como ```yes``` até que a t
|
||||
|
||||
> :book: ***Devo confiar nas transações que não possuem confirmações?*** Não, nunca. Isso era uma verdade antes do RBF e continua sendo depois do RBF. As transações devem receber confirmações antes de serem determinadas como confiáveis. Isto é especialmente verdadeiro se uma transação for marcada como ```bip125-replaceable```, porque ela pode muito bem ser... substituída.
|
||||
|
||||
> :information_source: **NOTA - SEQUÊNCIA:** Este é o primeiro uso do valor ```nSequence``` no Bitcoin. Podemos configurá-lo entre 1 e 0xffffffff-2 (4294967293) e habilitar o RBF, mas se não tivermos cuidado, poderemos bater de frente com o uso paralelo do ```nSequence``` que serve para _timelocks_ relativos. Sugerimos sempre configurá-lo como "1", que é o que o Bitcoin Core faz, mas a outra opção é configurá-lo com um valor entre 0xf0000000 (4026531840) e 0xffffffff-2 (4294967293). Configurá-lo como sendo "1" efetivamente torna os bloqueios de tempo relativos irrelevantes e configurá-lo para 0xf0000000 ou superior os desativa. Tudo isso é explicado posteriormente na sessão [§11.3: Usando CSV nos Scripts](11_3_Using_CSV_in_Scripts.md). Por enquanto, basta escolhermos um dos valores não conflitantes para o ```nSequence```.
|
||||
> :information_source: **NOTA - SEQUÊNCIA:** Este é o primeiro uso do valor ```nSequence``` no Bitcoin. Podemos configurá-lo entre 1 e 0xffffffff-2 (4294967293) e habilitar o RBF, mas se não tivermos cuidado, poderemos bater de frente com o uso paralelo do ```nSequence``` que serve para _timelocks_ relativos. Sugerimos sempre configurá-lo como "1", que é o que o Bitcoin Core faz, mas a outra opção é configurá-lo com um valor entre 0xf0000000 (4026531840) e 0xffffffff-2 (4294967293). Configurá-lo como sendo "1" efetivamente torna os bloqueios de tempo relativos irrelevantes e configurá-lo para 0xf0000000 ou superior os desativa. Tudo isso é explicado posteriormente na seção [§11.3: Usando CSV nos Scripts](11_3_Using_CSV_in_Scripts.md). Por enquanto, basta escolhermos um dos valores não conflitantes para o ```nSequence```.
|
||||
|
||||
### Opcional: Sempre habilite o RBF
|
||||
### Opcional: Sempre Habilite o RBF
|
||||
|
||||
Se preferirmos, podemos _sempre_ optar por habilitar o RBF. Podemos fazer isso executando nosso ```bitcoind``` com o comando ``` -walletrbf```. Depois de fazermos isso (e reiniciarmos nosso ```bitcoind```), todos os UTXOs devem ter um número de sequência inferior e as transações posteriores devem ser marcadas como ```bip125-replaceable```.
|
||||
Se preferirmos, podemos optar por _sempre_ habilitar o RBF. Podemos fazer isso executando nosso ```bitcoind``` com o comando ``` -walletrbf```. Depois de fazermos isso (e reiniciarmos nosso ```bitcoind```), todos os UTXOs devem ter um número de sequência inferior e as transações posteriores devem ser marcadas como ```bip125-replaceable```.
|
||||
|
||||
> :warning: **AVISO DE VERSÃO:** O sinalizador walletrbf requer o Bitcoin Core v.0.14.0 ou superior.
|
||||
|
||||
## Entendendo o funcionamento do RBF
|
||||
## Entendendo o Funcionamento do RBF
|
||||
|
||||
A funcionalidade RBF é baseada no [BIP 125](https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki), que lista as seguintes regras para usá-lo:
|
||||
|
||||
> 1. As transações originais sinalizam a possibilidade de serem substituídas de maneira explicita ou por herança, conforme descrito na sessão anterior.
|
||||
> 1. As transações originais sinalizam a possibilidade de serem substituídas de maneira explicita ou por herança, conforme descrito na seção anterior.
|
||||
|
||||
Isso significa que o número de sequência deve ser definido para menos de 0xffffffff-1 (4294967294), ou o mesmo é verdadeiro para transações pai não confirmadas.
|
||||
|
||||
@ -73,7 +73,7 @@ Diante desse conflito, os mineradores saberão usar aquele com a taxa mais alta
|
||||
|
||||
> :warning: **ATENÇÃO:** Algumas discussões anteriores sobre esta política sugeriram que o número ```nSequence``` também fosse aumentado. Na verdade, esse era o uso pretendido do ```nSequence``` em sua forma original. Isso _não_ faz parte da política publicada no BIP 125. Na verdade, aumentar o número da sequência, pode travar acidentalmente nossa transação com um _timelock_ relativo, a menos que usemos números de sequência no intervalo de 0xf0000000 (4026531840) a 0xffffffff-2 (4294967293) .
|
||||
|
||||
## Substituindo uma transação no modo hard: Manualmente
|
||||
## Substituindo uma Transação no Modo Difícil: Manualmente
|
||||
|
||||
Para criar uma transação RBF manual, tudo o que precisamos fazer é criar uma transação bruta que: (1) Substitua uma transação bruta anterior onde o RBF foi habilitado e que não foi confirmada; (2) Reutilizar um ou mais dos mesmos UTXOs; (3) Aumentar as taxas e; (4) Pagar a taxa mínima de ambas as transações [que já podem ser atendidas no item (3)].
|
||||
|
||||
@ -154,7 +154,7 @@ $ bitcoin-cli -named gettransaction txid=5b953a0bdfae0d11d20d195ea43ab7c31a5471d
|
||||
```
|
||||
Nossos destinatários terão nosso saldo, e a transação original que foi falha acabará saindo do mempool.
|
||||
|
||||
## Substituindo uma transação no modo easy: Usando o bumpfee
|
||||
## Substituindo uma Transação no Modo Fácil: Usando o bumpfee
|
||||
|
||||
As transações brutas são muito poderosas e podemos fazer muitas coisas interessantes combinando-as com o RBF. No entanto, às vezes _tudo_ o que desejamos é apenas liberar uma transação que está presa na mempool. Podemos fazer isso com um comando simples, o ```bumpfee```.
|
||||
|
||||
@ -201,7 +201,7 @@ $ bitcoin-cli -named gettransaction txid=75208c5c8cbd83081a0085cd050fc7a4064d87c
|
||||
```
|
||||
> :aviso: **AVISO DE VERSÃO:** O comando ```bumpfee``` no RPC requer o Bitcoin Core v.0.14.0.
|
||||
|
||||
## Resumo do Reenviando uma transação com o RBF
|
||||
## Resumo: Reenviando uma Transação com RBF
|
||||
|
||||
Se uma transação ficar presa na mempool e não quisermos esperar que ela expire, e se habilitamos o RBF nela, podemos fazer um gasto duplo usando o RBF para criar uma transação de substituição (ou apenas usar o comando ```bumpfee```).
|
||||
|
||||
@ -209,6 +209,6 @@ Se uma transação ficar presa na mempool e não quisermos esperar que ela expir
|
||||
|
||||
> Por exemplo, podemos enviar uma transação e, antes de ser confirmada, combiná-la com uma segunda transação. Isso permite que possamos comprimir várias transações em uma única, diminuindo as taxas totais. Também podemos oferecer benefícios à privacidade. Existem outras razões para usarmos o RBF, como por exemplo contratos inteligentes ou transferência de transações, conforme descrito na parte referente a [Perguntas frequentes sobre RBF de opt-in](https://bitcoincore.org/en/faq/optin_rbf/).
|
||||
|
||||
## O que vem depois?
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Controlando as transações de Bitcoin" na sessão [§5.3: Financiando uma transação com o CPFP](05_3_Funding_a_Transaction_with_CPFP.md).
|
||||
Vamos continuar "Controlando Transações no Bitcoin" na seção [§5.3: Financiando uma Transação com CPFP](05_3_Funding_a_Transaction_with_CPFP.md).
|
||||
|
@ -1,10 +1,10 @@
|
||||
# 5.3: Financiando uma transação com o CPFP
|
||||
# 5.3: Financiando uma Transação com CPFP
|
||||
|
||||
Se nossa transação do Bitcoin travar e formos os _recebedores_, poderemos aumentar a velocidade usando o CPFP (Child-Pays-For-Parent). Esta é uma alternativa semelhante ao que a parte que _ envia_ o saldo pode fazer usando o RBF.
|
||||
|
||||
> :warning: **AVISO DE VERSÃO:** Esta é uma inovação do Bitcoin Core v0.13.0, o que novamente significa que a maioria das pessoas já deve estar utilizando-a.
|
||||
|
||||
## Entendendo o funcionamento do CPFP
|
||||
## Entendendo o Funcionamento do CPFP
|
||||
|
||||
O RBF é possível caso você seja a parte que está enviando o saldo. O remetente errou e precisou aumentar a taxa, ou queria ser inteligente e combinar transações por diversos motivos. O RBF é um poderoso recurso voltado para o remetente. De certa forma, o CPFP é o oposto do RBF, pois dá poder ao destinatário que sabe que o dinheiro ainda não chegou e quer acelerar o processo. No entanto, também é um recurso muito mais simples, com aplicabilidade não tão ampla quanto a primeira.
|
||||
|
||||
@ -12,7 +12,7 @@ Basicamente, a ideia do CPFP é que um destinatário tenha uma transação que n
|
||||
|
||||
Devemos observar que o CPFP não é um recurso novo no protocolo, assim como o RBF. É apenas um novo esquema de incentivo que pode ser usado para a seleção de transações pelos mineradores. Isso também significa que não é tão confiável quanto uma alteração feita pelo RBF: Pode haver motivos para que o filho não seja selecionado para ser colocado em um bloco e isso impedirá que o pai também seja colocado no bloco.
|
||||
|
||||
## Gastando UTXOs não confirmados
|
||||
## Gastando UTXOs Não Confirmados
|
||||
|
||||
Financiar uma transação com o CPFP é um processo muito simples, usando os métodos com os quais já estamos familiarizados:
|
||||
|
||||
@ -108,7 +108,7 @@ Nossas transações podem ser processadas rapidamente, ou não. Tudo depende se
|
||||
|
||||
E isso realmente é tudo o que podemos fazer.
|
||||
|
||||
### Atenção aos nuances
|
||||
### Atenção aos Nuances
|
||||
|
||||
Embora o CPFP seja geralmente descrito como sendo um destinatário que usa uma nova transação para pagar por uma antiga que não foi confirmada, existem alguns nuances.
|
||||
|
||||
@ -116,12 +116,12 @@ A parte que está _enviando_ poderia usar o CPFP para liberar uma transação se
|
||||
|
||||
A parte que está _recebendo_ pode usar o CPFP mesmo se não estiver planejando gastar o dinheiro imediatamente, por exemplo, se estiver preocupado que os fundos possam não ser reenviados se a transação expirar. Nesse caso, ele apenas cria uma transação secundária que envia todo o dinheiro (menos a taxa de transação) para um endereço de troco. Isso é o que fizemos no nosso exemplo.
|
||||
|
||||
## Resumo do Financiando uma transação com o CPFP
|
||||
## Resumo: Financiando uma Transação com CPFP
|
||||
|
||||
Podemos aproveitar os incentivos do CPFP para liberar fundos que nos foram enviados, mas que não foram confirmados. Basta usar a transação não confirmada como sendo um UTXO e pagar uma taxa de transação acima da média.
|
||||
|
||||
> :fire: ***Qual é o poder do CPFP?*** O seu uso é apenas para liberar fundos quando formos os recebedores dos fundos e o remetente não quer ajudar por qualquer que seja o motivo. Ele não tem as mesmas habilidades que o RBF, mas é uma maneira alternativa de exercer controle sobre uma transação depois que ela foi colocada na mempool, mas antes de ser confirmada em um bloco.
|
||||
|
||||
## O que vem depois?
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos avançar para o [Capítulo 6: Expandindo as Transações de Bitcoin com Multisigs](06_0_Expanding_Bitcoin_Transactions_Multisigs.md).
|
||||
Vamos avançar para o [Capítulo 6: Expandindo Transações no Bitcoin com Multisigs](06_0_Expanding_Bitcoin_Transactions_Multisigs.md).
|
@ -2,7 +2,7 @@
|
||||
|
||||
Transações básicas no Bitcoin: (1) enviam fundos; (2) para um único destinatário P2PKH ou SegWit; (3) de uma única máquina; (4) imediatamente. No entanto, todas as quatro partes desta definição podem ser expandidas usando transações mais complexas no Bitcoin. Este primeiro capítulo sobre "Expansão" mostra como variar os pontos (2) e (3) enviando saldos para um endereço que representa vários destinatários (ou, pelo menos, vários assinantes).
|
||||
|
||||
## Objetivos deste capítulo
|
||||
## Objetivos deste Capítulo
|
||||
|
||||
Depois de trabalhar neste capítulo, um desenvolvedor será capaz de:
|
||||
* Criar endereços de Bitcoin multi-assinatura (multisig) usando os fundamentos do Bitcoin;
|
||||
@ -16,4 +16,4 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
|
||||
* [Seção 1: Enviando uma Transação com Multsig](06_1_Sending_a_Transaction_to_a_Multisig.md)
|
||||
* [Seção 2: Gastando uma Transação com Multsig](06_2_Spending_a_Transaction_to_a_Multisig.md)
|
||||
* [Seção 3: Enviando e Gastando um Multisig de Maneira Automatizada](06_3_Sending_an_Automated_Multisig.md)
|
||||
* [Seção 3: Enviando & Gastando um Multisig Automatizado](06_3_Sending_an_Automated_Multisig.md)
|
@ -196,7 +196,7 @@ b164388854f9701051809eed166d9f6cedba92327e4296bf8a265a5da94f6521
|
||||
```
|
||||
Como podemos ver, não houve nada de incomum na criação da transação e ela parece normal, embora com um endereço com um prefixo diferente do normal (```2N8MytPW2ih27LctLjn6LfLFZZb1PFSsqBr```). Sem surpresa, como também não vimos diferença quando enviamos para endereços Bech32 pela primeira vez na seção [§4.6](04_6_Creating_a_Segwit_Transaction.md).
|
||||
|
||||
## Resumo: Enviando uma Transação Multisig
|
||||
## Resumo: Enviando uma Transação com Multisig
|
||||
|
||||
Os endereços multisig trancam os fundos usando várias chaves privadas, possivelmente exigindo todas essas chaves privadas para resgate e, possivelmente, exigindo apenas algumas do conjunto. Eles são fáceis de serem criados com o ```bitcoin-cli``` e são simples para serem enviados. Essa facilidade se deve em grande parte ao uso invisível de endereços P2SH (Pay-To-Script-Hash), um tópico extenso que já falamos duas vezes, com endereços P2SH-SegWit e agora com os multisigs, e um outro que receberá mais atenção no futuro.
|
||||
|
||||
|
@ -117,4 +117,4 @@ Existe uma maneira mais fácil de gastar fundos enviados para os nossos endereç
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Saiba mais sobre "Expandindo Transações no Bitcoin com Multisigs" no [Capítulo 7: Expandindo Transações no Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md).
|
||||
Saiba mais sobre "Expandindo Transações no Bitcoin" no [Capítulo 7: Expandindo Transações no Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md).
|
@ -19,6 +19,6 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção Um: Criando uma Transação Bitcoin Parcialmente Assinada](07_1_Creating_a_Partially_Signed_Bitcoin_Transaction.md)
|
||||
* [Seção Dois: Usando uma Transação Bitcoin Parcialmente Assinada](07_2_Using_a_Partially_Signed_Bitcoin_Transaction.md)
|
||||
* [Seção Um: Criando uma Transação Parcialmente Assinada no Bitcoin (PSBT)](07_1_Creating_a_Partially_Signed_Bitcoin_Transaction.md)
|
||||
* [Seção Dois: Usando uma Transação Parcialmente Assinada no Bitcoin (PSBT)](07_2_Using_a_Partially_Signed_Bitcoin_Transaction.md)
|
||||
* [Seção Três: Integrando com Hardware Wallets](07_3_Integrating_with_Hardware_Wallets.md)
|
@ -1,4 +1,4 @@
|
||||
# 7.1: Criando uma Transação Bitcoin Parcialmente Assinada
|
||||
# 7.1: Criando uma Transação Parcialmente Assinada no Bitcoin (PSBT)
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -505,10 +505,10 @@ Finalmente, se precisarmos de mais controle e optarmos por usar o comando ```utx
|
||||
|
||||

|
||||
|
||||
## Resumo: Criando uma Transação Bitcoin Parcialmente Assinada
|
||||
## Resumo: Criando uma Transação Parcialmente Assinada no Bitcoin (PSBT)
|
||||
|
||||
A criação de uma PSBT envolve um fluxo de trabalho um tanto complexo de criação, atualização, assinatura, finalização e extração da PSBT, após o qual ela se converte novamente em uma transação bruta. Por que teríamos tanto trabalho? Porque desejamos colaborar entre vários usuários ou vários programas. Agora que entendemos esse fluxo de trabalho, a próxima seção irá apresentar alguns exemplos reais de como fazer isso.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Expandindo Transações no Bitcoin com PSBTs" na seção [§7.2: Usando uma Transação Bitcoin Parcialmente Assinada](07_2_Using_a_Partially_Signed_Bitcoin_Transaction.md).
|
||||
Vamos continuar "Expandindo Transações no Bitcoin com PSBTs" na seção [§7.2: Usando uma Transação Parcialmente Assinada no Bitcoin (PSBT)](07_2_Using_a_Partially_Signed_Bitcoin_Transaction.md).
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 7.2: Usando uma Transação Bitcoin Parcialmente Assinada
|
||||
# 7.2: Usando uma Transação Parcialmente Assinada no Bitcoin (PSBT)
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -588,7 +588,7 @@ Cada usuário coloca o próprio UTXO e cada um recebe uma saída correspondente.
|
||||
|
||||
A melhor maneira de gerenciar um CoinJoin é enviar a PSBT básica para todas as partes (que podem ser inúmeras) e, em seguida, fazer com que cada uma assine a PSBT e envie de volta para uma única parte que irá combinar, finalizar e enviar.
|
||||
|
||||
## Resumo: Usando uma Transação Bitcoin Parcialmente Assinada
|
||||
## Resumo: Usando uma Transação Parcialmente Assinada no Bitcoin (PSBT)
|
||||
|
||||
Agora vimos o processo PSBT que aprendemos na seção [§7.1](07_1_Creating_a_Partially_Signed_Bitcoin_Transaction.md) em uso em três exemplos da vida real: criando um multisig, um financiamento e fazendo CoinJoin. Tudo isso era teoricamente possível no Bitcoin com várias pessoas assinando transações cuidadosamente construídas, mas as PSBTs tornam isso padronizado e simples.
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
# Capítulo 8: Expandindo Transações de Bitcoin de Outras Maneiras
|
||||
# Capítulo 8: Expandindo Transações no Bitcoin de Outras Maneiras
|
||||
|
||||
A definição de transações básicas descrita no [Capítulo Seis](06_0_Expanding_Bitcoin_Transactions_Multisigs.md) diz que enviamos os _fundos_ _imediatamente_, mas esses são os dois elementos que podem ser alterados. Esta seção final sobre _Expandindo transações de Bitcoin_ fala sobre como enviar coisas que não sejam moedas e como fazer isso em um momento diferente do atual.
|
||||
|
||||
@ -15,7 +15,7 @@ Os objetivos secundários incluem a capacidade de:
|
||||
* Planejar usando o poder do Locktime;
|
||||
* Planejar usando o poder de OP_RETURN.
|
||||
|
||||
## Tabela de conteúdo
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção Um: Enviando uma transação com Locktime](08_1_Sending_a_Transaction_with_a_Locktime.md)
|
||||
* [Seção Dois: Enviando uma transação com dados](08_2_Sending_a_Transaction_with_Data.md)
|
||||
* [Seção Um: Enviando uma Transação com um Locktime](08_1_Sending_a_Transaction_with_a_Locktime.md)
|
||||
* [Seção Dois: Enviando uma Transação com Dados](08_2_Sending_a_Transaction_with_Data.md)
|
@ -1,8 +1,8 @@
|
||||
# 8.1: Enviando uma transação com Locktime
|
||||
# 8.1: Enviando uma Transação com um Locktime
|
||||
|
||||
Os capítulos anteriores mostraram duas maneiras diferentes de enviar fundos de várias máquinas e para vários destinatários. Mas, existem duas outras maneiras de alterar fundamentalmente as transações básicas. A primeira delas é variar o tempo, escolhendo um tempo de bloqueio ou mais conhecido pela expressão em inglês locktime. Isso nos dá a capacidade de enviar transações brutas em algum momento no futuro.
|
||||
|
||||
## Entendendo como o Locktime funciona
|
||||
## Entendendo Como o Locktime Funciona
|
||||
|
||||
Ao criar uma transação do tipo locktime, a bloqueamos com um número que representa a altura do bloco (se for um número pequeno) ou um carimbo de data/hora usando o padrão UNIX (se for um número grande). Isso informa à rede Bitcoin que a transação não pode ser colocada no bloco até que o tempo especificado chegue ou a blockchain tenha atingido a altura especificada.
|
||||
|
||||
@ -16,11 +16,11 @@ Quando uma transação do tipo locktime está esperando para entrar em um bloco,
|
||||
|
||||
> O Bitcoin Script capacita ainda mais os dois tipos de timelocks, permitindo o bloqueio de saídas individuais ao invés de toda a transação. Os timelocks absolutos (como Locktime) estão vinculados ao opcode Script OP_CHECKLOCKTIMEVERIFY, que é definido no [BIP 65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki) e que será estudado na seção [§11.2: Usando CLTV em Scripts](11_2_Using_CLTV_in_Scripts.md), enquanto os timelocks relativos (como o Timelock) estão vinculados ao opcode de Script OP_CHECKSEQUENCEVERIFY, que é definido no [BIP 112](https://github.com/bitcoin/bips /blob/master/bip-0112.mediawiki) e que também será abordado na seção [§11.3](11_3_Using_CSV_in_Scripts.md).
|
||||
|
||||
## Criando uma transação de Locktime
|
||||
## Criando uma Transação com Locktime
|
||||
|
||||
Para criar uma transação com locktime, precisamos primeiro determinar como definiremos o tempo.
|
||||
|
||||
### Descobrindo nosso tempo de bloqueio usando o carimbo de data/hora do UNIX
|
||||
### Descobrindo Nosso Locktime Usando o Carimbo de Data/Hora do UNIX
|
||||
|
||||
Provavelmente, iremos definir com muito mais frequência o nosso tempo de bloqueio usando um carimbo de data/hora do tipo UNIX que representa uma data e hora específica. Podemos calcular um carimbo de data/hora UNIX usando sites que fazem essa conversão, como o [UNIX Time Stamp](http://www.unixtimestamp.com/) ou o [Epoch Convertor](https://www.epochconverter.com/). No entanto, seria melhor [escrevermos nosso próprio script](https://www.epochconverter.com/#code) em nossa máquina local, para que saibamos que o carimbo de data/hora UNIX que recebemos está correto (lembre-se, não confie, verifique). Se não fizermos isso, pelo menos seria interessante verificar em dois sites diferentes para ter a certeza que tudo está correto.
|
||||
|
||||
@ -28,7 +28,7 @@ Provavelmente, iremos definir com muito mais frequência o nosso tempo de bloque
|
||||
|
||||
> :warning: **AVISO:** O Locktime com carimbos de data/hora tem menos flexibilidade, pois a liberação de blocos não é regular e os tempos de bloqueio podem ser duas horas antes do tempo real, então um locktime significa "mais ou menos nesta data e nesta hora".
|
||||
|
||||
### Descobrir o locktime usando a altura do bloco
|
||||
### Descobrindo Nossoo Locktime Usando a Altura do Bloco
|
||||
|
||||
Como alternativa, podemos definir o locktime usando um número menor, que representa a altura de um bloco. Para calcular a altura do bloco futuro, precisamos primeiro saber qual é a altura do bloco atual. O ```bitcoin-cli getblockcount``` nos dirá a altura do bloco atual baseado na blockchain da máquina local. Podemos verificar um explorador do Bitcoin como a [mempool.space](https://mempool.space/).
|
||||
|
||||
@ -38,7 +38,7 @@ Depois de descobrir a altura atual, podemos decidir até que ponto no futuro ire
|
||||
|
||||
> :warning: **AVISO:** Se desejamos definir um locktime usando a altura do bloco, devemos definir o tempo de bloqueio para menos de 500 milhões. Se definirmos como sendo 500 milhões ou mais, nosso número será interpretado como um carimbo de data/hora. Como o carimbo de data/hora usando o padrão UNIX com valor de 500 milhões era dia 5 de novembro de 1985, provavelmente significa que nossa transação será permitida a qualquer momento a entrar na blockchain.
|
||||
|
||||
## Escrevendo a transação
|
||||
## Escrevendo a Transação
|
||||
|
||||
Depois de descobrir o locktime, tudo o que precisamos fazer é escrever uma transação bruta padrão, com uma terceira variável para o ```locktime```:
|
||||
```
|
||||
@ -104,7 +104,7 @@ Observe que o número de sequência (```4294967294```) é menor que ```0xfffffff
|
||||
|
||||
> :warning: **ATENÇÃO:** Se estivermos criando uma transação bruta com locktime por algum outro meio que não seja o ```bitcoin-cli```, teremos que definir a sequência para um valor menor que ```0xffffffff``` manualmente.
|
||||
|
||||
## Enviando a transação
|
||||
## Enviando a Transação
|
||||
|
||||
Agora, já estamos familiarizados com a parte final, que é enviar a transação para a rede:
|
||||
```
|
||||
@ -120,11 +120,11 @@ Desde 2013, geralmente não podemos colocar a transação usando um timelock na
|
||||
|
||||
Assim que o bloqueio de tempo expirar, qualquer pessoa pode enviar a transação assinada para a rede, e o destinatário receberá o saldo como esperado... Desde que a transação não tenha sido cancelada.
|
||||
|
||||
## Cancelando uma transação com timelock
|
||||
## Cancelando uma Transação com Locktime
|
||||
|
||||
Cancelar uma transação de tempo de bloqueio é _muito_ simples: precisamos apenas enviar uma nova transação usando pelo menos um dos UTXOs.
|
||||
|
||||
## Resumo: Enviando uma transação com Locktime
|
||||
## Resumo: Enviando uma Transação com um Locktime
|
||||
|
||||
O Locktime oferece uma maneira de criar uma transação que _precisa_ esperar e que _não será aceita_ até que um determinado bloco chegue ou um momento pré-definido passe. Enquanto isso, ela pode ser cancelada simplesmente reutilizando um dos UTXO da transação.
|
||||
|
||||
@ -132,4 +132,4 @@ O Locktime oferece uma maneira de criar uma transação que _precisa_ esperar e
|
||||
|
||||
## O que vem depois?
|
||||
|
||||
Vamos continuar "Expandindo transações de Bitcoin" na seção [§8.2: Enviando uma transação com dados](08_2_Sending_a_Transaction_with_Data.md).
|
||||
Vamos continuar "Expandindo Transações no Bitcoin" na seção [§8.2: Enviando uma Transação com Dados](08_2_Sending_a_Transaction_with_Data.md).
|
@ -1,10 +1,10 @@
|
||||
# 8.2: Enviando uma transação com dados
|
||||
# 8.2: Enviando uma Transação com Dados
|
||||
|
||||
O último jeito de variar a forma como enviamos uma transação simples é usar a transação para enviar dados ao invés de saldos (ou, na prática, enviar algo além dos saldos). Isso nos dá a capacidade de inserir informações na blockchain. Isso é feito através de um comando especial, o ```OP_RETURN```.
|
||||
|
||||
A pegadinha? Só podemos armazenar 80 bytes por vez!
|
||||
|
||||
## Criando nossos dados
|
||||
## Criando Nossos Dados
|
||||
|
||||
A primeira coisa que precisamos fazer é criar os 80 bytes (ou menos) de dados que iremos gravar no nosso ```OP_RETURN```. Isso pode ser tão simples quanto preparar uma mensagem ou podemos usar o hash dos dados existentes. Por exemplo, o ```sha256sum``` produz 256 bits de dados, que são apenas 32 bytes, bem abaixo do nosso limite:
|
||||
```
|
||||
@ -14,7 +14,7 @@ $ op_return_data="b9f81a8919e5aba39aeb86145c684010e6e559b580a85003ae25d78237a12e
|
||||
```
|
||||
> :book: _O que é um OP_RETURN?_ Todas as transações Bitcoin são construídas com scripts que iremos ver mais a fundo no próximo capítulo. O ```OP_RETURN``` é um script simples que define o OUTPUT como sendo inválido. A convenção resultou no uso dele para incorporar dados na blockchain.
|
||||
|
||||
## Separando algumas moedas
|
||||
## Separando Algumas Moedas
|
||||
|
||||
Nosso objetivo ao criar uma transação de dados não é enviar dinheiro para alguém, mas colocar dados dentro da blockchain. No entanto, _devemos_ gastar algumas moedas para fazer isso. Só precisamos usar um endereço de troco como sendo nosso _ único_ destinatário. Em seguida, podemos identificar um UTXO e enviá-lo para nosso endereço de troco, sem esquecer da taxa de transação, ao mesmo tempo que usamos a mesma transação para criar um OP_RETURN.
|
||||
|
||||
@ -41,7 +41,7 @@ $ utxo_vout=$(bitcoin-cli listunspent | jq -r '.[0] | .vout')
|
||||
$ changeaddress=$(bitcoin-cli getrawchangeaddress)
|
||||
```
|
||||
|
||||
## Escrevendo uma transação bruta
|
||||
## Escrevendo uma Transação Bruta
|
||||
|
||||
Agora podemos escrever uma nova transação bruta com duas saídas: uma é o nosso endereço de alteração para recuperar (a maior parte) do nosso saldo, a outra é um endereço de dados, que é uma variável ```bitcoin-cli``` para um OP_RETURN.
|
||||
```
|
||||
@ -97,18 +97,18 @@ Esta é a cara da transação:
|
||||
```
|
||||
Como podemos observar, ela envia a maior parte do dinheiro de volta para o endereço de troco (`tb1qnx9fkrksw6aaaswc3kj0gademhn4ud3q7cz4fm`) menos a taxa de transação. Mais importante, a primeira saída mostra um OP_RETURN com os dados (`b9f81a8919e5aba39aeb86145c684010e6e559b580a85003ae25d78237a12e75`) logo depois.
|
||||
|
||||
## Enviando uma transação bruta
|
||||
## Enviando uma Transação Bruta
|
||||
|
||||
Assine a transação bruta e envie-a, e logo esse OP_RETURN será incorporado a blockchain!
|
||||
|
||||
## Verificando nosso OP_RETURN
|
||||
## Verificando Nosso OP_RETURN
|
||||
|
||||
Novamente, podemos olhar para essa transação usando um explorador da blockchain:
|
||||
[https://mempool.space/pt/testnet/tx/a600148ac3b05f0c774b8687a71c545077ea5dfb9677e5c6d708215053d892e8/]
|
||||
|
||||
Podemos observar um aviso sobre os dados estarem em um "protocolo desconhecido". Se estivermos projetando algum uso regular dos dados ```OP_RETURN```, provavelmente iremos marcar com um prefixo especial, para marcar esse protocolo. Então, os dados OP_RETURN reais podem ser algo como "CONTRACTS3b110a164aa18d3a5ab064ba93fdce62". Este exemplo não usa um prefixo para evitar qualquer tipo de confusão com os espaços de dados.
|
||||
|
||||
## Resumo: Enviando uma transação com dados
|
||||
## Resumo: Enviando uma Transação com Dados
|
||||
|
||||
Podemos usar o ```OP_RETURN``` para armazenar até 80 bytes de dados na blockchain. Fazemos isso com a palavra-código ```data``` em um ```vout```. Ainda precisaremos enviar alguns satoshinhos, mas basta enviá-lo de volta para um endereço de troco, retirando a taxa de transação.
|
||||
|
||||
@ -116,6 +116,6 @@ Podemos usar o ```OP_RETURN``` para armazenar até 80 bytes de dados na blockcha
|
||||
|
||||
Observe que há alguma controvérsia sobre o uso da blockchain do Bitcoin usando-a para este fim.
|
||||
|
||||
## O que vem depois?
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos conhecer mais sobre o "Script no Bitcoin" no [Capítulo Nove: Apresentando os Scripts no Bitcoin](09_0_Introducing_Bitcoin_Scripts.md).
|
||||
Vamos conhecer mais sobre "Programando no Bitcoin" no [Capítulo Nove: Apresentando os Scripts do Bitcoin](09_0_Introducing_Bitcoin_Scripts.md).
|
@ -1,10 +1,10 @@
|
||||
# Capítulo 9: Apresentando Scripts no Bitcoin
|
||||
# Capítulo 9: Apresentando os Scripts do Bitcoin
|
||||
|
||||
Até o momento, temos interagido 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.
|
||||
|
||||
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 os multisigs e os timelocks fornecerem as bases para os contratos inteligentes, o script do Bitcoin constrói os alicerces. É o próximo passo para capacitar o Bitcoin.
|
||||
|
||||
## Objetivos deste capítulo
|
||||
## Objetivos deste Capítulo
|
||||
|
||||
Depois de trabalhar neste capítulo, um desenvolvedor será capaz de:
|
||||
|
||||
@ -20,8 +20,8 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção Um: Compreendendo o Alicerce das Transações](09_1_PriveStanding_the_foundation_of_transactions.md)
|
||||
* [Seção Dois: Executando um Script no Bitcoin](09_2_running_a_bitcoin_script.md)
|
||||
* [Seção Três: Testando um Script no Bitcoin](09_3_testing_a_bitcoin_script.md)
|
||||
* [Seção Um: Compreendendo a Base das Transações](09_1_PriveStanding_the_foundation_of_transactions.md)
|
||||
* [Seção Dois: Executando um Script do Bitcoin](09_2_running_a_bitcoin_script.md)
|
||||
* [Seção Três: Testando um Script do Bitcoin](09_3_testing_a_bitcoin_script.md)
|
||||
* [Seção Quatro: Programando um P2PKH](09_4_scripting_a_p2pkh.md)
|
||||
* [Seção Cinco: Programando um P2WPKH](09_5_scripting_a_p2wpkh.md)
|
@ -1,4 +1,4 @@
|
||||
# 9.1: Compreendendo a Base de Transações
|
||||
# 9.1: Compreendendo a Base das Transações
|
||||
|
||||
A base do Bitcoin é a capacidade de proteger transações, algo que é feito com uma linguagem de programação simples.
|
||||
|
||||
@ -131,9 +131,9 @@ Vamos comparar isso com o ```ScriptPubkey``` da nossa nova transação P2PKH:
|
||||
|
||||
Essas duas transações são _definitivamente_ trancadas de maneiras diferentes. O Bitcoin reconhece a primeira como sendo ```scripthash``` (P2SH) e a segunda 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``` versus ```OP_DUP OP_HASH160 06b5c6ba5330cdf738a2ce91152bfd0e71f9ec39 Op_equalverify op_checksig```. Este é o poder da programação: conseguimos, de maneira bem simples, produzir alguns dos tipos drasticamente diferentes de transações que aprendemos nos capítulos anteriores.
|
||||
|
||||
## Resumo: Compreendendo a Base de Transações
|
||||
## Resumo: Compreendendo a Base das Transações
|
||||
|
||||
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 Bitcoin Script, uma linguagem semelhante à linguagem de programação Forth que fortalece ainda mais o Bitcoin.
|
||||
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 Bitcoin Script, uma linguagem semelhante à linguagem de programação Forth que fortalece ainda mais o Bitcoin.
|
||||
|
||||
> :fire: ***Qual é o poder dos scripts?*** Os scripts desbloqueiam 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 eles 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 mais complexos no Bitcoin, como a Lightning e sidechains.
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 9.2: Executando um Script no Bitcoin
|
||||
# 9.2: Executando um Script do 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 (_stack_).
|
||||
|
||||
@ -116,7 +116,7 @@ O Bitcoin irá verificar uma transação e permitir que o UTXO possa ser gasto n
|
||||
|
||||
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 no Bitcoin
|
||||
## Resumo: Executando um Script do Bitcoin
|
||||
|
||||
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.
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 9.3: Testando um Script no Bitcoin
|
||||
# 9.3: Testando um Script do Bitcoin
|
||||
|
||||
Programar no Bitcoin nos permite um controle adicional considerável sobre as transações no Bitcoin, mas também é um tanto quanto perigoso. Como descreveremos na seção [§10.1](10_1_Understanding_the_Foundation_of_P2SH.md), os scripts reais são um tanto isolados da rede Bitcoin, o que significa que é possível escrever um script e a rede aceitá-lo, mesmo que seja impossível resgatar daquele script! Portanto, precisamos testar exaustivamente nossos scripts antes de colocarmos nosso dinheiro neles.
|
||||
|
||||
@ -46,7 +46,7 @@ O ```btcdeb``` funciona como um depurador padrão. Ele pega um script (bem como
|
||||
|
||||
Se ao invés disso nós quisermos inicializá-lo sem argumentos, iremos obter simplesmente um interpretador onde podemos emitir comandos ```exec [opcode]``` para realizar ações diretas.
|
||||
|
||||
### Usando o btcdeb para um Exemplo de Adição
|
||||
### Usando o btcdeb com um Exemplo de Adição
|
||||
|
||||
O exemplo a seguir mostra o uso do ```btcdeb``` usando como exemplo a adição da seção anterior, ```1 2 OP_ADD```
|
||||
```
|
||||
@ -200,7 +200,7 @@ E como podemos faz isso? Acontece que esse é o tópico do [capítulo 10](10_0_E
|
||||
|
||||
_Quaisquer que sejam_ os outros métodos de teste que usamos, testar um script na Testnet deve ser nosso teste final _antes_ de colocar nosso script em Mainnet. Não podemos confiar que nosso código está correto. Não podemos fazer isso apenas olhando para ele. Nem mesmo podemos confiar em quaisquer simuladores ou depuradores que estivermos utilizando. Fazer isso é outra ótima maneira de perder seu saldo no Bitcoin.
|
||||
|
||||
## Resumo: Testando um Script no Bitcoin
|
||||
## Resumo: Testando um Script do Bitcoin
|
||||
|
||||
Você deve instalar o ```btcdeb``` como uma ferramenta de linha de comando para testar os scripts do Bitcoin. No momento em que este livro foi escrito, produzimos resultados precisos que podem percorrer todo o processo do script. Também podemos procurar em alguns sites online uma representação mais visual. Quando estivermos com tudo pronto, vamos precisar usar a testnet para ter certeza de que as coisas estão funcionando com precisão, antes de implantarmos na Mainnet.
|
||||
|
||||
|
@ -350,7 +350,7 @@ Infelizmente, esta verificação pode ou não estar funcionando no momento do te
|
||||
|
||||
Como mostramos, um P2PKH é bastante simples. Nossa proteção vem através da força de sua criptografia.
|
||||
|
||||
### Como Procurar uma Pub Key e uma Assinatura Manualmente
|
||||
### Como Procurar uma PubKey e uma Assinatura Manualmente
|
||||
|
||||
E se quiséssemos gerar a ```<signature>``` e a ```<PubKey>```, informações necessárias para desbloquear um UTXO, sem usar o ```bitcoin-cli``` para criar uma transação?
|
||||
|
||||
@ -386,4 +386,4 @@ Enviar para um endereço P2PKH foi relativamente fácil quando estávamos usando
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Apresentando Scripts no Bitcoin" na seção [§9.4: Programando um P2WPKH](09_4_Scripting_a_P2WPKH.md).
|
||||
Vamos continuar "Apresentando Scripts no Bitcoin" na seção [§9.5: Programando um P2WPKH](09_5_Scripting_a_P2WPKH.md).
|
@ -1,4 +1,4 @@
|
||||
# 9.5: Criando um script P2WPKH
|
||||
# 9.5: Programando um P2WPKH
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. Cautela, leitor.
|
||||
|
||||
@ -106,7 +106,7 @@ Uma máquina que entende como o SegWit funciona faz exatamente as mesmas coisas
|
||||
|
||||
Portanto, é outra maneira de fazer a mesma coisa, mas sem ter os scripts embutidos nas transações. Ao invés disso, o processo é integrado ao software do node.
|
||||
|
||||
## Resumo: Criando um script P2WPKH
|
||||
## Resumo: Programando um P2WPKH
|
||||
|
||||
Em grande parte, _não_ programamos um P2WPKH. Ao invés disso, o Bitcoin Core cria a transação de uma maneira diferente, colocando as informações da testemunha em um lugar diferente ao invés de um ```scriptSig``` tradicional. Isso significa que os P2WPKHs são uma digressão dos scripts de Bitcoin desta parte do livro, porque são uma expansão do Bitcoin que se distancia dos scripts tradicionais.
|
||||
|
||||
|
@ -16,11 +16,11 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
* Compreender as várias variações dos scripts Segwit;
|
||||
* Entender como gastar fundos enviados a um P2SH.
|
||||
|
||||
## Tabela de conteúdo
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção 1: Compreendendo a Base do P2SH](10_1_Understanding_the_Foundation_of_P2SH.md)
|
||||
* [Seção 2: Construindo a Estrutura do P2SH](10_2_Building_the_Structure_of_P2SH.md)
|
||||
* [Seção 3: Executando um Script Bitcoin com P2SH](10_3_Running_a_Bitcoin_Script_with_P2SH.md)
|
||||
* [Seção 3: Executando um Script do Bitcoin com P2SH](10_3_Running_a_Bitcoin_Script_with_P2SH.md)
|
||||
* [Seção 4: Programando um Multisig](10_4_Scripting_a_Multisig.md)
|
||||
* [Seção 5: Programando um Script Segwit](10_5_Scripting_a_Segwit_Script.md)
|
||||
* [Seção 6: Gastando uma Transação P2SH](10_6_Spending_a_P2SH_Transaction.md)
|
@ -1,4 +1,4 @@
|
||||
# 10.1: Compreendendo a Fundação do P2SH
|
||||
# 10.1: Compreendendo a Base do P2SH
|
||||
|
||||
Sabemos que os scripts do Bitcoin podem ser usados para controlar o resgate dos UTXOs. A próxima etapa é criar os nossos próprios scripts... mas isso requer uma técnica muito específica.
|
||||
|
||||
@ -89,7 +89,7 @@ Considerando que não podemos criar facilmente uma transação P2SH sem uma API,
|
||||
|
||||
> :warning: **AVISO:** Podemos criar uma transação perfeitamente válida com um redeemScript com o hash correto, mas se o redeemScript não funcionar, ou não funcionar corretamente, os fundos serão perdidos para sempre. É por isso que é importantíssimo testar os scripts, conforme discutido na seção [§9.3: Testando um Script no Bitcoin](09_3_Testing_a_Bitcoin_Script.md).
|
||||
|
||||
## Resumo: Compreendendo a Fundação do P2SH
|
||||
## Resumo: Compreendendo a Base do P2SH
|
||||
|
||||
Scripts arbitrários não são o padrão no Bitcoin. No entanto, podemos incorporá-los em transações padrão usando o tipo de endereço P2SH. Precisamos apenas fazer um hash do nosso script como parte do script de bloqueio, então o revelamos e executamos como parte do script de desbloqueio. Contanto que também possamos satisfazer o ```redeemScript```, o UTXO poderá ser gasto.
|
||||
|
||||
|
@ -173,7 +173,7 @@ Dependendo de nossa API, podemos inserir isso como um ```scriptPubKey``` no esti
|
||||
|
||||
Podemos observar que o ```hex scriptPubKey``` para a transação P2SH Script irá _sempre_ começar com um ```a914```, que é o ```OP_HASH160``` seguido por um ```OP_PUSHDATA``` de 20 bytes (hex: ```0x14```); e _sempre_ terminará com um ```87```, que é um ```OP_EQUAL```. Portanto, tudo o que precisamos fazer é colocar o script de resgate em hash entre esses números.
|
||||
|
||||
## Resumo: Construindo a Estrutura de P2SH
|
||||
## Resumo: Construindo a Estrutura do P2SH
|
||||
|
||||
Na verdade, a criação do script de bloqueio P2SH entra ainda mais nas entranhas do Bitcoin. Embora seja útil saber como tudo isso funciona em um nível muito baixo, é mais provável que tenhamos uma API cuidando de todo o trabalho pesado para nós. Nossa tarefa será simplesmente criar o Script Bitcoin para fazer o bloqueio... que é o tópico principal dos capítulos 9, 11 e 12.
|
||||
|
||||
|
@ -2,7 +2,7 @@
|
||||
|
||||
Agora que conhecemos a teoria e a prática por trás dos endereços P2SH, estamos prontos para transformar um script de Bitcoin não-padrão em uma transação real. Vamos utilizar o script de bloqueio simples da seção [§9.2: Executando um Script no Bitcoin](09_2_Running_a_Bitcoin_Script.md), `OP_ADD 99 OP_EQUAL`.
|
||||
|
||||
## Criando uma transação P2SH
|
||||
## Criando uma Transação P2SH
|
||||
|
||||
Para bloquear uma transação com este script, precisamos fazer o seguinte:
|
||||
|
||||
|
@ -100,7 +100,7 @@ Geralmente, esses eram problemas com qualquer tipo de script complexo do Bitcoin
|
||||
|
||||
Os Multisigs P2SH são a metodologia moderna para a criação de multisigs na Blockchain. Elas podem ser criadas de forma muito simples, usando o mesmo processo visto nas seções anteriores.
|
||||
|
||||
### Criando o Bloqueio para o Multisig P2SH
|
||||
### Criando um Bloqueio para o Multisig P2SH
|
||||
|
||||
Para criar um multisig P2SH, siga as etapas padrão para criar um script de bloqueio P2SH:
|
||||
|
||||
|
@ -1,9 +1,9 @@
|
||||
|
||||
# Capítulo 11: Expandindo o timelock com scripts do Bitcoin
|
||||
# Capítulo 11: Capacitando Timelock com Scripts do Bitcoin
|
||||
|
||||
O recurso ```nLockTime``` da seção [§8.1](08_1_Sending_a_Transaction_with_a_Locktime.md) foi apenas o começo dos Timelocks. Quando começamos a escrever scripts do Bitcoin, dois opcodes de timelocks ficam disponíveis.
|
||||
|
||||
## Objetivos deste capítulo
|
||||
## Objetivos deste Capítulo
|
||||
|
||||
Depois de trabalhar neste capítulo, um desenvolvedor será capaz de:
|
||||
|
||||
@ -18,6 +18,6 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
|
||||
## Índice
|
||||
|
||||
* [Seção 1: Compreendendo as Opções de Timelocks](11_1_Understanding_Timelock_Options.md)
|
||||
* [Seção 2: Usando o CLTV nos Scripts](11_2_Using_CLTV_in_Scripts.md)
|
||||
* [Seção 3: Usando o CSV nos Scripts](11_3_Using_CSV_in_Scripts.md)
|
||||
* [Seção 1: Compreendendo As Opções de Timelock](11_1_Understanding_Timelock_Options.md)
|
||||
* [Seção 2: Usando CLTV em Scripts](11_2_Using_CLTV_in_Scripts.md)
|
||||
* [Seção 3: Usando CSV em Scripts](11_3_Using_CSV_in_Scripts.md)
|
@ -1,8 +1,8 @@
|
||||
# 11.1: Compreendendo as Opções de Timelocks
|
||||
# 11.1: Compreendendo As Opções de Timelock
|
||||
|
||||
Na seção [§8.1: Enviando uma transação com Locktime](08_1_Sending_a_Transaction_with_a_Locktime.md), o ```nLocktime``` ofereceu uma ótima opção inicial para bloquear as transações para que não pudessem ser gastas até algum ponto no futuro, com base no tempo (data/hora) ou na altura do bloco. Mas, essa não é a única maneira de colocar um timelock em uma transação.
|
||||
|
||||
## Compreendendo as limitações do nLockTime
|
||||
## Compreendendo as Limitações do nLockTime
|
||||
|
||||
O ```nLockTime``` é uma maneira simples e poderosa de bloquear uma transação, mas possui algumas limitações:
|
||||
|
||||
@ -13,7 +13,7 @@ O ```nLockTime``` é uma maneira simples e poderosa de bloquear uma transação,
|
||||
|
||||
O último item costumava ser o _dealbreaker_ para o ```nLockTime```. Isso evitou que uma transação fosse gasta, mas não impediu que os fundos fossem usados em uma transação diferente. Então, havia certos usos, mas todos dependiam de confiança.
|
||||
|
||||
## Compreendendo as possibilidades dos scripts de Timelock
|
||||
## Compreendendo as Possibilidades dos Scripts de Timelock
|
||||
|
||||
Nos últimos anos, o Bitcoin Core foi expandido para permitir a manipulação dos timelocks no nível do opcode com os _OP_CHECKLOCKTIMEVERIFY_ (CLTV) e _OP_CHECKSEQUENCEVERIFY_ (CSV). Ambos trabalham sob uma nova metodologia que fortalece ainda mais o Bitcoin.
|
||||
|
||||
@ -23,19 +23,19 @@ _Eles bloqueiam as saídas._ Por serem opcodes incluídos nas transações como
|
||||
|
||||
Aqui está um ponto importante sobre a utilização dos timelocks: _Eles são bloqueios de mão única._ Os bloqueios de tempo são projetados para desbloquear fundos em um determinado momento. Eles não podem bloquear novamente um fundo: Uma vez que um fundo bloqueado por tempo está disponível, ele ficará disponível para ser gasto.
|
||||
|
||||
### Compreendendo as possibilidades do CLTV
|
||||
### Compreendendo as Possibilidades do CLTV
|
||||
|
||||
O _OP_CHECKLOCKTIMEVERIFY_ ou CLTV é compativel com o clássico recurso ```nLockTime```, mas no novo paradigma baseado em opcode. Ele permite que uma UTXO se torne acessível em um determinado momento ou em uma determinada altura de bloco.
|
||||
|
||||
O CLTV foi detalhado pela primeira vez no [BIP 65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki).
|
||||
|
||||
### Compreendendo as possibilidades do CSV
|
||||
### Compreendendo as Possibilidades do CSV
|
||||
|
||||
O _OP_CHECKSEQUENCEVERIFY_ ou CSV depende de um novo tipo de "locktime relativo", que é definido no campo _nSequence_ da transação. Como de costume, ele pode ser definido como uma data/hora ou uma altura de bloco. Se for definido como um tempo "n", então uma transação bloqueada em um tempo relativo pode ser gasta "n x 512" segundos depois que a UTXO foi minerada, e se for definido como um bloco "n", então uma transação bloqueada em tempo relativo pode ser gasta em "n" blocos depois que a UTXO foi minerada.
|
||||
|
||||
O uso do ```nSequence``` para um bloqueio de tempo relativo foi detalhado primeiramente no [BIP 68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki), e o opcode CSV foi adicionado no [BIP 112](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki).
|
||||
|
||||
## Resumo: Compreendendo as Opções de Timelocks
|
||||
## Resumo: Compreendendo As Opções de Timelock
|
||||
|
||||
Agora possuímos quatro opções de Timelocks:
|
||||
|
||||
@ -46,4 +46,4 @@ Agora possuímos quatro opções de Timelocks:
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Aumentando o poder do timelock com scripts do Bitcoin" na seção [§11.2: Usando o CLTV nos Scripts](11_2_Using_CLTV_in_Scripts.md).
|
||||
Vamos continuar "Aumentando o poder do timelock com scripts do Bitcoin" na seção [§11.2: Usando CLTV em Scripts](11_2_Using_CLTV_in_Scripts.md).
|
@ -1,4 +1,4 @@
|
||||
# 11.2: Usando o CLTV nos Scripts
|
||||
# 11.2: Usando CLTV em Scripts
|
||||
|
||||
O ```OP_CHECKLOCKTIMEVERIFY``` (ou CLTV) é o complemento natural para o ```nLockTime```. Ele muda a ideia de bloquear transações por um tempo absoluto ou altura de bloco para o âmbito dos opcodes, permitindo o bloqueio das UTXOs individuais.
|
||||
|
||||
@ -21,7 +21,7 @@ O ```OP_CHECKLOCKTIMEVERIFY``` funciona dentro do mesmo paradigma de altura de b
|
||||
|
||||
Como o CLTV é apenas parte de um script (e presumivelmente parte de uma transação P2SH), uma transação CLTV não é mantida fora da mempool como uma transação ```nLockTime```. Logo, assim que for verificado, ele vai para a blockchain e os fundos são considerados gastos. O truque é que todas as saídas que foram bloqueadas com o CLTV não estão disponíveis para _serem gastas_ até que o CLTV permita.
|
||||
|
||||
### Compreendendo um CLTV de tempo absoluto
|
||||
### Compreendendo um CLTV de Tempo Absoluto
|
||||
|
||||
É assim que o ```OP_CHECKLOCKTIMEVERIFY``` seria utilizado para verificar o locktime de 24 de maio de 2017:
|
||||
```
|
||||
@ -36,7 +36,7 @@ Ou assim:
|
||||
<AbsoluteTime> OP_CHECKLOCKTIMEVERIFY
|
||||
```
|
||||
|
||||
### Compreendendo um CLTV de altura de bloco absoluta
|
||||
### Compreendendo um CLTV de Altura de Bloco Absoluta
|
||||
|
||||
É assim que o ```OPCHECKLOCKTIMEVERIFY``` compararia a uma altura de bloqueio alcançada no dia 24 de maio de 2017:
|
||||
```
|
||||
@ -47,7 +47,7 @@ Mas geralmente vamos abstrair assim:
|
||||
<AbsoluteBlockHeight> OP_CHECKLOCKTIMEVERIFY
|
||||
```
|
||||
|
||||
### Entendendo como o CLTV realmente funciona
|
||||
### Entendendo como o CLTV Realmente Funciona
|
||||
|
||||
A explicação acima é suficiente para usar e entender o CLTV. No entanto, o [BIP 65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki) apresenta todos os seguintes detalhes.
|
||||
|
||||
@ -71,7 +71,7 @@ O seguinte script de bloqueio simples pode ser usado para transformar uma saída
|
||||
<NextYear> OP_CHECKLOCKTIMEVERIFY OP_DROP OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
|
||||
```
|
||||
|
||||
### Codificando um script CLTV
|
||||
### Codificando um Script CLTV
|
||||
|
||||
Obviamente, como acontece com quaisquer scripts Bitcoin complexos, este script CLTV seria realmente codificado em um script P2SH, conforme explicado na seção [§10.1: Entendendo a Fundação do P2SH](10_1_Understanding_the_Foundation_of_P2SH.md) e na [§10.2: Construindo a Estrutura de P2SH](10_2_Building_the_Structure_of_P2SH.md).
|
||||
|
||||
@ -116,7 +116,7 @@ No caso do exemplo acima, o script de desbloqueio abaixo seria suficiente, desde
|
||||
<signature> <pubKey>
|
||||
```
|
||||
|
||||
### Executando um script CLTV
|
||||
### Executando um Script CLTV
|
||||
|
||||
Para executar o Script, primeiro devemos concatenar os scripts de desbloqueio e bloqueio:
|
||||
```
|
||||
@ -142,7 +142,7 @@ Stack: [ <signature> <pubKey> ]
|
||||
```
|
||||
Finalmente, o restante do script é executado, que é uma verificação normal de uma assinatura e chave pública.
|
||||
|
||||
## Resumo: Usando o CLTV nos Scripts
|
||||
## Resumo: Usando CLTV em Scripts
|
||||
|
||||
O ```OP-CHECKLOCKTIMEVERIFY``` é um opcode simples que olha para um único argumento, o interpreta como uma altura de bloco ou timestamp UNIX, e só permite que a UTXO seja desbloqueada se àquela altura de bloco ou timestamp UNIX estiver no passado. Definir o ```nLockTime``` na transação de gastos é o que permite ao Bitcoin fazer este cálculo.
|
||||
|
||||
@ -150,4 +150,4 @@ O ```OP-CHECKLOCKTIMEVERIFY``` é um opcode simples que olha para um único argu
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Aumentando o poder do timelock com scripts do Bitcoin" na seção [§11.3: Usando o CSV nos Scripts](11_3_Using_CSV_in_Scripts.md).
|
||||
Vamos continuar "Capacitando Timelock com Scripts no Bitcoin" na seção [§11.3: Usando CSV em Scripts](11_3_Using_CSV_in_Scripts.md).
|
@ -1,4 +1,4 @@
|
||||
# 11.3: Usando o CSV nos Scripts
|
||||
# 11.3: Usando CSV em Scripts
|
||||
|
||||
O ```nLockTime``` e o ```OP_CHECKLOCKTIMEVERIFY``` (ou CLTV) são apenas um lado da equação do timelock. Do outro lado estão o ```nSequence``` e o ```OP_CHECKSEQUENCEVERIFY```, que podem ser usados para verificar tempos relativos ao invés de tempos absolutos.
|
||||
|
||||
@ -55,7 +55,7 @@ $ echo $relativevalue
|
||||
```
|
||||
Se convertermos de volta, teremos o valor de 4224679 = 10000000111011010100111. O 23º dígito é definido como "1", enquanto os primeiros 2 bytes, 0111011010100111, são convertidos em 76A7 em hexadecimal ou 30375 em decimal. Multiplicando isso por 512, teremos 15,55 milhões de segundos, o que de fato é 180 dias.
|
||||
|
||||
## Criando uma transação com um timelock relativo
|
||||
## Criando uma Transação com um Timelock Relativo
|
||||
|
||||
Então desejamos criar uma transação simples com um timelock relativo? Tudo que precisamos fazer é emitir uma transação onde o ```nSequence``` de uma entrada é definido como mostramos acima: Com o ```nSequence``` para essa entrada definido de forma que os primeiros dois bytes definam o timelock, o 23º bit define o tipo do timelock, e o 32º bit é definido como sendo falso.
|
||||
|
||||
@ -87,7 +87,7 @@ Neste caso, usaremos uma abreviatura:
|
||||
|
||||
> :warning: **ATENÇÃO:** Lembre-se de que um timelock relativo é um intervalo de tempo desde a mineração da UTXO usada como uma entrada. _Não_ é um intervalo de tempo após a criação da transação. Se usarmos uma UTXO que já foi confirmada cem vezes, e colocarmos um timelock relativo de 100 blocos nela, ela será elegível para mineração imediatamente. Os timelocks relativos têm alguns usos muito específicos, mas provavelmente não se aplicam se nosso único objetivo for determinar algum tempo definido no futuro.
|
||||
|
||||
### Entendendo como o CSV realmente funciona
|
||||
### Entendendo como o CSV Realmente Funciona
|
||||
|
||||
O CSV tem muitas das mesmas sutilezas de uso que CLTV:
|
||||
|
||||
@ -99,7 +99,7 @@ O CSV tem muitas das mesmas sutilezas de uso que CLTV:
|
||||
|
||||
Assim como no CLTV, quando estiver usando uma UTXO com um CSV em condições de bloqueio, devemos definir o ```nSequence``` para habilitar a transação. Normalmente, o configuraremos com o valor exato no script de bloqueio.
|
||||
|
||||
## Escrevendo um script CSV
|
||||
## Escrevendo um Script CSV
|
||||
|
||||
Assim como o ```OP_CHECKLOCKTIMEVERIFY```, o ```OP_CHECKSEQUENCEVERIFY``` inclui um ```OP_VERIFY``` implícito e deixa os argumentos na pilha, exigindo um ```OP_DROP``` quando finalizar tudo.
|
||||
|
||||
@ -108,7 +108,7 @@ Um script que bloquearia fundos por até seis meses após a mineração e que ex
|
||||
<+6Months> OP_CHECKSEQUENCEVERIFY OP_DROP OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
|
||||
```
|
||||
|
||||
### Codificando um script CSV
|
||||
### Codificando um Script CSV
|
||||
|
||||
Ao codificar um script CSV, precisamos tomar cuidado ao codificar o valor inteiro para o timelock relativo. Deve ser passado como um número inteiro de 3 bytes, o que significa que iremos ignorar o maior byte, o que pode desativar o timelock relativo. Como é um número inteiro, precisamos nos certificar de convertê-lo para little-endian.
|
||||
|
||||
@ -137,7 +137,7 @@ Hexcode: 03a77640
|
||||
|
||||
Para gastar uma UTXO bloqueado com um script CSV, devemos definir o ```nSequence``` dessa entrada para um valor maior que o requerido no script, mas menor que o tempo entre a UTXO e o bloco atual. Isso mesmo, isso significa que precisamos saber o requisito exato no script de bloqueio. Mas temos uma cópia do ```redeemScript```, então se não conhecermos os requisitos, podemos desserializá-lo e, em seguida, definir o ```nSequence``` como sendo o número que é mostrado lá.
|
||||
|
||||
## Resumo: Usando o CSV nos Scripts
|
||||
## Resumo: Usando CSV em Scripts
|
||||
|
||||
O ```nSequence``` e o CSV oferecem uma alternativa para o ```nLockTime``` e o CLTV onde bloqueamos uma transação com base em um tempo relativo desde que a entrada foi extraída, ao invés de basear o bloqueio em um tempo definido no futuro. Eles funcionam quase de forma idêntica, exceto pelo fato de que o valor do ```nSequence``` é codificado de forma ligeiramente diferente do valor do ```nLockTime```, com bits específicos significando coisas específicas.
|
||||
|
||||
@ -145,4 +145,4 @@ O ```nSequence``` e o CSV oferecem uma alternativa para o ```nLockTime``` e o CL
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos avançar "Criando Scripts do Bitcoin" no capítulo [12: Expandindo os Scripts do Bitcoin](12_0_Expanding_Bitcoin_Scripts.md).
|
||||
Vamos avançar em "Programando no Bitcoin" com o [Capítulo 12: Expandindo os Scripts do Bitcoin](12_0_Expanding_Bitcoin_Scripts.md).
|
@ -1,4 +1,4 @@
|
||||
# 13.1: Escrevendo Scripts de Quebra-Cabeça
|
||||
# 13.1: Escrevendo Scripts de Quebra-Cabeças
|
||||
|
||||
Os scripts de Bitcoin realmente _não_ precisam depender do conhecimento de uma chave secreta. Ao invés disso, eles podem ser quebra-cabeças de qualquer tipo.
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 13.2: Escrevendo Scripts Multisig Complexos
|
||||
# 13.2: Escrevendo Scripts Complexos de Multisig
|
||||
|
||||
Até o momento, os multisigs descritos nesses documentos têm sido inteiramente simples, na forma m-de-n ou n-de-n. No entanto, podemos desejar multisigs mais complexos, onde as pessoas que assinam as transações variam ou onde diferentes opções podem se tornar disponíveis ao longo do tempo.
|
||||
|
||||
@ -140,7 +140,7 @@ Observe que este script requer que um ```True``` ou ```False``` seja passado par
|
||||
|
||||
No início, o seguinte ```sigScript``` seria permitido: ```0 <signer1> <signer2> True```. Após 30 dias, Alice poderia produzir um ```sigScript``` como este: ```<sigA> False```.
|
||||
|
||||
## Resumo: Escrevendo Scripts Multisig Complexos
|
||||
## Resumo: Escrevendo Scripts Complexos de Multisig
|
||||
|
||||
Os multisigs mais complexos podem ser normalmente criados combinando assinaturas ou multi-assinaturas com condicionais e testes. Os multisigs resultantes podem ser variáveis, exigindo diferentes números de assinantes com base em quem são e quando estão assinando.
|
||||
|
||||
|
@ -271,6 +271,6 @@ Vamos ficar "Usando o Tor" no [Capítulo Quatorze: Usando o Tor](14_0_Using_Tor.
|
||||
|
||||
Ou, se preferir, existem dois caminhos alternativos:
|
||||
|
||||
Se quiser manter o foco no Bitcoin, siga em frente para "Programando com o RPC" no [Capítulo Quinze: Conversando com Bitcoind usando C](15_0_Talking_to_Bitcoind.md).
|
||||
Se quiser manter o foco no Bitcoin, siga em frente para "Programando com RPC" no [Capítulo Dezesseis: Conversando com Bitcoind com C](16_0_Talking_to_Bitcoind.md).
|
||||
|
||||
Ou, se quiser manter o foco na linha de comando porque não é um programador, pode pular para o [Capítulo Dezoito: Entendendo Nossa Configuração da Lightning](18_0_Understanding_Your_Lightning_Setup.md) para continuar seus estudos da linha de comando com a Lightning Network.
|
||||
Ou, se quiser manter o foco na linha de comando porque não é um programador, pode pular para o [Capítulo Dezenove: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md) para continuar seus estudos da linha de comando com a Lightning Network.
|
@ -16,6 +16,6 @@ Os objetivos secundários incluem a capacidade de:
|
||||
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção 1: Verificando a Sua Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md)
|
||||
* [Seção 2: Mudando os Seus Serviços Ocultos do Bitcoin](14_2_Changing_Your_Bitcoin_Hidden_Services.md)
|
||||
* [Seção 3: Adicionando um Serviço SSH Oculto](14_3_Adding_SSH_Hidden_Services.md)
|
||||
* [Seção 1: Verificando Nossa Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md)
|
||||
* [Seção 2: Mudando Nossos Serviços Ocultos do Bitcoin](14_2_Changing_Your_Bitcoin_Hidden_Services.md)
|
||||
* [Seção 3: Adicionando Serviços SSH Ocultos](14_3_Adding_SSH_Hidden_Services.md)
|
@ -1,4 +1,4 @@
|
||||
# 14.1: Verificando a Configuração do Tor
|
||||
# 14.1: Verificando Nossa Configuração do Tor
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
|
@ -1,10 +1,10 @@
|
||||
# 14.3: Adicionando um Serviço SSH Oculto
|
||||
# 14.3: Adicionando Serviços SSH Ocultos
|
||||
|
||||
>:information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
Até agora, usamos o Tor com os nossos serviços Bitcoin, mas também podemos usá-lo para proteger outros serviços em nossa máquina, melhorando a segurança e a privacidade. Esta seção demonstra como fazer isso, introduzindo um serviço ```ssh``` oculto para fazer o login remotamente usando o Tor.
|
||||
|
||||
## Criando serviços SSH ocultos
|
||||
## Criando Serviços SSH Ocultos
|
||||
|
||||
Novos serviços são criados adicionando-os ao arquivo ```/etc/tor/torrc```:
|
||||
```
|
||||
@ -48,12 +48,12 @@ Are you sure you want to continue connecting (yes/no)? yes
|
||||
Warning: Permanently added 'qwkemc3vusd73glx22t3sglf7izs75hqodxsgjqgqlujemv73j73qpid.onion' (ECDSA) to the list of known hosts.
|
||||
standup@qwkemc3vusd73glx22t3sglf7izs75hqodxsgjqgqlujemv73j73qpid.onion's password:
|
||||
```
|
||||
## Resumo: Adicionando um Serviço SSH Oculto
|
||||
## Resumo: Adicionando Serviços SSH Ocultos
|
||||
|
||||
Agora que instalamos o Tor e sabemos como usá-lo, podemos adicionar outros serviços ao Tor. Apenas adicionamos as linhas ao nosso ```torrc``` (no nosso servidor) e o conectamos com o ```torify``` (no nosso cliente).
|
||||
|
||||
> :fire: ***Qual é o poder de utilizar outros serviços ocultos?*** Cada vez que acessamos um serviço em nosso servidor remotamente, deixamos pegadas na rede. Mesmo que os dados sejam criptografados usando SSH (ou TLS), os vigias da rede podem ver de onde estamos nos conectando, para onde estamos conectando e qual serviço estamos usando. Isso realmente importa pra nós? Esta é a pergunta que devemos fazer. Mas se a resposta for "Sim", podemos proteger a conexão com um serviço oculto.
|
||||
|
||||
Vamos seguir "Programando com o RPC" no [Capítulo Dezesseis: Conversando com o Bitcoind usando C](16_0_Talking_to_Bitcoind.md).
|
||||
## O Que Vem Depois?
|
||||
|
||||
Ou, se você não for um programador, pode pular para o [Capítulo Dezenove: Entendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md) para aumentar nosso conhecimento sobre a Lightning Network usando a linha de comando.
|
||||
Para um tipo diferente de privacidade, vamos seguir para "Usando o I2P" com o [Capítulo Quize: Usando o I2P](15_0_Using_i2p.md)
|
@ -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)
|
||||
|
@ -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).
|
||||
|
@ -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).
|
@ -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).
|
@ -1,4 +1,4 @@
|
||||
# 16.1: Configurando a Libwally
|
||||
# 17.1: Configurando a Libwally
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -129,7 +129,7 @@ Em ambos os casos, o argumento é para flags, mas atualmente está definido como
|
||||
|
||||
## Testando um Programa de Teste da Libwally
|
||||
|
||||
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.
|
||||
O diretório src contém o arquivo [testwally.c](src/17_1_testwally.c), que apenas mostra como funcionam as funções de inicialização e de limpeza.
|
||||
|
||||
Podemos compilá-lo da seguinte maneira:
|
||||
```
|
||||
@ -192,4 +192,4 @@ Então, o que exatamente podemos fazer agora? É para dar essa resposta que temo
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos aprender mais sobre "Programando Bitcoin com Libwally" na seção [§16.2: Usando BIP39 na Libwally](16_2_Using_BIP39_in_Libwally.md).
|
||||
Vamos aprender mais sobre "Programando o Bitcoin com Libwally" na seção [§17.2: Usando BIP39 na Libwally](17_2_Using_BIP39_in_Libwally.md).
|
@ -1,4 +1,4 @@
|
||||
# 16.2: Usando BIP39 na Libwally
|
||||
# 17.2: Usando BIP39 na Libwally
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -103,4 +103,4 @@ O BIP39 nos permite gerar um conjunto de 12-24 palavras Mnemônicas a partir de
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
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).
|
||||
Vamos aprender mais sobre "Programando o Bitcoind usando o Libwally" na seção [§17.3: Usando o BIP32 no Libwally](17_3_Using_BIP32_in_Libwally.md).
|
@ -1,4 +1,4 @@
|
||||
# 17.3: Usando o BIP32 na Libwally
|
||||
# 17.3: Usando BIP32 na Libwally
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -129,7 +129,7 @@ Account xpub key: tpubDWFQG78gYHzCkACXxkeh2LwWo8MVLm3YkTGd85LJwtpBB6xp4KwseGTEvx
|
||||
[m/84'/1'/0'/0/0]: tb1q0knqq26ek59pfl7nukzqr28m2zl5wn2f0ldvwu
|
||||
```
|
||||
|
||||
## Resumo: Usando o BIP32 na Libwally
|
||||
## Resumo: Usando BIP32 na Libwally
|
||||
|
||||
Uma carteira HD permite gerar um grande número de chaves a partir de uma única seed. Agora sabemos como essas chaves são organizadas no BIP44, BIP84 e no Bitcoin Core, além de como derivá-las, começando com uma seed ou palavras mnemônicas.
|
||||
|
||||
@ -139,4 +139,4 @@ Uma carteira HD permite gerar um grande número de chaves a partir de uma única
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos aprender mais sobre "Programando Bitcoin com Libwally" na seção [§17.4: Usando PSBTs na Libwally](16_4_Using_PSBTs_in_Libwally.md).
|
||||
Vamos aprender mais sobre "Programando Bitcoin com Libwally" na seção [§17.4: Usando PSBTs na Libwally](17_4_Using_PSBTs_in_Libwally.md).
|
@ -6,7 +6,7 @@ Na seção 3 deste capítulo, ao apresentar os scripts, dissemos que era prováv
|
||||
|
||||
## Criando o Script
|
||||
|
||||
Criar o script é a coisa _mais fácil_ de se fazer na Libwally. Veja o exemplo a seguir, um simples [Script Quebra-Cabeça](13_1_Writing_Puzzle_Scripts.md) ao qual retornamos de vez em quando:
|
||||
Criar o script é a coisa _mais fácil_ de se fazer na Libwally. Veja o exemplo a seguir, um simples [Script de Quebra-Cabeças](13_1_Writing_Puzzle_Scripts.md) ao qual retornamos de vez em quando:
|
||||
```
|
||||
OP_ADD 99 OP_EQUAL
|
||||
```
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 17.7: Integranda Libwally e Bitcoin-CLI
|
||||
# 17.7: Integrando Libwally e Bitcoin-CLI
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
|
@ -417,4 +417,4 @@ Embora o `btcd` e o `rpcclient` tenham alguns limites, ainda podemos executar os
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos aprender mais sobre "Conversando com o Bitcoind com Outras Linguagens" na seção [§18.2: Acessando Bitcoin com Java](18_2_Accessing_Bitcoind_with_Java.md).
|
||||
Vamos aprender mais sobre "Conversando com o Bitcoind com Outras Linguagens" na seção [§18.2: Acessando o Bitcoin com Java](18_2_Accessing_Bitcoind_with_Java.md).
|
@ -399,7 +399,7 @@ O Swift é uma linguagem de programação robusta e moderna que infelizmente ain
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Aprenda sobre o Lightning em [Capítulo 19: Compreendendo Sua Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md).
|
||||
Aprenda sobre o Lightning em [Capítulo 19: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md).
|
||||
|
||||
## Variante: Implantando o Swift no Ubuntu
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
# Capítulo 19: Compreendendo a Configuração da Lightning
|
||||
# Capítulo 19: Compreendendo Nossa Configuração da Lightning
|
||||
|
||||
> :information_source: **NOTA:** Este é um rascunho que está em andamento. Seu objetivo é que possa obter alguns comentários dos revisores iniciais. Ainda não está pronto para ser produzido.
|
||||
|
||||
@ -20,7 +20,7 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção 1: Verificando a Configuração da c-lightning](19_1_Verifying_Your_Lightning_Setup.md)
|
||||
* [Seção 2: Conhecendo a Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md)
|
||||
* [Seção 1: Verificando Nossa Configuração da c-lightning](19_1_Verifying_Your_Lightning_Setup.md)
|
||||
* [Seção 2: Conhecendo Nossa Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md)
|
||||
* [Adendo: Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md)
|
||||
* [Seção 3: Criando um Canal na Lightning](19_3_Setting_Up_a_Channel.md)
|
||||
* [Seção 3: Criando um Canal Lightning](19_3_Setting_Up_a_Channel.md)
|
@ -1,4 +1,4 @@
|
||||
# 19.1: Verificando a Configuração da c-lightning
|
||||
# 19.1: Verificando Nossa Configuração da c-lightning
|
||||
|
||||
>: information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -258,13 +258,13 @@ Também existe um arquivo de configuração geral (o padrão é `~/.lightning/co
|
||||
|
||||
Nossa configuração pode não ter nenhum arquivo de configuração: a c-lightning será executada com uma boa configuração padrão, sem eles.
|
||||
|
||||
## Resumo: Verificando a Configuração da c-lightning
|
||||
## Resumo: Verificando Nossa Configuração da c-lightning
|
||||
|
||||
Antes de começar a brincar com a lightning, devemos nos certificar de que nossos aliases estão configurados, nosso `lightningd` está rodando e nosso node está sincronizado. Também podemos querer configurar algum acesso a configurações alternativas da Lightning, em outras redes.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Compreendendo a Configuração da Lightning" na seção [§19.2: Conhecendo a Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md).
|
||||
Vamos continuar "Compreendendo a Configuração da Lightning" na seção [§19.2: Conhecendo Nossa Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md).
|
||||
|
||||
## Variante: Instalando do Ubuntu ppa
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 19.2: Conhecendo a Configuração da c-lightning
|
||||
# 19.2: Conhecendo Nossa Configuração da c-lightning
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -329,12 +329,12 @@ c$ lightning-cli --testnet listconfigs
|
||||
}
|
||||
```
|
||||
|
||||
## Resumo: Conhecendo a Configuração da c-lightning
|
||||
## Resumo: Conhecendo Nossa Configuração da c-lightning
|
||||
|
||||
O diretório `~/.lightning` contém todos os arquivos, enquanto o comando `lightning-cli help` mostra uma variedade de informações dos comandos que podem ser usados para obter mais informações sobre a configuração e o funcionamento da Lightning Network.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Precisaremos de um segundo node para testar o pagamento dos invoices. Se precisarmos de suporte para configurar um, podemos ler o [Adendo: Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md).
|
||||
Precisaremos de um segundo node para testar o pagamento dos invoices. Se precisarmos de suporte para configurar um, podemos ler o [Prefácio: Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md).
|
||||
|
||||
Caso contrário, vamos continuar "Compreendendo a Configuração da Lightning" na seção [§19.3: Criando um Canal na Lightning](19_3_Setting_Up_a_Channel.md).
|
@ -1,4 +1,4 @@
|
||||
# Adendo: Acessando um Segundo Node Lightning
|
||||
# Prefácio: Acessando um Segundo Node Lightning
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -315,12 +315,12 @@ c$ lightning-cli --network=testnet listpeers
|
||||
```
|
||||
No entanto, este definitivamente não será o caso na nossa primeira interação com a Lightning Network.
|
||||
|
||||
## Resumo: Adendo: Acessando um Segundo Node Lightning
|
||||
## Resumo: Prefácio: Acessando um Segundo Node Lightning
|
||||
|
||||
Sempre precisaremos de dois nodes Lightning para formar um canal. Se não tivermos outra pessoa que está testando as coisas conosco, precisaremos criar um segundo node, usanda c-lightning ou (como faremos em nossos exemplos) usando a LND.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Embora possivelmente tenhamos criado um LND, a c-lightning permanecerá no centro dos nossos exemplos até que precisemos começar a usar os dois, no [Capítulo 19](19_0_Understanding_Your_Lightning_Setup.md).
|
||||
Embora possivelmente tenhamos criado um LND, a c-lightning permanecerá no centro dos nossos exemplos até que precisemos começar a usar os dois, no [Capítulo 20](20_0_Using_Lightning.md).
|
||||
|
||||
Vamos continuar "Compreendendo a Configuração da Lightning" na seção [§19.3: Criando um Canal na Lightning](19_3_Setting_Up_a_Channel.md).
|
||||
Vamos continuar "Compreendendo Nossa Configuração da Lightning" na seção [§19.3: Criando um Canal Lightning](19_3_Setting_Up_a_Channel.md).
|
||||
|
@ -1,4 +1,4 @@
|
||||
# 19.3: Criando um Canal na Lightning
|
||||
# 19.3: Criando um Canal Lightning
|
||||
|
||||
> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão.
|
||||
|
||||
@ -176,10 +176,10 @@ Esta transação de financiamento também pode ser encontrada onchain pelo TXID
|
||||
|
||||
> :book: ***O que é a capacidade do canal?*** Em um canal Lightning, ambos os lados do canal possuem uma parte da capacidade. O valor do seu lado do canal é chamado de *saldo local (local balance)* e o valor do outro lado é chamado de *saldo remoto (remote balance)*. Ambos os saldos podem ser atualizados muitas vezes sem fechar o canal (quando o saldo final é enviado para a blockchain), mas a capacidade do canal não pode mudar sem fechá-lo. A capacidade total de um canal é a soma do saldo de cada participante do canal.
|
||||
|
||||
## Resumo: Criando um Canal na Lightning
|
||||
## Resumo: Criando um Canal Lightning
|
||||
|
||||
Precisaremos criar um canal com um node remoto para poder receber e enviar dinheiro pela Lightning Network.
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Você está pronto para passar para o [Capítulo 20: Usando Lightning](20_0_Using_Lightning.md).
|
||||
Você está pronto para passar para o [Capítulo 20: Usando a Lightning](20_0_Using_Lightning.md).
|
@ -19,8 +19,7 @@ Os objetivos secundários do capítulo incluem a capacidade de:
|
||||
|
||||
## Tabela de Conteúdo
|
||||
|
||||
* [Seção 1: Gerando um Invoice](19_1_Generate_a_Payment_Request.md)
|
||||
* [Seção 2: Pagando um Invoice](19_2_Paying_a_Invoice.md)
|
||||
* [Seção 3: Fechando um Canal na Lightning](19_3_Closing_a_Channel.md)
|
||||
* [Seção 4: Expandindo a Lightning Network](19_4_Lightning_Network_Review.md)
|
||||
|
||||
* [Seção 1: Gerando um Invoice](20_1_Generate_a_Payment_Request.md)
|
||||
* [Seção 2: Pagando um Invoice](20_2_Paying_a_Invoice.md)
|
||||
* [Seção 3: Fechando um Canal Lightning](20_3_Closing_a_Channel.md)
|
||||
* [Seção 4: Expandindo a Lightning Network](20_4_Lightning_Network_Review.md)
|
||||
|
@ -203,4 +203,4 @@ Depois de recebermos um invoice, é fácil pagar com um único comando na Lightn
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Usando a Lightning" na seção [§20.3: Fechando um Canal na Lightning](20_3_Closing_a_Channel.md).
|
||||
Vamos continuar "Usando a Lightning" na seção [§20.3: Fechando um Canal Lightning](20_3_Closing_a_Channel.md).
|
@ -256,4 +256,4 @@ Ao fechar um canal, realizamos uma transação na blockchain encerrando nosso re
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Vamos continuar "Usando a Lightning" na seção [§20.4: Expandindo a Rede Lightning](20_4_Lightning_Network_Review.md).
|
||||
Vamos continuar "Usando a Lightning" na seção [§20.4: Expandindo a Lightning Network](20_4_Lightning_Network_Review.md).
|
@ -26,7 +26,7 @@ Se fornecemos um endereço IP, o acesso `ssh` será limitado a esse endereço, d
|
||||
|
||||
## Etapa 5: Configurando o Tor
|
||||
|
||||
O Tor é instalado para fornecer serviços protegidos (ocultos) para acessar os comandos RPC do Bitcoin através do nosso servidor. Podemos consultar a seção [§14.1: Verificando a Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md) para obter mais informações sobre a configuração do Tor.
|
||||
O Tor é instalado para fornecer serviços protegidos (ocultos) para acessar os comandos RPC do Bitcoin através do nosso servidor. Podemos consultar a seção [§14.1: Verificando Nossa Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md) para obter mais informações sobre a configuração do Tor.
|
||||
|
||||
Se criarmos um cliente autorizado para os serviços ocultos, o acesso será limitado a essa chave, que está em `/var/lib/tor/standup/authorized_clients`. Caso contrário, na seção [§14.2](14_2_Changing_Your_Bitcoin_Hidden_Services.md) explicamos como podemos fazê-la depois.
|
||||
|
||||
|
@ -122,6 +122,6 @@ Se quisermos aumentar a segurança da instalação do Bitcoin a partir da fonte,
|
||||
|
||||
## O Que Vem Depois?
|
||||
|
||||
Se estávamos no processo de criação de um node de Bitcoin para usar neste curso, devemos continuar com o [Capítulo 3: Compreendendo Sua Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
Se estávamos no processo de criação de um node Bitcoin para usar neste curso, devemos continuar com o [Capítulo 3: Compreendendo Nossa Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md).
|
||||
|
||||
Se estivermos lendo os apêndices, vamos continuar com o [Apêndice 3: Usando o Bitcoin Regtest](A3_0_Using_Bitcoin_Regtest.md).
|
120
pt/README.md
120
pt/README.md
@ -3,7 +3,7 @@
|
||||
|
||||

|
||||
|
||||
"Aprendendo Bitcoin pela Linha de Comando", esta é a versão em português de [Learning Bitcoin from the Command Line](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line), um tutorial para trabalhar com Bitcoin (e Lightning) que ensina a interação direta com os servidores da maneira mais robusta e segura, para começar a trabalhar com criptomoedas.
|
||||
"Aprendendo Bitcoin pela Linha de Comando" é a versão em português de [Learning Bitcoin from the Command Line](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line), um tutorial para trabalhar com Bitcoin (e Lightning) que ensina a interação direta com os próprios servidores como a maneira mais robusta e segura para começar a trabalhar com criptomoedas.
|
||||
|
||||
> NOTA: Este é um rascunho em progresso, para que eu possa receber algum feedback de revisores iniciais. Ainda não está pronto para uso.
|
||||
|
||||
@ -22,19 +22,19 @@ Se você gostaria de fazer a sua própria tradução, por favor veja [Contribuin
|
||||
**Estado**: Finalizado. Atualizado para 0.20.
|
||||
|
||||
* [1.0: Introdução à Programação com Bitcoin Core e Lightning](01_0_Introduction.md)
|
||||
* [Prefácio: Introduzindo o Bitcoin](01_1_Introducing_Bitcoin.md)
|
||||
* [Prefácio: Apresentando o Bitcoin](01_1_Introducing_Bitcoin.md)
|
||||
* [2.0: Configurando um Bitcoin-Core VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md)
|
||||
* [2.1: Configurando um Bitcoin-Core VPS com Bitcoin Standup](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md)
|
||||
* [2.2: Configurando uma Máquina Bitcoin-Core de Outras Formas](02_2_Setting_Up_Bitcoin_Core_Other.md)
|
||||
* [2.2: Configurando uma Máquina Bitcoin-Core de Outras Maneiras](02_2_Setting_Up_Bitcoin_Core_Other.md)
|
||||
|
||||
### PARTE DOIS: USANDO BITCOIN-CLI
|
||||
### PARTE DOIS: USANDO O BITCOIN-CLI
|
||||
|
||||
**Estado:** Finalizado. Atualizado para 0.20.
|
||||
|
||||
* [3.0: Compreendendo Sua Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md)
|
||||
* [3.1: Verificando Sua Configuração do Bitcoin](03_1_Verifying_Your_Bitcoin_Setup.md)
|
||||
* [3.2: Conhecendo Sua Configuração do Bitcoin](03_2_Knowing_Your_Bitcoin_Setup.md)
|
||||
* [3.3: Configurando Sua Carteira](03_3_Setting_Up_Your_Wallet.md)
|
||||
* [3.0: Compreendendo Nossa Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md)
|
||||
* [3.1: Verificando Nossa Configuração do Bitcoin](03_1_Verifying_Your_Bitcoin_Setup.md)
|
||||
* [3.2: Conhecendo Nossa Configuração do Bitcoin](03_2_Knowing_Your_Bitcoin_Setup.md)
|
||||
* [3.3: Configurando Nossa Carteira](03_3_Setting_Up_Your_Wallet.md)
|
||||
* [Prefácio: Usando Variáveis de Linha de Comando](03_3__Interlude_Using_Command-Line_Variables.md)
|
||||
* [3.4: Recebendo uma Transação](03_4_Receiving_a_Transaction.md)
|
||||
* [3.5: Compreendendo o Descritor](03_5_Understanding_the_Descriptor.md)
|
||||
@ -49,7 +49,7 @@ Se você gostaria de fazer a sua própria tradução, por favor veja [Contribuin
|
||||
* [4.6: Criando uma Transação SegWit](04_6_Creating_a_Segwit_Transaction.md)
|
||||
* [5.0: Controlando Transações no Bitcoin](05_0_Controlling_Bitcoin_Transactions.md)
|
||||
* [5.1 Atentando-se para Transações Presas](05_1_Watching_for_Stuck_Transactions.md)
|
||||
* [5.2: Re-enviando uma Transação com RBF](05_2_Resending_a_Transaction_with_RBF.md)
|
||||
* [5.2: Reenviando uma Transação com RBF](05_2_Resending_a_Transaction_with_RBF.md)
|
||||
* [5.3: Financiando uma Transação com CPFP](05_3_Funding_a_Transaction_with_CPFP.md)
|
||||
* [6.0: Expandindo Transações no Bitcoin com Multisigs](06_0_Expanding_Bitcoin_Transactions_Multisigs.md)
|
||||
* [6.1: Enviando uma Transação com Multisig](06_1_Sending_a_Transaction_to_a_Multisig.md)
|
||||
@ -58,7 +58,7 @@ Se você gostaria de fazer a sua própria tradução, por favor veja [Contribuin
|
||||
* [7.0: Expandindo Transações no Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md)
|
||||
* [7.1: Criando uma Transação Parcialmente Assinada no Bitcoin (PSBT)](07_1_Creating_a_Partially_Signed_Bitcoin_Transaction.md)
|
||||
* [7.2: Usando uma Transação Parcialmente Assinada no Bitcoin (PSBT)](07_2_Using_a_Partially_Signed_Bitcoin_Transaction.md)
|
||||
* [7.3: Integrando com Carteiras de Hardware](07_3_Integrating_with_Hardware_Wallets.md)
|
||||
* [7.3: Integrando com Hardware Wallets](07_3_Integrating_with_Hardware_Wallets.md)
|
||||
* [8.0: Expandindo Transações no Bitcoin de Outras Maneiras](08_0_Expanding_Bitcoin_Transactions_Other.md)
|
||||
* [8.1: Enviando uma Transação com um Locktime](08_1_Sending_a_Transaction_with_a_Locktime.md)
|
||||
* [8.2: Enviando uma Transação com Dados](08_2_Sending_a_Transaction_with_Data.md)
|
||||
@ -67,81 +67,81 @@ Se você gostaria de fazer a sua própria tradução, por favor veja [Contribuin
|
||||
|
||||
**Estado:** Finalizado. Atualizado para 0.20 e btcdeb.
|
||||
|
||||
* [9.0: Introduzindo Scripts no Bitcoin](09_0_Introducing_Bitcoin_Scripts.md)
|
||||
* [9.1: Compreendendo a Fundação de Transações](09_1_Understanding_the_Foundation_of_Transactions.md)
|
||||
* [9.2: Rodando um Script no Bitcoin](09_2_Running_a_Bitcoin_Script.md)
|
||||
* [9.3: Testando um Script no Bitcoin](09_3_Testing_a_Bitcoin_Script.md)
|
||||
* [9.0: Apresentando os Scripts do Bitcoin](09_0_Introducing_Bitcoin_Scripts.md)
|
||||
* [9.1: Compreendendo a Base das Transações](09_1_Understanding_the_Foundation_of_Transactions.md)
|
||||
* [9.2: Executando um Script do Bitcoin](09_2_Running_a_Bitcoin_Script.md)
|
||||
* [9.3: Testando um Script do Bitcoin](09_3_Testing_a_Bitcoin_Script.md)
|
||||
* [9.4: Programando um P2PKH](09_4_Scripting_a_P2PKH.md)
|
||||
* [9.5: Programando um P2WPKH](09_5_Scripting_a_P2WPKH.md)
|
||||
* [10.0: Embutindo Scripts em Transações P2SH no Bitcoin](10_0_Embedding_Bitcoin_Scripts_in_P2SH_Transactions.md)
|
||||
* [10.1: Compreendendo a Fundação do P2SH](10_1_Understanding_the_Foundation_of_P2SH.md)
|
||||
* [10.0: Incorporando Scripts em Transações P2SH no Bitcoin](10_0_Embedding_Bitcoin_Scripts_in_P2SH_Transactions.md)
|
||||
* [10.1: Compreendendo a Base do P2SH](10_1_Understanding_the_Foundation_of_P2SH.md)
|
||||
* [10.2: Construindo a Estrutura do P2SH](10_2_Building_the_Structure_of_P2SH.md)
|
||||
* [10.3: Rodando um Script no Bitcoin com P2SH](10_3_Running_a_Bitcoin_Script_with_P2SH.md)
|
||||
* [10.3: Executando um Script do Bitcoin com P2SH](10_3_Running_a_Bitcoin_Script_with_P2SH.md)
|
||||
* [10.4: Programando um Multisig](10_4_Scripting_a_Multisig.md)
|
||||
* [10.5: Programando um Script Segwit](10_5_Scripting_a_Segwit_Script.md)
|
||||
* [10.6: Gastando uma Transação P2SH](10_6_Spending_a_P2SH_Transaction.md)
|
||||
* [11.0: Capacitando Timelock com Scripts no Bitcoin](11_0_Empowering_Timelock_with_Bitcoin_Scripts.md)
|
||||
* [11.1: Compreendendo Opções de Timelock](11_1_Understanding_Timelock_Options.md)
|
||||
* [11.0: Capacitando Timelock com Scripts do Bitcoin](11_0_Empowering_Timelock_with_Bitcoin_Scripts.md)
|
||||
* [11.1: Compreendendo As Opções de Timelock](11_1_Understanding_Timelock_Options.md)
|
||||
* [11.2: Usando CLTV em Scripts](11_2_Using_CLTV_in_Scripts.md)
|
||||
* [11.3: Usando CSV em Scripts](11_3_Using_CSV_in_Scripts.md)
|
||||
* [12.0: Expandindo Scripts no Bitcoin](12_0_Expanding_Bitcoin_Scripts.md)
|
||||
* [12.1: Usando Condicionais de Script](12_1_Using_Script_Conditionals.md)
|
||||
* [12.2: Usando Outros Comandos de Script](12_2_Using_Other_Script_Commands.md)
|
||||
* [12.0: Expandindo os Scripts do Bitcoin](12_0_Expanding_Bitcoin_Scripts.md)
|
||||
* [12.1: Usando Condicionais no Script](12_1_Using_Script_Conditionals.md)
|
||||
* [12.2: Usando Outros Comandos no Script](12_2_Using_Other_Script_Commands.md)
|
||||
* [13.0: Projetando Scripts Reais no Bitcoin](13_0_Designing_Real_Bitcoin_Scripts.md)
|
||||
* [13.1: Escrevendo Scripts de Quebra-Cabeças](13_1_Writing_Puzzle_Scripts.md)
|
||||
* [13.2: Escrevendo Scripts Complexos de Multisig](13_2_Writing_Complex_Multisig_Scripts.md)
|
||||
* [13.3: Capacitando o Bitcoin com Scripts](13_3_Empowering_Bitcoin_with_Scripts.md)
|
||||
|
||||
### PARTE QUATRO: USANDO TOR
|
||||
### PARTE QUATRO: PRIVACIDADE
|
||||
|
||||
**Estado:** Finalizado.
|
||||
|
||||
* [14.0: Usando Tor](14_0_Using_Tor.md)
|
||||
* [14.1: Verificando Sua Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md)
|
||||
* [14.2: Mudando Seus Serviços Ocultos do Bitcoin](14_2_Changing_Your_Bitcoin_Hidden_Services.md)
|
||||
* [14.3: Adicionando SSH aos Seus Serviços Ocultos](14_3_Adding_SSH_Hidden_Services.md)
|
||||
* [14.0: Usando o Tor](14_0_Using_Tor.md)
|
||||
* [14.1: Verificando Nossa Configuração do Tor](14_1_Verifying_Your_Tor_Setup.md)
|
||||
* [14.2: Mudando Nossos Serviços Ocultos do Bitcoin](14_2_Changing_Your_Bitcoin_Hidden_Services.md)
|
||||
* [14.3: Adicionando Serviços SSH Ocultos](14_3_Adding_SSH_Hidden_Services.md)
|
||||
|
||||
* [15.0: Usando i2p](15_0_Using_i2p.md)
|
||||
* [15.1: Bitcoin Core como um Serviço I2P (Invisible Internet Project)](15_1_i2p_service.md)
|
||||
* [15.0: Usando o I2P](15_0_Using_i2p.md)
|
||||
* [15.1: Bitcoin Core como um Serviço I2P (Projeto Internet Invisível)](15_1_i2p_service.md)
|
||||
|
||||
### PARTE CINCO: PROGRAMANDO COM RPC
|
||||
|
||||
**Estado:** Finalizado.
|
||||
|
||||
* [16.0: Conversando com o Bitcoind com C](15_0_Talking_to_Bitcoind.md)
|
||||
* [16.1: Acessando o Bitcoind em C com Livrarias RPC](15_1_Accessing_Bitcoind_with_C.md)
|
||||
* [16.2: Programando o Bitcoind em C com Livrarias RPC](15_2_Programming_Bitcoind_with_C.md)
|
||||
* [16.3: Recebendo Notificações em C com Livrarias ZMQ](15_3_Receiving_Bitcoind_Notifications_with_C.md)
|
||||
* [17.0: Programando Bitcoin com Libwally](16_0_Programming_with_Libwally.md)
|
||||
* [17.1: Configurando a Libwally](16_1_Setting_Up_Libwally.md)
|
||||
* [17.2: Usando BIP39 na Libwally](16_2_Using_BIP39_in_Libwally.md)
|
||||
* [17.3: Usando BIP32 na Libwally](16_3_Using_BIP32_in_Libwally.md)
|
||||
* [17.4: Usando PSBTs na Libwally](16_4_Using_PSBTs_in_Libwally.md)
|
||||
* [17.5: Usando Scripts na Libwally](16_5_Using_Scripts_in_Libwally.md)
|
||||
* [17.6: Usando Outras Funções na Libwally](16_6_Using_Other_Functions_in_Libwally.md)
|
||||
* [17.7: Integrando Libwally e Bitcoin-CLI](16_7_Integrating_Libwally_and_Bitcoin-CLI.md)
|
||||
* [18.0: Conversando com o Bitcoind com Outras Linguagens](17_0_Talking_to_Bitcoind_Other.md)
|
||||
* [18.1: Acessando o Bitcoind com Go](17_1_Accessing_Bitcoind_with_Go.md)
|
||||
* [18.2: Acessando o Bitcoind com Java](17_2_Accessing_Bitcoind_with_Java.md)
|
||||
* [18.3: Acessando o Bitcoind com Node JS](17_3_Accessing_Bitcoind_with_NodeJS.md)
|
||||
* [18.4: Acessando o Bitcoind com Python](17_4_Accessing_Bitcoind_with_Python.md)
|
||||
* [18.5: Acessando o Bitcoind com Rust](17_5_Accessing_Bitcoind_with_Rust.md)
|
||||
* [18.6: Acessando o Bitcoind com Swift](17_6_Accessing_Bitcoind_with_Swift.md)
|
||||
* [16.0: Conversando com o Bitcoind com C](16_0_Talking_to_Bitcoind.md)
|
||||
* [16.1: Acessando o Bitcoind em C com Bibliotecas RPC](16_1_Accessing_Bitcoind_with_C.md)
|
||||
* [16.2: Programando o Bitcoind em C com Bibliotecas RPC](16_2_Programming_Bitcoind_with_C.md)
|
||||
* [16.3: Recebendo Notificações em C com Bibliotecas ZMQ](16_3_Receiving_Bitcoind_Notifications_with_C.md)
|
||||
* [17.0: Programando o Bitcoin com Libwally](17_0_Programming_with_Libwally.md)
|
||||
* [17.1: Configurando a Libwally](17_1_Setting_Up_Libwally.md)
|
||||
* [17.2: Usando BIP39 na Libwally](17_2_Using_BIP39_in_Libwally.md)
|
||||
* [17.3: Usando BIP32 na Libwally](17_3_Using_BIP32_in_Libwally.md)
|
||||
* [17.4: Usando PSBTs na Libwally](17_4_Using_PSBTs_in_Libwally.md)
|
||||
* [17.5: Usando Scripts na Libwally](17_5_Using_Scripts_in_Libwally.md)
|
||||
* [17.6: Usando Outras Funções na Libwally](17_6_Using_Other_Functions_in_Libwally.md)
|
||||
* [17.7: Integrando Libwally e Bitcoin-CLI](17_7_Integrating_Libwally_and_Bitcoin-CLI.md)
|
||||
* [18.0: Conversando com o Bitcoind com Outras Linguagens](18_0_Talking_to_Bitcoind_Other.md)
|
||||
* [18.1: Acessando o Bitcoind com Go](18_1_Accessing_Bitcoind_with_Go.md)
|
||||
* [18.2: Acessando o Bitcoind com Java](18_2_Accessing_Bitcoind_with_Java.md)
|
||||
* [18.3: Acessando o Bitcoind com Node JS](18_3_Accessing_Bitcoind_with_NodeJS.md)
|
||||
* [18.4: Acessando o Bitcoind com Python](18_4_Accessing_Bitcoind_with_Python.md)
|
||||
* [18.5: Acessando o Bitcoind com Rust](18_5_Accessing_Bitcoind_with_Rust.md)
|
||||
* [18.6: Acessando o Bitcoind com Swift](18_6_Accessing_Bitcoind_with_Swift.md)
|
||||
|
||||
### PARTE SEIS: USANDO LIGHTNING-CLI
|
||||
### PARTE SEIS: USANDO A LIGHTNING-CLI
|
||||
|
||||
**Estado:** Finalizado.
|
||||
|
||||
* [19.0: Compreendendo Sua Configuração Lightning](18_0_Understanding_Your_Lightning_Setup.md)
|
||||
* [19.1: Verificando Sua Configuração c-lightning](18_1_Verifying_Your_Lightning_Setup.md)
|
||||
* [19.2: Conhecendo Sua Configuração c-lightning](18_2_Knowing_Your_lightning_Setup.md)
|
||||
* [Prefácio: Acessando um Segundo Node Lightning](18_2__Interlude_Accessing_a_Second_Lightning_Node.md)
|
||||
* [19.3: Criando um Canal Lightning](18_3_Setting_Up_a_Channel.md)
|
||||
* [20.0: Usando Lightning](19_0_Using_Lightning.md)
|
||||
* [20.1: Gerando um Pedido de Pagamento](19_1_Generate_a_Payment_Request.md)
|
||||
* [20.2: Pagando uma Fatura](19_2_Paying_a_Invoice.md)
|
||||
* [20.3: Fechando um Canal Lighnting]((19_3_Closing_a_Channel.md))
|
||||
* [20.4: Expandindo a Rede Lightning](19_4_Lightning_Network_Review.md)
|
||||
* [19.0: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md)
|
||||
* [19.1: Verificando Nossa Configuração da c-lightning](19_1_Verifying_Your_Lightning_Setup.md)
|
||||
* [19.2: Conhecendo Nossa Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md)
|
||||
* [Prefácio: Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md)
|
||||
* [19.3: Criando um Canal Lightning](19_3_Setting_Up_a_Channel.md)
|
||||
* [20.0: Usando a Lightning](20_0_Using_Lightning.md)
|
||||
* [20.1: Gerando um Invoice](20_1_Generate_a_Payment_Request.md)
|
||||
* [20.2: Pagando um Invoice](20_2_Paying_a_Invoice.md)
|
||||
* [20.3: Fechando um Canal Lighnting]((20_3_Closing_a_Channel.md))
|
||||
* [20.4: Expandindo a Lightning Network](20_4_Lightning_Network_Review.md)
|
||||
|
||||
### APÊNDICES
|
||||
|
||||
@ -222,4 +222,4 @@ As seguintes chaves podem ser utilizadas para comunicar informação confidencia
|
||||
| ----------------- | -------------------------------------------------- |
|
||||
| Christopher Allen | FDFE 14A5 4ECB 30FC 5D22 74EF F8D3 6C91 3574 05ED |
|
||||
|
||||
Você pode importar uma chave rodando o seguinte comando com a fingerprint daquele indivíduo: `gpg --recv-keys "<fingerprint>"` Se certifique de colocar o fingerprint entre aspas caso o mesmo contenha espaços.
|
||||
Você pode importar uma chave executando o seguinte comando com a fingerprint daquele indivíduo: `gpg --recv-keys "<fingerprint>"` Se certifique de colocar o fingerprint entre aspas caso o mesmo contenha espaços.
|
Loading…
x
Reference in New Issue
Block a user