From fdaaac3856f4fde0d8496b22edf84e0a2fcf3ff7 Mon Sep 17 00:00:00 2001 From: KoreaComK Date: Sun, 8 Aug 2021 15:14:40 -0300 Subject: [PATCH 1/8] Chapter 18 translation concluded --- pt/18_0_Understanding_Your_Lightning_Setup.md | 26 ++ pt/18_1_Verifying_Your_Lightning_Setup.md | 288 +++++++++++++++ pt/18_2_Knowing_Your_lightning_Setup.md | 340 ++++++++++++++++++ ...rlude_Accessing_a_Second_Lightning_Node.md | 326 +++++++++++++++++ pt/18_3_Setting_Up_a_Channel.md | 185 ++++++++++ 5 files changed, 1165 insertions(+) create mode 100644 pt/18_0_Understanding_Your_Lightning_Setup.md create mode 100644 pt/18_1_Verifying_Your_Lightning_Setup.md create mode 100644 pt/18_2_Knowing_Your_lightning_Setup.md create mode 100644 pt/18_2__Interlude_Accessing_a_Second_Lightning_Node.md create mode 100644 pt/18_3_Setting_Up_a_Channel.md diff --git a/pt/18_0_Understanding_Your_Lightning_Setup.md b/pt/18_0_Understanding_Your_Lightning_Setup.md new file mode 100644 index 0000000..3a3a6bf --- /dev/null +++ b/pt/18_0_Understanding_Your_Lightning_Setup.md @@ -0,0 +1,26 @@ +# Capítulo 18: Compreendendo a 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. + +O capítulo anterior concluiu nosso trabalho com o Bitcoin propriamente dito, por meio do CLI, scripts e linguagens de programação. No entanto, existem muitos outros utilitários dentro do ecossistema Bitcoin. Neste capítulo e no próximo, iremos cobrir o que pode ser o maior e mais importante deles, a Lightning Network. Aqui, começaremos a trabalhar com a interface de linha de comando `lightning-cli`, entendendo a configuração do c-lightning e dos seus recursos, incluindo alguns exemplos e configuração básica. + +## Objetivos deste capítulo + +Depois de trabalhar neste capítulo, um desenvolvedor será capaz de: + + * Avaliar se um node c-lightning está instalado e atualizado; + * Executar comandos básicos de uma carteira Lightning ; + * Criar um canal na Lightning. + +Os objetivos secundários do capítulo incluem a capacidade de: + + * Compreender a configuração básica da Lightning; + * Compreender a interação dos canais Lightning; + * Entender como usar a Lightning. + +## Tabela de Conteúdo + +* [Seção 1: Verificando a configuração do c-lightning](18_1_Verifying_Your_Lightning_Setup.md) +* [Seção 2: Conhecendo a configuração do c-lightning](18_2_Knowing_Your_lightning_Setup.md) + * [Adendo: Acessando um segundo node Lightning](18_2__Interlude_Accessing_a_Second_Lightning_Node.md) +* [Seção 3: Criando um canal na Lightning](18_3_Setting_Up_a_Channel.md) \ No newline at end of file diff --git a/pt/18_1_Verifying_Your_Lightning_Setup.md b/pt/18_1_Verifying_Your_Lightning_Setup.md new file mode 100644 index 0000000..5d3cb0c --- /dev/null +++ b/pt/18_1_Verifying_Your_Lightning_Setup.md @@ -0,0 +1,288 @@ +# 18.1: Verificando a configuração do c-lightning + +>: information_source: ** NOTA: ** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. + +Nesta seção, instalaremos e verificaremos o c-lightning, nosso utilitário para acessar a Lightning Network. + +> :book: ***O que é a Lightning Network?*** A Rede Lightning é uma rede descentralizada que usa a funcionalidade de contrato inteligente da blockchain do Bitcoin para permitir pagamentos instantâneos em uma rede de participantes. A Lightning é construída como um protocolo de segunda camada que interage com o Bitcoin para permitir que os usuários troquem seus bitcoins "fora da blockchain (ou como muitos falam, offchain)". + +> :book: ***O que é um protocolo de segunda camada?*** A segunda camada refere-se a um protocolo secundário criado em cima do sistema de blockchain do Bitcoin. O objetivo principal desses protocolos é resolver a velocidade de transação e as dificuldades de escala que estão presentes no Bitcoin. O Bitcoin não é capaz de processar milhares de transações por segundo (TPS), então protocolos de segunda camada foram criados para resolver o problema de escalabilidade da blockchain . Essas soluções também são conhecidas como soluções de dimensionamento "offchain". + +## Instalando o C-Lightning + +Se já usamos os [Bitcoin Standup Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts), talvez já o tenhamos instalado no início deste curso. Podemos testar isso verificando se o `lightningd` está em execução: +``` +$ ps auxww | grep -i lightning +standup 31213 0.0 0.2 24144 10424 pts/0 S 15:38 0:00 lightningd --testnet +standup 31214 0.0 0.1 22716 7444 pts/0 S 15:38 0:00 /usr/local/bin/../libexec/c-lightning/plugins/autoclean +standup 31215 0.0 0.2 22992 8248 pts/0 S 15:38 0:00 /usr/local/bin/../libexec/c-lightning/plugins/bcli +standup 31216 0.0 0.1 22756 7604 pts/0 S 15:38 0:00 /usr/local/bin/../libexec/c-lightning/plugins/keysend +standup 31217 0.0 0.1 22776 7648 pts/0 S 15:38 0:00 /usr/local/bin/../libexec/c-lightning/plugins/pay +standup 31218 0.0 0.1 22720 7652 pts/0 S 15:38 0:00 /usr/local/bin/../libexec/c-lightning/plugins/txprepare +standup 31219 0.0 0.1 22744 7716 pts/0 S 15:38 0:00 /usr/local/bin/../libexec/c-lightning/plugins/spenderp +standup 31227 0.0 0.1 22748 7384 pts/0 SL 15:38 0:00 /usr/local/libexec/c-lightning/lightning_hsmd +standup 31228 0.0 0.2 23044 8192 pts/0 S 15:38 0:00 /usr/local/libexec/c-lightning/lightning_connectd +standup 31229 0.0 0.1 22860 7556 pts/0 S 15:38 0:00 /usr/local/libexec/c-lightning/lightning_gossipd +standup 32072 0.0 0.0 6208 888 pts/0 S+ 15:50 0:00 grep -i lightning +``` +Caso contrário, precisaremos instalá-lo agora. Infelizmente, se estivermos usando o Debian, precisaremos instalá-lo manualmente, compilando o código-fonte, mas ainda assim deve ser muito simples se seguirmos estas instruções. Se acontecer de estarmos em um sistema Ubuntu padrão, podemos tentar [Instalar a partir do Ubuntu ppa](#variant-install-from-ubuntu-ppa), e sempre pode tentar [Instalar os binários pré-compilados](#variant-install- binários pré-compilados). + +> :book: ***O que é a c-lightning?*** Existem três implementações diferentes da Lightning no momento: C-lightning, LND e Eclair. Todos devem ser funcionalmente compatíveis, com base nas mesmas [RFCs do BOLT](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), mas os detalhes de implementação podem ser diferentes. Escolhemos a c-lightning como base do curso porque ela também faz parte do mesmo [Elements Project](https://github.com/ElementsProject) que também contém a Libwally. + +### Compilando o código-fonte da c-lightning + +A instalação da Lightning a partir do código-fonte deve ser bem simples se seguirmos estas instruções. + +_Provavelmente_ desejaremos fazer isso em um node não prunado, pois trabalhar com nodes prunados na Lightning pode causar problemas de instalação e uso. Se configuramos nosso node no início deste curso para ser prunado, podemos querer substituí-lo por um full node agora. Se estivermos usando a testnet, devemos conseguir usar o mesmo tipo de máquina que usamos para o node prunado. + +> :warning: **AVISO:** Realmente podemos executar o c-lightning em um node prunado. No entanto, conforme observamos no [repositório Lightning](https://github.com/ElementsProject/lightning#pruning), pode haver uma série de problemas. Para fazer isso funcionar, devemos garantir que o node da Lightning sempre tente atualizar informações sobre os blocos que o node do Bitcoin não excluiu. Para fazermos isso, devemos nos certificar de (1) que nosso node de Bitcoin está totalmente atualizado antes de iniciar nosso node da Lightning pela primeira vez e; (2) que nosso node Lightning nunca fique defasado do node do Bitcoin (para um node prunado em 550 blocos padrão, ele nunca pode ser desligado por 4 dias ou mais). Portanto, podemos usar o node assim, mas apresenta algum perigo, o que não é uma boa ideia se estivermos executando um serviço em produção. + +Dito isso, estamos prontos para instalar a Lightning: + +Primeiro, vamos instalar as dependências, incluindo requisitos de desenvolvimento. +``` +$ sudo apt-get install -y \ + autoconf automake build-essential git libtool libgmp-dev \ + libsqlite3-dev python3 python3-mako net-tools zlib1g-dev libsodium-dev \ + gettext +$ sudo apt-get install -y valgrind python3-pip libpq-dev +``` +Isso pode demorar um pouco, porque há várias dependências e algumas são bem grandes. + +Em segundo lugar, vamos clonar o repositório Lightning: +``` +$ cd ~ +$ git clone https://github.com/ElementsProject/lightning.git +$ cd lightning +``` +Agora podemos usar o `pip3` que instalamos para instalar requisitos adicionais para a compilação e posteriomente configurar tudo: +``` +$ pip3 install -r requirements.txt +$ ./configure +``` +Agora, vamos compilar. Isso pode levar algum tempo também, dependendo do processamento da nossa máquina. +``` +$ make +``` +Depois disso, o que precisamos fazer é instalar: +``` +$ sudo make install +``` + +## Verificando nossa instalação + +Podemos confirmar que tudo foi instalado o lightningd corretamente usando o parâmetro `help`: + +``` +$ lightningd --help +lightningd: WARNING: default network changing in 2020: please set network=testnet in config! +Usage: lightningd +A bitcoin lightning daemon (default values shown for network: testnet). +--conf= Specify configuration file +--lightning-dir= Set base directory: network-specific + subdirectory is under here + (default: "/home/javier/.lightning") +--network Select the network parameters (bitcoin, + testnet, regtest, litecoin or + litecoin-testnet) (default: testnet) +--testnet Alias for --network=testnet +--signet Alias for --network=signet +--mainnet Alias for --network=bitcoin +``` + +## Executar a Lightningd + +Começaremos a explorar a Lightning Network com o comando `lightning-cli`. No entanto, `lightningd` _deve_ estar rodando para podermos usar o `lightning-cli`, já que `lightning-cli` envia comandos JSON-RPC para o `lightningd` (tudo exatamente como o `bitcoin-cli` e o `bitcoind`). + +Se instalamos o `c-lightning` manualmente, precisaremos iniciá-lo: +``` +$ nohup lightningd --testnet & +``` + +### Executando o lightningd como um serviço + +Se preferirmos, podemos instalar o `lightningd` como um serviço que será executado toda vez que reiniciarmos nossa máquina. Os comandos seguintes farão isso e ele começará a funcionar imediatamente: + +``` +$ cat > ~/lightningd.service << EOF +# It is not recommended to modify this file in-place, because it will +# be overwritten during package upgrades. If you want to add further +# options or overwrite existing ones then use +# $ systemctl edit bitcoind.service +# See "man systemd.service" for details. +# Note that almost all daemon options could be specified in +# /etc/lightning/config, except for those explicitly specified as arguments +# in ExecStart= +[Unit] +Description=c-lightning daemon +[Service] +ExecStart=/usr/local/bin/lightningd --testnet +# Process management +#################### +Type=simple +PIDFile=/run/lightning/lightningd.pid +Restart=on-failure +# Directory creation and permissions +#################################### +# Run as standup +User=standup +# /run/lightningd +RuntimeDirectory=lightningd +RuntimeDirectoryMode=0710 +# Hardening measures +#################### +# Provide a private /tmp and /var/tmp. +PrivateTmp=true +# Mount /usr, /boot/ and /etc read-only for the process. +ProtectSystem=full +# Disallow the process and all of its children to gain +# new privileges through execve(). +NoNewPrivileges=true +# Use a new /dev namespace only populated with API pseudo devices +# such as /dev/null, /dev/zero and /dev/random. +PrivateDevices=true +# Deny the creation of writable and executable memory mappings. +MemoryDenyWriteExecute=true +[Install] +WantedBy=multi-user.target +EOF +$ sudo cp ~/lightningd.service /etc/systemd/system +$ sudo systemctl enable lightningd.service +$ sudo systemctl start lightningd.service +``` + +### Habilitando as conexões remotas + +Se tivermos algum tipo de firewall, precisaremos abrir a porta 9735 para permitir que outros nodes da Lightning interajam conosco. + +Se usarmos o `ufw` do Bitcoin Standup, podemos fazer da seguinte maneira: +``` +$ sudo ufw allow 9735 +``` + +## Verificando o nosso node + +Podemos verificar se o nosso node Lightning está pronto para funcionar comparando a saída de `bitcoin-cli getblockcount` com o resultado de do `blockheight` do `lightning-cli getinfo`. + +``` +$ bitcoin-cli -testnet getblockcount +1838587 +$ lightning-cli --testnet getinfo +{ + "id": "03d4592f1244cd6b5a8bb7fba6a55f8a91591d79d3ea29bf8e3c3a405d15db7bf9", + "alias": "HOPPINGNET", + "color": "03d459", + "num_peers": 0, + "num_pending_channels": 0, + "num_active_channels": 0, + "num_inactive_channels": 0, + "address": [ + { + "type": "ipv4", + "address": "74.207.240.32", + "port": 9735 + }, + { + "type": "ipv6", + "address": "2600:3c01::f03c:92ff:fe48:9ddd", + "port": 9735 + } + ], + "binding": [ + { + "type": "ipv6", + "address": "::", + "port": 9735 + }, + { + "type": "ipv4", + "address": "0.0.0.0", + "port": 9735 + } + ], + "version": "v0.9.1-96-g6f870df", + "blockheight": 1838587, + "network": "testnet", + "msatoshi_fees_collected": 0, + "fees_collected_msat": "0msat", + "lightning-dir": "/home/standup/.lightning/testnet" +} +``` +Neste caso, o `blockheight` é mostrado como `1838587` por ambos os comandos. + +Em vez disso, podemos obter um erro, dependendo da situação. + +Se o node Bitcoin ainda estiver sincronizando com a rede, devemos ver uma mensagem como esta: +``` +"warning_bitcoind_sync": "Bitcoind is not up-to-date with network." +``` +Se o nosso node Lightning não estiver atualizado, receberemos uma mensagem como esta: +``` +"warning_lightningd_sync": "Still loading latest blocks from bitcoind." +``` +Se tentarmos executar em uma blockchain prunada em que o node Bitcoin não estava atualizado quando iniciamos o node Lightning, receberemos as mensagens de erro em nosso log, parecidas como esta: +``` +bitcoin-cli -testnet getblock 0000000000000559febee77ab6e0be1b8d0bef0f971c7a4bee9785393ecef451 0 exited with status 1 +``` + +## Criando aliases + +Sugerimos a criação de alguns aliases para facilitar o uso do c-lightning. + +Podemos fazer isso colocando-os em nosso arquivo `.bash_profile`. +``` +cat >> ~/.bash_profile < :link: **TESTNET vs MAINNET:** Ao configurar nosso node, escolhemos criá-lo como um node Mainnet, Testnet ou Regtest. Embora este documento presuma uma configuração no Testenet, vale a pena entender como podemos acessar e usar os outros tipos de configuração, mesmo todos estando na mesma máquina! Mas, se formos um usuário iniciante, podemos pular esta parte, pois não é necessário para uma configuração básica. + +Quando o lightningd é inicializado, geralmente ele lê um arquivo de configuração cuja localização depende da rede que estamos usando (O padrão é: `~/.lightning/testnet/config`). Isso pode ser alterado com os sinalizadores `–conf` e `–lightning-dir`. + +``` +~/.lightning/testnet$ ls -la config +-rw-rw-r-- 1 user user 267 jul 12 17:08 config +``` +Também existe um arquivo de configuração geral (O padrão é: `~/.lightning/config`). Se desejarmos executar vários tipos diferentes de nodes simultaneamente. Devemos deixar o sinalizador testnet (ou regtest) fora deste arquivo de configuração. Devemos então escolher se estamos usando a mainnet, a testnet ou a regtest toda vez que executarmos o `lightningd` ou o `lightning-cli`. + +Nossa configuração pode não ter nenhum arquivo de configuração. O c-lightning será executado com uma boa configuração padrão, sem eles. + +## Resumo: Verificando a configuração do c-lightning + +Antes de começar a brincar com o 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 [§18.2: Conhecendo a configuração do c-lightning](18_2_Knowing_Your_lightning_Setup.md). + +## Variante: Instalando no Ubuntu ppa + +Se estivermos usando uma versão do Ubuntu diferente do Debian, podemos instalar o c-lightning usando [Ubuntu ppa](https://launchpad.net/~lightningnetwork/+archive/ubuntu/ppa): + +``` +$ sudo apt-get install -y software-properties-common +$ sudo add-apt-repository -u ppa:lightningnetwork/ppa +$ sudo apt-get install lightningd +``` + +## Variante: Instale binários pré-compilados + +Outro método para instalar a Lightning é usar os binários pré-compilados no [repositório Github](https://github.com/ElementsProject/lightning/releases). Vamos escolher o tarball mais recente, como `clightning-v0.9.1-Ubuntu-20.04.tar.xz`. + +Depois de baixá-lo, precisaremos ir para o diretório raiz e descompactá-lo: +``` +$ cd / +$ sudo tar xf ~/clightning-v0.9.1-Ubuntu-20.04.tar.xz +``` +Aviso: Isso exigirá que tenhamos exatamente as mesmas bibliotecas que foram usadas para criar o binário. Geralmente é mais fácil apenas recompilar. \ No newline at end of file diff --git a/pt/18_2_Knowing_Your_lightning_Setup.md b/pt/18_2_Knowing_Your_lightning_Setup.md new file mode 100644 index 0000000..edb617c --- /dev/null +++ b/pt/18_2_Knowing_Your_lightning_Setup.md @@ -0,0 +1,340 @@ +# 18.2: Conhecendo a configuração do c-lightning + +> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. + +Antes de começar a acessar a Lightning Network, devemos compreender melhor nossa configuração. + +## Conhecendo o diretório da c-lightning + +Ao usar o c-lightning, tudo será mantindo dentro do diretório `~/.lightning`. + +O diretório principal contém apenas os diretórios para as redes configuradas, neste caso da Testnet: +``` +$ ls ~/.lightning +testnet +``` +O diretório `~/.lightning/testnet` irá então conter a essência de nossa configuração: +``` +$ ls ~/.lightning/testnet3 +config gossip_store hsm_secret lightningd.sqlite3 lightningd.sqlite3-journal lightning-rpc +``` + +> :link: **TESTNET vs MAINNET:** Se estivermos usando a Mainnet, então _tudo_ será colocado no diretório principal `~/.lightning/bitcoin`. Essas várias configurações _empilham-se_ elegantemente, então se estivermos usando a Mainnet, Testnet e Regtest, descobriremos que `~/.lightning/bitcoin` contém os arquivos de configuração e os dados de mainnet, o diretório `~/.lightning/testnet` contém os dados da Testnet, e o diretório `~/.lightning/regtest` contém os dados Regtest. + +## Conhecendo os comandos lightning-cli + +A maior parte do nosso trabalho inicial será feito com o comando `lightning-cli`, que oferece uma interface fácil para a `lightningd`, assim como o `bitcoin-cli`. + +Já vimos que o comando `help` nos dará uma lista de outros comandos: + +``` +$ lightning-cli help +lightning-cli: WARNING: default network changing in 2020: please set network=testnet in config! +=== bitcoin === + +feerates style + Return feerate estimates, either satoshi-per-kw ({style} perkw) or satoshi-per-kb ({style} perkb). + +newaddr [addresstype] + Get a new {bech32, p2sh-segwit} (or all) address to fund a channel (default is bech32) + +reserveinputs outputs [feerate] [minconf] [utxos] + Reserve inputs and pass back the resulting psbt + +sendpsbt psbt + Finalize, extract and send a PSBT. + +signpsbt psbt + Sign this wallet's inputs on a provided PSBT. + +txdiscard txid + Abandon a transaction created by txprepare + +txprepare outputs [feerate] [minconf] [utxos] + Create a transaction, with option to spend in future (either txsend and txdiscard) + +txsend txid + Sign and broadcast a transaction created by txprepare + +unreserveinputs psbt + Unreserve inputs, freeing them up to be reused + +withdraw destination satoshi [feerate] [minconf] [utxos] + Send to {destination} address {satoshi} (or 'all') amount via Bitcoin transaction, at optional {feerate} + +=== channels === + +close id [unilateraltimeout] [destination] [fee_negotiation_step] + Close the channel with {id} (either peer ID, channel ID, or short channel ID). Force a unilateral close after {unilateraltimeout} seconds (default 48h). If {destination} address is provided, will be used as output address. + +fundchannel_cancel id + Cancel inflight channel establishment with peer {id}. + +fundchannel_complete id txid txout + Complete channel establishment with peer {id} for funding transactionwith {txid}. Returns true on success, false otherwise. + +fundchannel_start id amount [feerate] [announce] [close_to] [push_msat] + Start fund channel with {id} using {amount} satoshis. Returns a bech32 address to use as an output for a funding transaction. + +getroute id msatoshi riskfactor [cltv] [fromid] [fuzzpercent] [exclude] [maxhops] + Show route to {id} for {msatoshi}, using {riskfactor} and optional {cltv} (default 9). If specified search from {fromid} otherwise use this node as source. Randomize the route with up to {fuzzpercent} (default 5.0). {exclude} an array of short-channel-id/direction (e.g. [ '564334x877x1/0', '564195x1292x0/1' ]) or node-id from consideration. Set the {maxhops} the route can take (default 20). + +listchannels [short_channel_id] [source] + Show channel {short_channel_id} or {source} (or all known channels, if not specified) + +listforwards + List all forwarded payments and their information + +setchannelfee id [base] [ppm] + Sets specific routing fees for channel with {id} (either peer ID, channel ID, short channel ID or 'all'). Routing fees are defined by a fixed {base} (msat) and a {ppm} (proportional per millionth) value. If values for {base} or {ppm} are left out, defaults will be used. {base} can also be defined in other units, for example '1sat'. If {id} is 'all', the fees will be applied for all channels. + +=== network === + +connect id [host] [port] + Connect to {id} at {host} (which can end in ':port' if not default). {id} can also be of the form id@host + +disconnect id [force] + Disconnect from {id} that has previously been connected to using connect; with {force} set, even if it has a current channel + +listnodes [id] + Show node {id} (or all, if no {id}), in our local network view + +listpeers [id] [level] + Show current peers, if {level} is set, include logs for {id} + +ping id [len] [pongbytes] + Send peer {id} a ping of length {len} (default 128) asking for {pongbytes} (default 128) + +=== payment === + +createonion hops assocdata [session_key] + Create an onion going through the provided nodes, each with its own payload + +decodepay bolt11 [description] + Decode {bolt11}, using {description} if necessary + +delexpiredinvoice [maxexpirytime] + Delete all expired invoices that expired as of given {maxexpirytime} (a UNIX epoch time), or all expired invoices if not specified + +delinvoice label status + Delete unpaid invoice {label} with {status} + +invoice msatoshi label description [expiry] [fallbacks] [preimage] [exposeprivatechannels] + Create an invoice for {msatoshi} with {label} and {description} with optional {expiry} seconds (default 1 week), optional {fallbacks} address list(default empty list) and optional {preimage} (default autogenerated) + +listinvoices [label] + Show invoice {label} (or all, if no {label}) + +listsendpays [bolt11] [payment_hash] + Show sendpay, old and current, optionally limiting to {bolt11} or {payment_hash}. + +listtransactions + List transactions that we stored in the wallet + +sendonion onion first_hop payment_hash [label] [shared_secrets] [partid] + Send a payment with a pre-computed onion. + +sendpay route payment_hash [label] [msatoshi] [bolt11] [payment_secret] [partid] + Send along {route} in return for preimage of {payment_hash} + +waitanyinvoice [lastpay_index] [timeout] + Wait for the next invoice to be paid, after {lastpay_index} (if supplied). If {timeout} seconds is reached while waiting, fail with an error. + +waitinvoice label + Wait for an incoming payment matching the invoice with {label}, or if the invoice expires + +waitsendpay payment_hash [timeout] [partid] + Wait for payment attempt on {payment_hash} to succeed or fail, but only up to {timeout} seconds. + +=== plugin === + +autocleaninvoice [cycle_seconds] [expired_by] + Set up autoclean of expired invoices. + +estimatefees + Get the urgent, normal and slow Bitcoin feerates as sat/kVB. + +fundchannel id amount [feerate] [announce] [minconf] [utxos] [push_msat] + Fund channel with {id} using {amount} (or 'all'), at optional {feerate}. Only use outputs that have {minconf} confirmations. + +getchaininfo + Get the chain id, the header count, the block count, and whether this is IBD. + +getrawblockbyheight height + Get the bitcoin block at a given height + +getutxout txid vout + Get informations about an output, identified by a {txid} an a {vout} + +listpays [bolt11] + List result of payment {bolt11}, or all + +pay bolt11 [msatoshi] [label] [riskfactor] [maxfeepercent] [retry_for] [maxdelay] [exemptfee] + Send payment specified by {bolt11} with {amount} + +paystatus [bolt11] + Detail status of attempts to pay {bolt11}, or all + +plugin subcommand=start|stop|startdir|rescan|list + Control plugins (start, stop, startdir, rescan, list) + +sendrawtransaction tx + Send a raw transaction to the Bitcoin network. + +=== utility === + +check command_to_check + Don't run {command_to_check}, just verify parameters. + +checkmessage message zbase [pubkey] + Verify a digital signature {zbase} of {message} signed with {pubkey} + +getinfo + Show information about this node + +getlog [level] + Show logs, with optional log {level} (info|unusual|debug|io) + +getsharedsecret point + Compute the hash of the Elliptic Curve Diffie Hellman shared secret point from this node private key and an input {point}. + +help [command] + List available commands, or give verbose help on one {command}. + +listconfigs [config] + List all configuration options, or with [config], just that one. + +listfunds + Show available funds from the internal wallet + +signmessage message + Create a digital signature of {message} + +stop + Shut down the lightningd process + +waitblockheight blockheight [timeout] + Wait for the blockchain to reach {blockheight}, up to {timeout} seconds. + +=== developer === + +dev-listaddrs [bip32_max_index] + Show addresses list up to derivation {index} (default is the last bip32 index) + +dev-rescan-outputs + Synchronize the state of our funds with bitcoind + +--- +run `lightning-cli help ` for more information on a specific command +``` + +## Conhecendo as informações de Lightning + +Uma variedade de comandos `lightning-cli` podem fornecer informações adicionais sobre nosso node Lightning. Os mais comuns são: +``` +$ lightning-cli --testnet listconfigs +$ lightning-cli --testnet listfunds +$ lightning-cli --testnet listtransactions +$ lightning-cli --testnet listinvoices +$ lightning-cli --testnet listnodes +``` +* listconfigs: O comando RPC `listconfigs` lista todas as opções de configuração; +* listfunds: O comando RPC `listfunds` exibe todos os fundos disponíveis, seja em saídas não gastas (UTXOs) na carteira interna ou fundos bloqueados em canais abertos no momento; +* listtransactions: O comando RPC `listtransactions` retorna as transações rastreadas na carteira. Isso inclui depósitos, retiradas e transações relacionadas a canais; +* listinvoices: O comando RPC `listinvoices` recupera o status de um invoice específico, se houver, ou o status de todos os invoices, se não houver nenhum argumento; +* listnodes: O comando RPC `listnodes` retorna nodes que nosso servidor aprendeu através da comunicação com outros nodes, ou um específico se o id do node foi informado. + +Por exemplo, `lightning-cli listconfigs` fornece uma variedade de informações sobre nossa configuração: + +``` +c$ lightning-cli --testnet listconfigs +{ + "# version": "v0.8.2-398-g869fa08", + "lightning-dir": "/home/standup/.lightning", + "network": "testnet", + "allow-deprecated-apis": true, + "rpc-file": "lightning-rpc", + "plugin": "/usr/local/bin/../libexec/c-lightning/plugins/fundchannel", + "plugin": "/usr/local/bin/../libexec/c-lightning/plugins/autoclean", + "plugin": "/usr/local/bin/../libexec/c-lightning/plugins/bcli", + "plugin": "/usr/local/bin/../libexec/c-lightning/plugins/pay", + "plugin": "/usr/local/bin/../libexec/c-lightning/plugins/keysend", + "plugins": [ + { + "path": "/usr/local/bin/../libexec/c-lightning/plugins/fundchannel", + "name": "fundchannel" + }, + { + "path": "/usr/local/bin/../libexec/c-lightning/plugins/autoclean", + "name": "autoclean", + "options": { + "autocleaninvoice-cycle": null, + "autocleaninvoice-expired-by": null + } + }, + { + "path": "/usr/local/bin/../libexec/c-lightning/plugins/bcli", + "name": "bcli", + "options": { + "bitcoin-datadir": null, + "bitcoin-cli": null, + "bitcoin-rpcuser": null, + "bitcoin-rpcpassword": null, + "bitcoin-rpcconnect": null, + "bitcoin-rpcport": null, + "bitcoin-retry-timeout": null, + "commit-fee": "500" + } + }, + { + "path": "/usr/local/bin/../libexec/c-lightning/plugins/pay", + "name": "pay" + }, + { + "path": "/usr/local/bin/../libexec/c-lightning/plugins/keysend", + "name": "keysend" + } + ], + "disable-plugin": [], + "always-use-proxy": false, + "daemon": "false", + "wallet": "sqlite3:///home/user/.lightning/testnet/lightningd.sqlite3", + "wumbo": false, + "wumbo": false, + "rgb": "03fce2", + "alias": "learningBitcoin", + "pid-file": "/home/user/.lightning/lightningd-testnet.pid", + "ignore-fee-limits": false, + "watchtime-blocks": 144, + "max-locktime-blocks": 720, + "funding-confirms": 3, + "commit-fee-min": 200, + "commit-fee-max": 2000, + "cltv-delta": 6, + "cltv-final": 10, + "commit-time": 10, + "fee-base": 1, + "rescan": 15, + "fee-per-satoshi": 10, + "max-concurrent-htlcs": 483, + "min-capacity-sat": 10000, + "offline": "false", + "autolisten": true, + "disable-dns": "false", + "enable-autotor-v2-mode": "false", + "encrypted-hsm": false, + "rpc-file-mode": "0600", + "log-level": "DEBUG", + "log-prefix": "lightningd" +} +``` + +## Resumo: Conhecendo a configuração do 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 nossa configuração e funcionamento da Lightning Network. + +## O Que Vem Depois? + +Precisaremos de um segundo node para testar o pagamento dos invoices. Se precisaremos de suporte para configurar um, podemos ler o [Adendo: Acessando um segundo node Lightning](18_2__Interlude_Accessing_a_Second_Lightning_Node.md). + +Caso contrário, vamos continuar "Compreendendo sua configuração do Lightning" na seção [§18.3: Criando um canal na Lightning](18_3_Setting_Up_a_Channel.md). \ No newline at end of file diff --git a/pt/18_2__Interlude_Accessing_a_Second_Lightning_Node.md b/pt/18_2__Interlude_Accessing_a_Second_Lightning_Node.md new file mode 100644 index 0000000..cccd6ea --- /dev/null +++ b/pt/18_2__Interlude_Accessing_a_Second_Lightning_Node.md @@ -0,0 +1,326 @@ +# Adendo: 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. + +Quando estávamos brincando com o Bitcoin, estávamos acessando uma rede existente, e isso torna tudo relativamente fácil para se trabalhar. Apenas ligávamos o `bitcoind` e estávamos imediatamente interagindo com a rede. Agora, é assim que a Lightning funciona: É fundamentalmente uma rede ponto a ponto, construída a partir das conexões entre dois nodes individuais. Em outras palavras, para interagir com a Lightning Network, precisaremos primeiro encontrar um node ao qual podemos nos conectar. + +Existem quatro maneiras de fazermos isso, as três primeiras são possíveis para a nossa primeira conexão: + +## Pedindo informações sobre um node + +Se outra pessoa já tiver um node da Lightning Network na rede que escolhemos, podemos pedir o ID dele. + +Se estiverem executando o c-lightning, eles só precisam usar o comando `getinfo`: +``` +$ lightning-cli getinfo +lightning-cli: WARNING: default network changing in 2020: please set network=testnet in config! + "id": "03240a4878a9a64aea6c3921a434e573845267b86e89ab19003b0c910a86d17687", + "alias": "VIOLETGLEE", + "color": "03240a", + "num_peers": 0, + "num_pending_channels": 0, + "num_active_channels": 0, + "num_inactive_channels": 0, + "address": [ + { + "type": "ipv4", + "address": "74.207.240.32", + "port": 9735 + } + ], + "binding": [ + { + "type": "ipv6", + "address": "::", + "port": 9735 + }, + { + "type": "ipv4", + "address": "0.0.0.0", + "port": 9735 + } + ], + "version": "v0.9.1-96-g6f870df", + "blockheight": 1862854, + "network": "testnet", + "msatoshi_fees_collected": 0, + "fees_collected_msat": "0msat", + "lightning-dir": "/home/standup/.lightning/testnet" +} +``` +Eles podem então poderão nos dizer o `ID` (`03240a4878a9a64aea6c3921a434e573845267b86e89ab19003b0c910a86d17687`). Eles também precisarão informar o endereço IP (`74.207.240.32`) e porta (`9735`). + +## Criando um novo node c-lightning + +No entanto, para fins de teste, provavelmente iremos desejar ter um segundo node sob nosso próprio controle. A maneira mais fácil de fazer isso é criar um segundo node c-lightning em uma nova máquina, usando Bitcoin Standup, de acordo com a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) ou compilando-o manualmente, de acordo com a seção [§18.1](18_1_Verifying_Your_Lightning_Setup .md). + +Depois de ter nosso node em execução, podemos executar o `getinfo` para recuperar nossas informações, como mostrado acima. + +## Criando um novo node LND + +No entanto, para nossos exemplos no próximo capítulo, vamos criar um node LND. Isso nos permitirá demonstrar um pouco da profundidade do ecossistema Lightning, mostrando como comandos semelhantes funcionam nas duas plataformas diferentes. + +Uma maneira de criar um node LND é executar os scripts Bitcoin Standup novamente em uma nova máquina, mas desta vez escolher a LND, de acordo com a seção [§2.1](2_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md). + +Outra forma é compilar o LND a partir do código-fonte em uma máquina em que já estejamos executando um node Bitcoin, como falaremos abaixo. + +### Compilando o código-fonte LND + +Primeiro, precisaremos baixar e instalar o Go: +``` +$ wget --progress=bar:force https://dl.google.com/go/"go1.14.4"."linux"-"amd64".tar.gz -O ~standup/"go1.14.4"."linux"-"amd64".tar.gz +$ /bin/tar xzf ~standup/"go1.14.4"."linux"-"amd64".tar.gz -C ~standup +$ sudo mv ~standup/go /usr/local +``` +Depois, precisamos nos certificar de que a versão Go é a mais atualizada (atualmente é a `go1.14.4`), e a plataforma e arquitetura são adequadas para nossa máquina. O item acima funcionará para o Debian. + +Vamos atulizar o caminho: +``` +$ export GOPATH=~standup/gocode +$ export PATH="$PATH":/usr/local/go/bin:"$GOPATH"/bin +``` +Em seguida, vamos nos certificar de que o `go` funciona: +``` +$ go version +go version go1.14.4 linux/amd64 +``` +Também precisaremos do `git` e do `make`: +``` +$ sudo apt-get install git +$ sudo apt-get install build-essential +``` +Agora estamos pronto para recuperar o LND. Certifique-se de obter a versão atual (no momento, é a `v0.11.0-beta.rc4`). +``` +$ go get -d github.com/lightningnetwork/lnd +``` +E agora podemos compilar: +``` +$ cd "$GOPATH"/src/github.com/lightningnetwork/lnd +$ git checkout v0.11.0-beta.rc4 +$ make +$ make install +``` +Os comandos acima irão instalar o Go na pasta `~/gocode/bin`, que é o `$GOPATH/bin`. + +Devemos alterá-la para os diretórios globais: +``` +$ sudo cp $GOPATH/bin/lnd $GOPATH/bin/lncli /usr/bin +``` + +### Criando um arquivo de configuração LND + +Ao contrário do c-lightning, precisaremos criar um arquivo de configuração padrão para o LND. + +No entanto, primeiro, iremos precisar habilitar o ZMQ em nosso Bitcoind, se ainda não o fizemos na seção [§15.3](15_3_Receiving_Bitcoind_Notifications_with_C.md). + +Isso requer adicionar o seguinte ao nosso arquivo `~/.bitcoin/bitcoin.conf` se ainda não estiver lá: +``` +zmqpubrawblock=tcp://127.0.0.1:28332 +zmqpubrawtx=tcp://127.0.0.1:28333 +``` + +Se estivermos usando um arquivo de configuração Bitcoin do Standup ou algum outro `conf` especializado, precisamos nos certificar de colocar nossos novos comandos na seção correta. Idealmente, devemos chegar perto do topo do arquivo, caso contrário, na seção `[test]` (assumindo, como de costume, que estamos testando na testnet). + +Devemos então, reiniciar o bitcoin (ou apenas reiniciar nossa máquina). Podemos testar se está tudo funcionando da seguinte maneira: +``` +$ bitcoin-cli getzmqnotifications +[ + { + "type": "pubrawblock", + "address": "tcp://127.0.0.1:28332", + "hwm": 1000 + }, + { + "type": "pubrawtx", + "address": "tcp://127.0.0.1:28333", + "hwm": 1000 + } +] +``` +Agora estamos prontos para criar um arquivo de configuração. + +Primeiro, precisamos recuperar nosso rpcuser e rpcpassword. Esta é uma maneira automatizada de fazer isso: +``` +$ BITCOINRPC_USER=$(cat ~standup/.bitcoin/bitcoin.conf | grep rpcuser | awk -F = '{print $2}') +$ BITCOINRPC_PASS=$(cat ~standup/.bitcoin/bitcoin.conf | grep rpcpassword | awk -F = '{print $2}') +``` + +> :warning: **AVISO:** Obviamente, nunca iremos armazenar nossa senha RPC em uma variável shell em um ambiente de produção. + +Em seguida, podemos gravar o arquivo: +``` +$ mkdir ~/.lnd +$ cat > ~/.lnd/lnd.conf << EOF +[Application Options] +maxlogfiles=3 +maxlogfilesize=10 +#externalip=1.1.1.1 # change to your public IP address if required. +alias=StandUp +listen=0.0.0.0:9735 +debuglevel=debug +[Bitcoin] +bitcoin.active=1 +bitcoin.node=bitcoind +bitcoin.testnet=true +[Bitcoind] +bitcoind.rpchost=localhost +bitcoind.rpcuser=$BITCOINRPC_USER +bitcoind.rpcpass=$BITCOINRPC_PASS +bitcoind.zmqpubrawblock=tcp://127.0.0.1:28332 +bitcoind.zmqpubrawtx=tcp://127.0.0.1:28333 +EOF +``` + +### Criando um serviço LND + +Finalmente, podemos criar um serviço LND para executar automaticamente o `lnd`: +``` +$ cat > ~/lnd.service << EOF +# It is not recommended to modify this file in-place, because it will +# be overwritten during package upgrades. If you want to add further +# options or overwrite existing ones then use +# $ systemctl edit lnd.service +# See "man systemd.service" for details. +# Note that almost all daemon options could be specified in +# /etc/lnd/lnd.conf, except for those explicitly specified as arguments +# in ExecStart= +[Unit] +Description=LND Lightning Network Daemon +Requires=bitcoind.service +After=bitcoind.service +[Service] +ExecStart=/usr/bin/lnd +ExecStop=/usr/bin/lncli --lnddir /var/lib/lnd stop +PIDFile=/run/lnd/lnd.pid +User=standup +Type=simple +KillMode=process +TimeoutStartSec=60 +TimeoutStopSec=60 +Restart=always +RestartSec=60 +[Install] +WantedBy=multi-user.target +EOF +``` +Em seguida, precisaremos instalar isso e iniciar as coisas: +``` +$ sudo cp ~/lnd.service /etc/systemd/system +$ sudo systemctl enable lnd +$ sudo systemctl start lnd +``` +É esperado que a primeira vez demore um tempo para a inicialização. + +### Habilitando as conexões remotas + +Assim como com o c-lightning, precisaremos tornar o LND acessível a outros nodes. Veja como fazer isso se usarmos o `ufw`, de acordo com as configurações do Bitcoin Standup: +``` +$ sudo ufw allow 9735 +``` + +### Criando uma carteira + +Na primeira vez que executamos o LND, devemos criar uma carteira: +``` +$ lncli --network=testnet create +``` +O LND pedirá uma senha e, em seguida, nos perguntará se desejaremos inserir um mnemônico existente (basta pressionar `n` para o último). + +Agora devemos ter um `lnd` funcionando, que pode ser verificado com o comando `getinfo`: +``` +$ lncli --network=testnet getinfo +{ + "version": "0.11.0-beta.rc4 commit=v0.11.0-beta.rc4", + "commit_hash": "fc12656a1a62e5d69430bba6e4feb8cfbaf21542", + "identity_pubkey": "032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543", + "alias": "StandUp", + "color": "#3399ff", + "num_pending_channels": 0, + "num_active_channels": 0, + "num_inactive_channels": 0, + "num_peers": 2, + "block_height": 1862848, + "block_hash": "000000000000000ecb6fd95e1f486283d48683aa3111b6c23144a2056f5a1532", + "best_header_timestamp": "1602632294", + "synced_to_chain": true, + "synced_to_graph": false, + "testnet": true, + "chains": [ + { + "chain": "bitcoin", + "network": "testnet" + } + ], + "uris": [ + ], + "features": { + "0": { + "name": "data-loss-protect", + "is_required": true, + "is_known": true + }, + "5": { + "name": "upfront-shutdown-script", + "is_required": false, + "is_known": true + }, + "7": { + "name": "gossip-queries", + "is_required": false, + "is_known": true + }, + "9": { + "name": "tlv-onion", + "is_required": false, + "is_known": true + }, + "13": { + "name": "static-remote-key", + "is_required": false, + "is_known": true + }, + "15": { + "name": "payment-addr", + "is_required": false, + "is_known": true + }, + "17": { + "name": "multi-path-payments", + "is_required": false, + "is_known": true + } + } +} +``` +O ID deste node é `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`. Embora este comando não mostre o endereço IP e a porta, eles devem ser o endereço IP da nossa máquina e a porta `9735`. + +## Ouvindo a Lightning + +Se já estivermos conectados à Lightning Network, nosso node já deve estar "fofocando" com seus pares, também já pode ser capaz de encontrar informações sobre os pares automaticamente, por meio do comando `listpeers`: +``` +c$ lightning-cli --network=testnet listpeers +{ + "peers": [ + { + "id": "0302d48972ba7eef8b40696102ad114090fd4c146e381f18c7932a2a1d73566f84", + "connected": true, + "netaddr": [ + "127.0.0.1:9736" + ], + "features": "02a2a1", + "channels": [] + } + ] +} +``` +No entanto, esse definitivamente não será o caso da nossa primeira interação com a Lightning Network. + +## Resumo: Adendo: 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, usando c-lightning ou (como faremos em nossos exemplos) usando a LND. + +## O Que Vem Depois? + +Embora possivelmente tenhamos criado um LND, o c-lightning permanecerá o coração dos nossos exemplos até que precisemos começar a usar os dois, no [Capítulo 19](19_0_Understanding_Your_Lightning_Setup.md). + +Vamos continuar "Compreendendo a configuração da Lightning" na seção [§18.3: Criando um canal na Lightning](18_3_Setting_Up_a_Channel.md). diff --git a/pt/18_3_Setting_Up_a_Channel.md b/pt/18_3_Setting_Up_a_Channel.md new file mode 100644 index 0000000..b193b06 --- /dev/null +++ b/pt/18_3_Setting_Up_a_Channel.md @@ -0,0 +1,185 @@ +# 18.3: Criando um canal na Lightning + +> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. + +Agora que entendemos o básico da configuração da Lightning e, com sorte, já criamos ou recebemos informações sobre um segundo node Lightning. Estamos prontos para criar nosso primeiro canal na Lightning Network. Claro, precisaremos entender o que é e como é criado usando o c-lightning. + +> :book: ***O que é um canal Lightning?*** De maneira simples, um canal Lightning é um tubo de dinheiro que permite transferências rápidas, baratas e privadas sem enviar transações para a blockchain. Mais tecnicamente, um canal é uma transação de Bitcoin em cadeia com várias assinaturas 2 de 2 que estabelece um relacionamento financeiro sem confiança entre duas pessoas ou dois agentes. Uma certa quantia de dinheiro é depositada no canal, quando então se mantém um banco de dados local com saldo em bitcoins para ambas as partes, mantendo o registro de qual é o saldo de cada parte. Os dois usuários podem então trocar bitcoins por meio do canal Lightning sem nunca escrever na blockchain do Bitcoin. Somente quando desejam fechar o canal, eles liquidam os bitcoins na blockchain, com base no saldo final das moedas. + +> :book: ***Como os canais Lightning criam uma rede Lightning?*** Embora um canal Lightning só permita o pagamento entre dois usuários, os canais podem ser conectados para formar uma rede que permite pagamentos entre membros que não têm um canal direto entre eles. Isso cria uma rede entre várias pessoas, construída a partir de conexões em pares. + +Nesta seção, continuaremos usando nossa configuração c-lightning como nosso node principal. + +## Criando um canal + +A criação de um canal Lightning requer as seguintes etapas: + +* Financiar nossa carteira c-lightning com alguns satoshis; +* Conectar-se a um nó remoto como um par; +* Abrir um canal. + +### Financiando nossa carteira c-lightning + +Para mover fundos para um canal Lightning, primeiro é necessário financiar nossa carteira c-lightning. + +> :book: ***O que é uma carteira c-lightning?*** A implementação padrão a c-lightning vem com uma carteira Bitcoin integrada que permite enviar e receber transações bitcoin na blockchain. Esta carteira será usada para criar novos canais. + +A primeira coisa que precisamos fazer é enviar alguns satoshis para nossa carteira c-lightning. Podemos criar um novo endereço usando o comando `lightning-cli newaddr`. Isso gera um novo endereço que pode ser subsequentemente usado para financiar canais gerenciados pelo node c-lightning. Podemos especificar o tipo de endereço desejado. Se não for especificado, o endereço gerado será um bech32. + +``` +$ lightning-cli --testnet newaddr +{ + "address": "tb1qefule33u7ukfuzkmxpz02kwejl8j8dt5jpgtu6", + "bech32": "tb1qefule33u7ukfuzkmxpz02kwejl8j8dt5jpgtu6" +} +``` +Podemos então enviar fundos para este endereço usando `bitcoin-cli sendtoaddress` (ou qualquer outro método de preferência). Para este exemplo, fizemos o envio que pode ser observado na transação [11094bb9ac29ce5af9f1e5a0e4aac2066ae132f25b72bff90fcddf64bf2feb02](https://mempool.space/pt/testnet/tx/11094bb9ac29ce5af9f1e5a0e4aac2066ae132f25b72bff90fcddf64bf2feb02). + +Esta transação é chamada de [transação de financiamento](https://github.com/lightningnetwork/lightning-rfc/blob/master/03-transactions.md#funding-transaction-output) e precisa ser confirmada antes que os fundos possam ser utilizados. + +> :book: ***O que é uma transação de financiamento?*** Uma transação de financiamento é uma transação de Bitcoin que coloca dinheiro em um canal Lightning. Pode ser de financiamento único (por um participante) ou de financiamento duplo (por ambos). A partir daí, as transações da Lightning tratam de realocar a propriedade da transação de financiamento, mas só se ajustam na blockchain quando o canal é fechado. + +Para verificar nosso saldo local, devemos usar o comando `lightning-cli listfunds`: + +``` +c$ lightning-cli --testnet listfunds +{ + "outputs": [], + "channels": [] +} +``` + +Como os fundos ainda não têm seis confirmações, não há saldo disponível. Após seis confirmações, devemos ver o saldo alterado: +``` +c$ lightning-cli --testnet listfunds +{ + "outputs": [ + { + "txid": "11094bb9ac29ce5af9f1e5a0e4aac2066ae132f25b72bff90fcddf64bf2feb02", + "output": 0, + "value": 300000, + "amount_msat": "300000000msat", + "scriptpubkey": "0014ca79fcc63cf72c9e0adb3044f559d997cf23b574", + "address": "tb1qefule33u7ukfuzkmxpz02kwejl8j8dt5jpgtu6", + "status": "confirmed", + "blockheight": 1780680, + "reserved": false + } + ], + "channels": [] +} + +``` +Observe que o valor está listado em satoshis ou microsatoshis, não em Bitcoin! + +> :book: ***O que são satoshis e msats?*** Já conhecemos os satoshis na seção [§3.4](03_4_Receiving_a_Transaction.md). Um satoshi é o centésimo milionésimo de um bitcoin, então 300.000 satoshis equivalem a 0,003 BTC. Um satoshi é a menor unidade monetária na rede Bitcoin. Mas, a rede Lightning pode ser menor, então 1.000 msat, ou milisatoshis, equivalem a um satoshi. Isso significa que 1 msat é o centésimo bilionésimo de um bitcoin e 300.000.000 msat equivalem a 0,003 BTC. + +Agora que financiamos nossa carteira c-lightning, precisaremos de informações sobre um node remoto para começar a criar o processo do canal. + +### Conectando a um node Remoto + +A próxima coisa que precisaremos fazer é conectar nosso node a um par. Isso é feito com o comando `lightning-cli connect`. Lembre-se que se quisermos mais informações sobre este comando, devemos digitar `lightning-cli help connect`. + +Para conectar nosso nodes a um par remoto, precisaremos do nosso id, que representa a chave pública do node de destino. Por conveniência, o `ID` pode ter a forma `id@host` ou `id@host:port`. Podemos ter recuperado isso com o `lightning-cli getinfo` (no c-lightning) ou `lncli --network=testnet getinfo` (no LND) conforme discutido no [adendo anterior](18_2__Interlude_Accessing_a_Second_Lightning_Node.md). + +Selecionamos o node LND, `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`, que está localizado no endereço IP `45.33.35.151`, ao qual vamos nos conectar a partir de nosso node c-lightning: + +``` +$ lightning-cli --network=testnet connect 032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543@45.33.35.151 +{ + "id": "032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543", + "features": "02a2a1" +} +``` + +### Abrindo um canal + +O comando fundchannel do RPC abre um canal de pagamento com um par ao comprometer uma transação de financiamento para o blockchain. Devemos usar o comando `lightning-cli fundchannel` para fazer isso, com os seguintes parâmetros: + +* **id** é o retorno do id do peer da conexão; +* **amount** é o valor em satoshis retirado da carteira interna para financiar o canal. O valor não pode ser inferior ao limite mínimo, atualmente definido como 546 satoshis, nem superior a 16.777.215 satoshis (a menos que grandes canais tenham sido negociados com o par). +* **feerate** é o feerate opcional usado para a transação de abertura e como feerate inicial para transações de confirmação e HTLC. +* **announce** é um sinalizador opcional que aciona o anúncio deste canal ou não. O padrão é verdadeiro. Se desejarmos criar um canal privado, precisamos definí-lo como falso. +* **minconf** especifica o número mínimo de confirmações que devem ter saídas usadas no processo de abertura de canal. O padrão é 1. +* **utxos** especifica os utxos a serem usados ​​para financiar o canal, como uma matriz de “txid:vout”. + +Agora podemos abrir o canal assim: + +``` +$ lightning-cli --testnet fundchannel 032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543 100000 urgent true 1 +{ + "tx": "0200000000010193dc3337837f091718f47b71f2eae8b745ec307231471f6a6aab953c3ea0e3b50100000000fdffffff02a0860100000000002200202e30365fe321a435e5f66962492163302f118c13e215ea8928de88cc46666c1d07860100000000001600142fe02e5be9283e8c5bcb93ae61421baf8cb64f9c024730440220668a7c253c9fd83fc1b45e4a52823fb6bc5fad30da36240d4604f0d6981a6f4502202aeb1da5fbbc8790791ef72b3378005fe98d485d22ffeb35e54a6fbc73178fb2012103b3efe051712e9fa6d90008186e96320491cfe1ef1922d74af5bc6d3307843327c76c1c00", + "txid": "66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d", + "channel_id": "1d3cf2126ae36e12be3aee893b385ed6a2e19b1da7f4e579e3ef15ca234d6966", + "outnum": 0 +} +``` +Para confirmar o status do canal, vamos usar o comando `lightning-cli listfunds`: + +``` +c$ lightning-cli --testnet listfunds +{ + "outputs": [ + { + "txid": "66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d", + "output": 1, + "value": 99847, + "amount_msat": "99847000msat", + "scriptpubkey": "00142fe02e5be9283e8c5bcb93ae61421baf8cb64f9c", + "address": "tb1q9lszuklf9qlgck7tjwhxzssm47xtvnuu4jslf8", + "status": "unconfirmed", + "reserved": false + }, + { + "txid": "b5e3a03e3c95ab6a6a1f47317230ec45b7e8eaf2717bf41817097f833733dc93", + "output": 1, + "value": 200000, + "amount_msat": "200000000msat", + "scriptpubkey": "0014ed54b65eae3da99b23a48bf8827c9acd78079469", + "address": "tb1qa42tvh4w8k5ekgay30ugyly6e4uq09rfpqf9md", + "status": "confirmed", + "blockheight": 1862831, + "reserved": true + } + ], + "channels": [ + { + "peer_id": "032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543", + "connected": true, + "state": "CHANNELD_AWAITING_LOCKIN", + "channel_sat": 100000, + "our_amount_msat": "100000000msat", + "channel_total_sat": 100000, + "amount_msat": "100000000msat", + "funding_txid": "66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d", + "funding_output": 0 + } + ] +} + +``` +Embora este novo canal com 100.000 satoshis não esteja confirmado, nosso estado será `CHANNELD_AWAITING_LOCKIN`. Observe que a alteração não confirmada de satoshis `99847` também está aparecendo como uma nova transação na carteira. Depois que todas as seis confirmações forem concluídas, o canal mudará para o estado `CHANNELD_NORMAL`, que será o estado permanente. Nesse momento, um `short_channel_id` também aparecerá, como: +``` +"short_channel_id": "1862856x29x0", +``` +Esses valores indicam onde a transação de financiamento pode ser encontrada na blockchain. Ele aparece na forma `bloco x txid x vout`. + +Neste caso, `1862856x29x0` significa: + +* Criado no bloco 1862856; +* Com um `txid` de 29 e; +* Um `vout` de 0. + +Podemos precisar usar este `short_channel_id` para certos comandos na Lightning. + +Esta transação de financiamento também pode ser encontrada onchain pelo TXID [66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d] (https://mempool.space/pt/testnet/tx/66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d) + +> :book: ***O que é a capacidade do canal?*** Em um canal Lightning, ambos os lados do canal possuem uma parte da capacidade. O valor do 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 + +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 19: Usando Lightning](19_0_Using_Lightning.md). \ No newline at end of file From c3113187016cf2adec6aa5fb97c148936838d680 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 16:14:11 -0300 Subject: [PATCH 2/8] Delete old files --- pt/15_0_Talking_to_Bitcoind.md | 27 -- pt/15_1_Accessing_Bitcoind_with_C.md | 294 --------------- pt/15_2_Programming_Bitcoind_with_C.md | 354 ------------------ ...Receiving_Bitcoind_Notifications_with_C.md | 155 -------- 4 files changed, 830 deletions(-) delete mode 100644 pt/15_0_Talking_to_Bitcoind.md delete mode 100644 pt/15_1_Accessing_Bitcoind_with_C.md delete mode 100644 pt/15_2_Programming_Bitcoind_with_C.md delete mode 100644 pt/15_3_Receiving_Bitcoind_Notifications_with_C.md diff --git a/pt/15_0_Talking_to_Bitcoind.md b/pt/15_0_Talking_to_Bitcoind.md deleted file mode 100644 index 88bde29..0000000 --- a/pt/15_0_Talking_to_Bitcoind.md +++ /dev/null @@ -1,27 +0,0 @@ - -# Capítulo 15: Conversando com Bitcoind usando 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. - -Esta seção se concentra em três diferentes bibliotecas que podem ser usadas como base de programação C sofisticada: Uma biblioteca RPC e uma biblioteca JSON que juntas permitem recriar muito do que fazemos nos scripts de shell, porém, usando C; enquanto uma biblioteca ZMQ nos conecta a notificações, algo que não conseguiríamos acessar até agora. (O próximo capítulo cobrirá uma biblioteca ainda mais sofisticada chamada Libwally, para finalizar esta introdução à programação do Bitcoin com C). - -## Objetivos deste capítulo - -Depois de trabalhar neste capítulo, um desenvolvedor será capaz de: - - * Criar programas C que usam RPC para conversar com o Bitcoind; - * Criar programas C que usam ZMQ para conversar com o Bitcoind. - -Os objetivos secundários do capítulo incluem a capacidade de: - - * Entender como usar uma biblioteca RPC; - * Entender como usar uma biblioteca JSON; - * Compreender as capacidades do ZMQ; - * Entender como usar uma biblioteca ZMQ. - -## 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) - \ No newline at end of file diff --git a/pt/15_1_Accessing_Bitcoind_with_C.md b/pt/15_1_Accessing_Bitcoind_with_C.md deleted file mode 100644 index 2e97e1c..0000000 --- a/pt/15_1_Accessing_Bitcoind_with_C.md +++ /dev/null @@ -1,294 +0,0 @@ - -# 15.1: Acessando o Bitcoind usando 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. - -Você já viu uma maneira alternativa de acessar as portas RPC do Bitcoind: Usando o ``curl``, que cobrimos no [Capítulo 4 Prefácio](04_4__interlude_using_curl.md). Interagir com o ``Bitcoind`` através de uma biblioteca de RPC usando C não é diferente do que já vimos, só precisamos de boas bibliotecas para nos auxiliar. Esta seção introduz um pacote chamado ``libbitcoinrpc``, que permite acessar a porta JSON-RPC do ``bitcoind``. Ele usa uma biblioteca ``curl`` para acessar os dados e usa a biblioteca ``jansson`` para codificar e decodificar o JSON. - -## Configurando o libbitcoinrpc - -Para usar o ``libbitcoinrpc``, precisaremos instalar uma configuração básica C e os pacotes dependentes, que são ``libcurl``, ``libjansson``, e ``libuuid``. Depois faremos isso no seu servidor Standup Bitcoin (ou em qualquer outro servidor Ubuntu). - -``` -$ sudo apt-get install make gcc libcurl4-openssl-dev libjansson-dev uuid-dev -Suggested packages: - libcurl4-doc libidn11-dev libkrb5-dev libldap2-dev librtmp-dev libssh2-1-dev -The following NEW packages will be installed: - libcurl4-openssl-dev libjansson-dev uuid-dev -0 upgraded, 3 newly installed, 0 to remove and 4 not upgraded. -Need to get 358 kB of archives. -After this operation, 1.696 kB of additional disk space will be used. -Do you want to continue? [Y/n] y -``` -Agora, podemos baixar o [libbitcoinrpc no github](https://github.com/gitmarek/libbitcoinrpc/blob/master/readme.md). Vamos clonar ou pegar um arquivo zip, do jeito que preferir. - -``` -$ sudo apt-get install git -$ 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. - -Antes de compilarmos e instalarmos o pacote, provavelmente precisaremos ajustar nosso ``$PATH``, para que possamos acessar o ``/sbin/ldconfig``: -``` -$ PATH="/sbin:$PATH" -``` - -Para o Ubuntu, também precisaremos ajustar o ``install_libpath`` no ``makefile`` do ``libbitcoinrpc`` para instalar no ``/usr/lib`` ao invés do ``/usr/local/lib``: - -``` -$ emacs ~/libbitcoinrpc/Makefile -... -INSTALL_LIBPATH := $(INSTALL_PREFIX)/usr/lib -``` - -(Se preferir não usar o ``/usr/lib``, precisará alterar o ``etc/ld.so.conf`` ou os arquivos dependentes de maneira apropriada... Porém, para uma configuração de teste em uma máquina de teste, acredito que isso não seja um problema). - -Da mesma forma, vamos precisar ajustar o ``install_headerpath`` no ``Makefile`` do ``libbitcoinrpc`` para instalar no caminho ``/usr/include`` ao invés do ``/usr/local/inclusve``: - -``` -... -INSTALL_HEADERPATH := $(INSTALL_PREFIX)/usr/include -``` - -Agora, podemos compilar: -``` -$ cd libbitcoinrpc -~/libbitcoinrpc$ make - -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_err.o -c src/bitcoinrpc_err.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_global.o -c src/bitcoinrpc_global.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc.o -c src/bitcoinrpc.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_resp.o -c src/bitcoinrpc_resp.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_cl.o -c src/bitcoinrpc_cl.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -o src/bitcoinrpc_method.o -c src/bitcoinrpc_method.c -gcc -fPIC -O3 -g -Wall -Werror -Wextra -std=c99 -D VERSION=\"0.2\" -shared -Wl,-soname,libbitcoinrpc.so.0 \ -src/bitcoinrpc_err.o src/bitcoinrpc_global.o src/bitcoinrpc.o src/bitcoinrpc_resp.o src/bitcoinrpc_cl.o src/bitcoinrpc_method.o \ --o .lib/libbitcoinrpc.so.0.2 \ --Wl,--copy-dt-needed-entries -luuid -ljansson -lcurl -ldconfig -v -n .lib -.lib: - libbitcoinrpc.so.0 -> libbitcoinrpc.so.0.2 (changed) -ln -fs libbitcoinrpc.so.0 .lib/libbitcoinrpc.so -``` -Se tudo correr bem, podemos instalar o pacote: -``` -$ sudo make install -Installing to -install .lib/libbitcoinrpc.so.0.2 /usr/local/lib -ldconfig -n /usr/local/lib -ln -fs libbitcoinrpc.so.0 /usr/local/lib/libbitcoinrpc.so -install -m 644 src/bitcoinrpc.h /usr/local/include -Installing docs to /usr/share/doc/bitcoinrpc -mkdir -p /usr/share/doc/bitcoinrpc -install -m 644 doc/*.md /usr/share/doc/bitcoinrpc -install -m 644 CREDITS /usr/share/doc/bitcoinrpc -install -m 644 LICENSE /usr/share/doc/bitcoinrpc -install -m 644 Changelog.md /usr/share/doc/bitcoinrpc -Installing man pages -install -m 644 doc/man3/bitcoinrpc*.gz /usr/local/man/man3 -``` - -## 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. - -Para usar o ``libbitcoinrpc``, é importante certificar de que nossos arquivos do código incluam os cabeçalhos apropriados: -``` c -#include -#include -``` - -Precisaremos também vincular as bibliotecas apropriadas sempre que possamos compilar: - -``` -$ cc yourcode.c -lbitcoinrpc -ljansson -o yourcode -``` - -## Construindo a conexão - -Para construir a conexão com o servidor ``bitcoind`` é necessário alguns simples passos. - -Primeiro, inicialize a biblioteca: -``` -bitcoinrpc_global_init(); -``` -Em seguida, vamos conectar ao ``Bitcoind`` com ``bitcoinrpc_cl_init_params``. Os quatro argumentos necessários para o ``bitcoinrpc_cl_init_params`` são o nome de usuário, a senha, o endereço IP e a porta. A esta altura, você deve saber todas essas informações, já que foram necessárias para realizar o trabalho com o [curl](04_4__interlude_using_curl.md). Apenas para recordar, o endereço de IP é 127.0.0.1 e a porta 18332 devem estar corretos para a configuração padrão da testenet descrita neste documento, enquanto podemos encontrar o usuário e a senha no arquivo ``~/.bitcoin/bitcoin.conf``. -``` -$ cat bitcoin.conf -server=1 -dbcache=1536 -par=1 -maxuploadtarget=137 -maxconnections=16 -rpcuser=StandUp -rpcpassword=6305f1b2dbb3bc5a16cd0f4aac7e1eba -rpcallowip=127.0.0.1 -debug=tor -prune=550 -testnet=1 -[test] -rpcbind=127.0.0.1 -rpcport=18332 -[main] -rpcbind=127.0.0.1 -rpcport=8332 -[regtest] -rpcbind=127.0.0.1 -rpcport=18443 -``` -Com essas informações, vamos colocá-las no ``bitcoinrpc_cl_init_params``: -``` c -bitcoinrpc_cl_t *rpc_client; -rpc_client = bitcoinrpc_cl_init_params("StandUp", "6305f1b2dbb3bc5a16cd0f4aac7e1eba", "127.0.0.1", 18332); -``` - -> **MAINNET VS TESTNET:** A porta seria a 8332 caso estivéssemos usando a configuração da rede principal. - -Se o ``rpc_client`` for inicializado com sucesso, poderemos enviar os comandos do RPC. - -Mais tarde, quando tivermos feito com a conexão de ``bitcoind``, poderemos fechar da seguinte maneira: -``` c -bitcoinrpc_global_cleanup(); -``` - -### 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). - -Podemos compilar e executar o código da seguinte maneira: -``` -$ cc testbitcoin.c -lbitcoinrpc -ljansson -o testbitcoin -$ ./testbitcoin -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 - -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 -bitcoinrpc_method_t *getmininginfo = NULL; -getmininginfo = bitcoinrpc_method_init(BITCOINRPC_METHOD_GETMININGINFO); -``` -Normalmente definiríamos os parâmetros em seguida, mas o ``GetMiningInfo`` não requer parâmetros, por isso podemos pular essa parte. - -Também devemos criar outros dois objetos, um "objeto de resposta" e um "objeto de erro". Eles podem ser inicializados da seguinte forma: -``` c -bitcoinrpc_resp_t *btcresponse = NULL; -btcresponse = bitcoinrpc_resp_init(); - -bitcoinrpc_err_t btcerror; -``` -Vamos usar a variável ``rpc_client`` que aprendemos no teste anterior e vamos adicionar nosso método ``getmininginfo`` e os outros dois objetos: -``` c -bitcoinrpc_call(rpc_client, getmininginfo, btcresponse, &btcerror); -``` - -### 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 -json_t *jsonresponse = NULL; -jsonresponse = bitcoinrpc_resp_get(btcresponse); -``` -Se quisermos gerar os resultados completos da chamada RPC no JSON, podemos fazer com uma simples invocação do ``json_dumps``, da biblioteca ``jansson``: -``` c -printf("%s\n", json_dumps(j, JSON_INDENT(2))); -``` -No entanto, como agora estamos escrevendo programas completos, provavelmente iremos querer fazer um trabalho mais sutil, como retirar valores individuais do JSON para algum uso específico. A [Referência do Jansson](https6//jansson.readthedocs.Io/en/2.10/apiref.html) traz detalhes de como fazer. - -Assim como estávamos usando o [curl](04_4__interlude_using_curl.md), descobrimos que o RPC retorna um objeto JSON contendo um ``ID``, um ``error`` e, mais importante, um objeto JSON do tipo ``result``. - -A função ``json_object_get`` permite recuperar um valor (como o ``result``) de um objeto JSON usando chaves: -``` c -json_t *jsonresult = NULL; -jsonresult = json_object_get(jsonresponse,"result"); -printf("%s\n", json_dumps(jsonresult, JSON_INDENT(2))); -``` - -No entanto, provavelmente iremos querer analisar informações ainda mais profundas, para obter uma variável específica. Depois de recuperar o valor apropriado, precisaremos convertê-lo em um objeto C padrão usando a função ``JSON_*_value``. Por exemplo, para acessar um integer usamos o ``json_integer_value``: -``` c -json_t *jsonblocks = NULL; -jsonblocks = json_object_get(jsonresult,"blocks"); - -int blocks; -blocks = json_integer_value(jsonblocks); -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 - -Vamos recuperar o código de teste que está no [diretório src](15_1_GetMiningInfo.c). -``` -$ cc getmininginfo.c -lbitcoinrpc -ljansson -o getmininginfo -$ ./getmininginfo -Full Response: { - "result": { - "blocks": 1804406, - "difficulty": 4194304, - "networkhashps": 54842097951591.781, - "pooledtx": 127, - "chain": "test", - "warnings": "Warning: unknown new rules activated (versionbit 28)" - }, - "error": null, - "id": "474ccddd-ef8c-4e3f-93f7-fde72fc08154" -} - -Just the Result: { - "blocks": 1804406, - "difficulty": 4194304, - "networkhashps": 54842097951591.781, - "pooledtx": 127, - "chain": "test", - "warnings": "Warning: unknown new rules activated (versionbit 28)" -} - -Block Count: 1804406 -``` - -## Fazendo uma chamada RPC usando argumentos - -Mas e se a sua chamada RPC tiver argumentos? - -### 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. - -Vamos criar a matriz JSON usando a função ``json_array do`` do ``jansson``: -``` c -json_t *params = NULL; -params = json_array(); -``` -Vamos fazer o processo inverso que fizemos para acessar valores do JSON: Vamos converter objetos no C para objetos no JSON usando as funções ``JSON_*``. Depois, vamos anexar tudo à matriz: -``` c -json_array_append_new(params,json_string(tx_rawhex)); -``` - -Observe que existem duas variantes para o comando de anexação: ``json_array_apend_new``, que acrescenta uma variável recém-criada, e ``json_array_apend``, que anexa uma variável existente. - -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 - -Quando criamos o parâmetro array no JSON, simplesmente o atribuímos depois de inicializar o método RPC, da seguinte maneira: -``` c -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 - -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. - -## 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). diff --git a/pt/15_2_Programming_Bitcoind_with_C.md b/pt/15_2_Programming_Bitcoind_with_C.md deleted file mode 100644 index c1fdc38..0000000 --- a/pt/15_2_Programming_Bitcoind_with_C.md +++ /dev/null @@ -1,354 +0,0 @@ - -# 15.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. - -## 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: - - 1. Solicitar um endereço e uma quantia; - 2. Definir uma taxa arbitrária; - 3. Preparar nosso RPC; - 4. Encontrar um UTXO que seja grande o suficiente para pagar o valor + a taxa; - 5. Criar uma mudança de endereço; - 6. Criar uma transação bruta que envie o UTXO para o endereço e altere o endereço; - 7. Assinar a transação; - 8. Enviar a transação. - -### 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: - - 1. Testar e/ou higienizar as entradas; - 2. Calcular uma taxa automaticamente; - 3. Pensar logicamente sobre qual UTXO seria válido utilizar; - 4. Combinar vários UTXOs, caso seja necessário; - 5. Ficar atento a mais erros nos comandos ``libbitcoinrpc`` ou no ``jansson``; - 6. Observar se há erros nas respostas RPC. - -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 - -Agora estamos prontos para realizar o passo a passo do nosso plano - -### Etapa 1: Solicitando um endereço e uma quantia - -Inserir as informações é bem simples se usarmos os argumentos na linha de comando: -``` c -if(argc != 3) { - - printf("ERROR: Only %i arguments! Correct usage is '%s [recipient] [amount]'\n",argc-1,argv[0]); - exit(-1); - -} - -char *tx_recipient = argv[1]; -float tx_amount = atof(argv[2]); - -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 - -Este exemplo colocamos uma taxa arbitrária de 0.0005 BTC para garantir que as transações do teste sejam processadas rapidamente: - -``` c -float tx_fee = 0.0005; -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 - -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: -``` c -bitcoinrpc_global_init(); -rpc_client = bitcoinrpc_cl_init_params("bitcoinrpc", "YOUR-RPC-PASSWD", "127.0.0.1", 18332); -btcresponse = bitcoinrpc_resp_init(); -``` - -### Etapa 4: Encontrando um UTXO - -Para encontrar um UTXO, precisaremos chamar a função RPC ``listunspent``: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_LISTUNSPENT); -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); -``` - -No entanto, o verdadeiro trabalho consiste em decodificar a resposta. Na seção anterior vimos que a biblioteca ``jansson`` era "um tanto quanto desajeitada" e esta é a razão: Precisamos criar (e limpar) um conjunto muito grande de objetos ``json_t`` para descobrir o que queremos. - -Primeiro, precisamos nos recuperar o campo ``result`` do JSON: -``` c -json_t *lu_response = NULL; -json_t *lu_result = NULL; - -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); -``` - -> :warning: **ATENÇÃO:** Só obteremos um resultado se não houver nenhum erro. Aqui temos um momento para melhorar nossa verificação de erros no código que iremos colocar em produção. - -Em seguida, vamos fazer um laço, examinando cada transação que não foi gasta, que aparece como um elemento em sua matriz do resultado JSON: -``` c -int i; - -const char *tx_id = 0; -int tx_vout = 0; -double tx_value = 0.0; - -for(i = 0 ; i < json_array_size(lu_result) ; i++) { - - json_t *lu_data = NULL; - lu_data = json_array_get(lu_result, i); - - json_t *lu_value = NULL; - lu_value = json_object_get(lu_data,"amount"); - tx_value = json_real_value(lu_value); -``` - -O UTXO é grande o suficiente para pagar sua transação? Se sim, pegue-o! - -> :warning: **ATENÇÃO:** Um programa em produção pensaria com mais cuidado sobre qual UTXO utilizar, com base no tamanho e em outros fatores. Provavelmente não pegaria apenas o primeiro mais simples e pronto. - -``` c - if(tx_value > tx_total) { - - json_t *lu_txid = NULL; - lu_txid = json_object_get(lu_data,"txid"); - tx_id = strdup(json_string_value(lu_txid)); - - json_t *lu_vout = NULL; - lu_vout = json_object_get(lu_data,"vout"); - tx_vout = json_integer_value(lu_vout); - - json_decref(lu_value); - json_decref(lu_txid); - json_decref(lu_vout); - json_decref(lu_data); - break; - - } -``` -Você também deve limpar os principais elementos do JSON: -``` c -} - -json_decref(lu_result); -json_decref(lu_response); -``` - -> :warning: **ATENÇÃO:** Um programa em produção também se certificaria de que os UTXOs são passíveis de serem `gastos`. - -Se não encontramos nenhum UTXOs grande o suficiente, teremos que relatar este infortúnio ao usuário... E talvez, sugerir que ele deva usar um programa melhor, que irá mesclar os UTXOs de maneira correta. -``` c -if(!tx_id) { - - printf("Very Sad: You don't have any UTXOs larger than %f\n",tx_total); - exit(-1); -} -``` - -> **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 - -Repita a metodologia padrão de pesquisa RPC para obter um endereço de troco: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_GETRAWCHANGEADDRESS); - -if(!rpc_method) { - - printf("ERROR: Unable to initialize listunspent method!\n"); - exit(-1); - -} - -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); - -if(btcerror.code != BITCOINRPCE_OK) { - -printf("Error: listunspent error code %d [%s]\n", btcerror.code,btcerror.msg); - - exit(-1); - -} - -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); -char *changeaddress = strdup(json_string_value(lu_result)); -``` -A única diferença é quais informações específicas são extraídas do objeto JSON. - -> :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 - -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. - -Para criarmos esses parâmetros corretamente, precisaremos revisar o que o RPC ``createrawtransaction`` espera que passemos como argumento. Felizmente, isso é fácil de determinar usando a funcionalidade ``bitcoin-cli help``: -``` -$ bitcoin-cli help createrawtransaction -createrawtransaction [{"txid":"id","vout":n},...] {"address":amount,"data":"hex",...} ( locktime ) -``` - -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 - -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 -json_t *inputtxid = NULL; -inputtxid = json_object(); - -json_object_set_new(inputtxid,"txid",json_string(tx_id)); -json_object_set_new(inputtxid,"vout",json_integer(tx_vout)); -``` - -Pode-se notar que teremos que traduzir novamente cada tipo de variável C em um tipo de variável JSON usando a função apropriada, como ``json_string`` ou ``json_integer``. - -Para criar o array de entrada para todos os UTXOs, vamos usar o ``json_array`` e, em seguida, preenchê-lo com os objetos usando o ``json_array_append``: -``` c -json_t *inputparams = NULL; -inputparams = json_array(); -json_array_append(inputparams,inputtxid); -``` - -#### 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 -json_t *outputparams = NULL; -outputparams = json_object(); - -char tx_amount_string[32]; -sprintf(tx_amount_string,"%.8f",tx_amount); -char tx_change_string[32]; -sprintf(tx_change_string,"%.8f",tx_value - tx_total); - -json_object_set(outputparams, tx_recipient, json_string(tx_amount_string)); -json_object_set(outputparams, changeaddress, json_string(tx_change_string)); -``` - -> :warning: **ATENÇÃO:** É possível pensar que teremos que inserir os valores do Bitcoin como sendo números, usando a função ``json_real``. Infelizmente, isso expõe um dos maiores problemas com a integração da biblioteca ``jansson`` e o Bitcoin. O Bitcoin só é válido até oito dígitos depois da casa decimal. Devemos nos lembrar que 0,00000001 BTC é um satoshi, e essa é a menor divisão possível de um Bitcoin. O tipo ``double`` no C oferecem mais dígitos do que precisamos, embora sejam frequentemente imprecisos depois das oito casas decimais. Se tentarmos convertê-los diretamente do nosso valor ``double`` no C (ou de um tipo ``float``, neste caso) para um valor Bitcoin, a imprecisão frequentemente criará um valor Bitcoin com mais de oito dígitos. Antes da versão Bitcoin Core 0.12, isso não era problema, e podíamos usar a função ``json_real``. Mas à partir dessa versão, se tentarmos usar a função ``createrawtransaction`` com mais do que oito dígitos, obteremos um erro e a transação não será criada. Como resultado, se o valor do Bitcoin _sempre_ se tornar um ``double`` ou ``float``, devemos deixar com apenas oito casas decimais antes de transformá-lo em uma ``string``. Obviamente, isso é um erro, portanto, certifique-se disso para que o código continue funcionando nas versões mais novas do Bitcoin Core. - -#### Etapa 6.3: Criando a Matriz de Parâmetros - -Para terminarmos de criar os parâmetros, só precisaremos agrupá-los em uma matriz JSON: -``` c -json_t *params = NULL; -params = json_array(); -json_array_append(params,inputparams); -json_array_append(params,outputparams); -``` - -#### Etapa 6.4: Fazendo a chamada ao RPC - -Vamos usar o método normal para criar uma chamada ao RPC: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_CREATERAWTRANSACTION); -``` -Agora, porém, devemos adicionar os nossos parâmetros. Isso pode ser feito facilmente com a função ``bitcoinrpc_method_set_params``: -``` c -if(bitcoinrpc_method_set_params(rpc_method, params) != BITCOINRPCE_OK) { - - fprintf(stderr, "Error: Could not set params for createrawtransaction"); - -} -``` -Depois, é só executar o RPC e obter os resultados: -``` c -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); - -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); - -char *tx_rawhex = strdup(json_string_value(lu_result)); -``` -### 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 -params = json_array(); -json_array_append_new(params,json_string(tx_rawhex)); -``` -Por fim, vamos assinar a transação seguindo o rigamarole típico para criar uma chamada RPC: -``` c -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_SIGNRAWTRANSACTION); -if(bitcoinrpc_method_set_params(rpc_method, params) != BITCOINRPCE_OK) { - - fprintf(stderr, "Error: Could not set params for signrawtransaction"); - -} - -json_decref(params); - -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); -lu_response = bitcoinrpc_resp_get(btcresponse); -``` -Novamente, usar a função ``jansson`` para acessar a saída pode ser complicado. Devemos lembrar que ``hex`` é parte de um objeto JSON, não um resultado independente, como era quando criamos a transação bruta. Claro, sempre podemos acessar essas informações a partir da ajuda da linha de comando: ``bitcoin-cli help signrawtransaction`` -``` c -lu_result = json_object_get(lu_response,"result"); -json_t *lu_signature = json_object_get(lu_result,"hex"); -char *tx_signrawhex = strdup(json_string_value(lu_signature)); -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 - -Agora podemos enviar a transação, usando todas as técnicas aprendidas anteriormente: -``` c -params = json_array(); -json_array_append_new(params,json_string(tx_signrawhex)); - -rpc_method = bitcoinrpc_method_init(BITCOINRPC_METHOD_SENDRAWTRANSACTION); - -if(bitcoinrpc_method_set_params(rpc_method, params) != BITCOINRPCE_OK) { - - fprintf(stderr, "Error: Could not set params for sendrawtransaction"); - -} - -json_decref(params); - -bitcoinrpc_call(rpc_client, rpc_method, btcresponse, &btcerror); -lu_response = bitcoinrpc_resp_get(btcresponse); -lu_result = json_object_get(lu_response,"result"); - -char *tx_newid = strdup(json_string_value(lu_result)); - -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 - -O código completo pode ser encontrado no [diretório src/](src/15_2_sendtoaddress.c). - -Compile-o como de costume: -``` -$ cc sendtoaddress.c -lbitcoinrpc -ljansson -o sendtoaddress -``` -Agora, é possível utilizá-lo para enviar fundos para um endereço: - -``` -./sendtoaddress tb1qynx7f8ulv4sxj3zw5gqpe56wxleh5dp9kts7ns .001 -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 - -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). \ No newline at end of file diff --git a/pt/15_3_Receiving_Bitcoind_Notifications_with_C.md b/pt/15_3_Receiving_Bitcoind_Notifications_with_C.md deleted file mode 100644 index fe166ac..0000000 --- a/pt/15_3_Receiving_Bitcoind_Notifications_with_C.md +++ /dev/null @@ -1,155 +0,0 @@ - -# 15.3 Recebendo notificações usando C com a biblioteca 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. - -> :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). - -## Configurando o ZMQ - -Antes de podemos ouvir a blockchain, precisaremos configurar o ``bitcoind`` para permitir as notificações ZMQ. Por isso, precisamos instalar a biblioteca ZMQ para tirar proveito dessas notificações. - -### Configurando o ``bitcoind`` para usar o ZMQ - -O Bitcoin Core está pronto para ZMQ, mas devemos especificar os endpoints do ZMQ. O ZeroMQ publish-sockets prefixa cada item de dados com um prefixo de tópico arbitrário que permite aos clientes assinantes solicitarem apenas os itens com um prefixo correspondente. Existem atualmente quatro tópicos suportados pelo ``bitcoind``: -``` -$ bitcoind --help | grep zmq | grep address - -zmqpubhashblock=
- -zmqpubhashtx=
- -zmqpubrawblock=
- -zmqpubrawtx=
-``` - -Podemos executar o ``bitcoind`` com argumentos de linha de comando para endpoints ZMQ, como mostrado acima, mas também podemos criar um endpoint acessível adicionando linhas apropriadas ao nosso arquivo ``~/.bitcoin/bitcoin.conf`` e reiniciando o sistema. - -``` -zmqpubrawblock=tcp://127.0.0.1:28332 -zmqpubrawtx=tcp://127.0.0.1:28333 -``` -Podemos então testar se os nossos endpoints estão funcionando usando o RPC ``getzmqnotifications``: - -``` -$ bitcoin-cli getzmqnotifications -[ - { - "type": "pubrawblock", - "address": "tcp://127.0.0.1:28332", - "hwm": 1000 - }, - { - "type": "pubrawtx", - "address": "tcp://127.0.0.1:28333", - "hwm": 1000 - } -] -``` -Nosso ``bitcoind`` agora irá emitir as notificações ZMQ - -### Instalando o ZMQ - -Para aproveitar essas notificações, precisamos de uma biblioteca ZMQ para usar com o C, portanto, estaremos usando uma nova biblioteca ZMQ ao invés da biblioteca ``libbitcoinrpc`` nesta seção, mas no futuro, podemos combinar ambas. - -Felizmente, as bibliotecas ZMQ estão disponíveis por meio de pacotes Debian padrão: -``` -$ sudo apt-get install libzmq3-dev -$ sudo apt-get install libczmq-dev -``` -Agora estamos pronto para escrever o código! - -## 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. - -O programa requer dois parâmetros: O primeiro é o "servidor", que é o ponto de conexão TCP exposto pelo ``bitcoind``. O segundo é o "tópico", que atualmente é o ``zmqpubhashblock``,``zmqpubhashtx``, ``zmqpubrawblock`` ou ``zmqpubrawtx``. O tópico precisa ter suporte do ``bitcoin.conf`` e o endereço IP e a porta do servidor devem corresponder ao que está definido no arquivo de configuração. - -``` c -#include -int main(int argc, char ** argv) { - - char *zmqserver; - char *topic; - - if(argc < 3) { - printf("\nUSAGE:\nchainlistener \n\n"); - return 0; - } else { - zmqserver = argv[1]; - topic = argv[2]; - } -``` -Abriremos um soquete ZMQ para o servidor e para o tópico definido: -``` c - zsock_t *socket = zsock_new_sub(zmqserver, topic); - assert(socket); -``` -Depois, vamos esperar: -``` c - while(1) { - zmsg_t *msg; - int rc = zsock_recv(socket, "m", &msg); - assert(rc == 0); - - char *header = zmsg_popstr(msg); - zframe_t *zdata = zmsg_pop(msg); - unsigned int *no = (unsigned int*)zmsg_popstr(msg); - - char *data = zframe_strhex(zdata); - int len = zframe_size(zdata); - printf("Size: %d\n", len); - printf("Data: %s", data); - printf("\nNo: %d\n", *no); - - free(header); - free(data); - free(no); - free(zdata); - zmsg_destroy(&msg); - sleep(1); - } -``` -Enquanto esperamos, observamos as mensagens no soquete ZMQ. Sempre que recebermos uma mensagem, iremos retirá-la da pilha, relatando o número, comprimento e, o os dados que foram importante para nós. - -É isso! - -Claro, quando terminar o processo, precisamos limpar tudo: -``` c - zsock_destroy(&socket); - return 0; -} -``` - -### 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: -``` -$ cc -o chainlistener chainlistener.c -I/usr/local/include -L/usr/local/lib -lzmq -lczmq -``` -Depois, podemos executá-lo com os tópicos e endereços que definimos no nosso ``bitcoin.conf``: -``` -$ ./chainlistener tcp://127.0.0.1:28333 rawtx -Size: 250 -Data: 02000000000101F5BD2032E5A9E6650D4E411AD272E391F26AFC3C9102B7C0C7444F8F74AE86010000000017160014AE9D51ADEEE8F46ED2017F41CD631D210F2ED9C5FEFFFFFF0203A732000000000017A9147231060F1CDF34B522E9DB650F44EDC6C0714E4C8710270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC02483045022100AE316D5F21657E3525271DE39EB285D8A0E89A20AB6413824E88CE47DCD0EFE702202F61E10C2A8F4A7125D5EB63AEF883D8E3584A0ECED0D349283AABB6CA5E066D0121035A77FE575A9005E3D3FF0682E189E753E82FA8BFF0A20F8C45F06DC6EBE3421079111B00 -No: 67 -Size: 249 -Data: 0200000000010165C986992F7DAD22BBCE3FCF0BF546EDBC3C599618B04CFA22D9E64EF0CE4C030000000017160014B58E0A5CD68B249F1C407E9AAE9CD0332AAA3067FEFFFFFF02637932000000000017A914CCC47261489036CB6B9AA610857793FF5752E5378710270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC0247304402206CCC3F3B4BE01D4E532A01C2DC6BC3B53E4FFB6B494C8B87DD603EFC648A159902201653841E8B16A814DC375129189BB7CF01CFF7D269E91178645B6A97F5C7F4F10121030E20F3D2F172281B8DC747F007DF24B352248AC09E48CA64016942A8F01D317079111B00 -No: 68 -Size: 250 -Data: 02000000000101E889CFC1FFE127BA49F6C1011388606A194109AE1EDAAB9BEE215E123C14A7920000000017160014577B0B3C2BF91B33B5BD70AE9E8BD8144F4B87E7FEFFFFFF02C34B32000000000017A914A9F1440402B46235822639C4FD2F78A31E8D269E8710270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC02483045022100B46318F53E1DCE63E7109DB4FA54AF40AADFC2FEB0E08263756BC3B7A6A744CB02200851982AF87DBABDC3DFC3362016ECE96AECFF50E24D9DCF264AE8966A5646FE0121039C90FCB46AEA1530E5667F8FF15CB36169D2AD81247472F236E3A3022F39917079111B00 -No: 69 -Size: 250 -Data: 0200000000010137527957C9AD6CFF0C9A74597E6EFCD7E1EBD53E942AB2FA34A831046CA11488000000001716001429BFF05B3CD79E9CCEFDB5AE82139F72EB3E9DB0FEFFFFFF0210270000000000001976A914262437B129CF8592AB2EDC59C07D19C57729F72888AC231E32000000000017A9146C8D5FE29BFDDABCED0D6F4D8E82DCBFD9D34A8B8702483045022100F259846BAE29EB2C7A4AD711A3BC6109DE69AE91E35B14CA2742157894DD9760022021464E09C00ABA486AEAA0C49FEE12D2850DC03F57F04A1A9E2CC4D0F4F1459C012102899F24A9D60132F4DD1A5BA6DCD1E4E4B6C728927BA482C2C4E511679F60CA5779111B00 -No: 70 -....... -``` - -### Resumo do capítulo Recebendo Notificações Usando C com a Biblioteca 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. - -> :fire: ***Qual é o poder das notificações?*** Com as notificações, não dependemos mais dos usuários para emitir os comandos. Ou seja, podemos criar programas que monitoram o blockchain do Bitcoin e tomar as ações apropriadas quando certas coisas ocorrem. Isso, por sua vez, pode ser utilizado juntamente com os comandos RPC que programamos nas seções anteriores. Este também é um grande passo além do que poderíamos fazer com os scripts shell: Certamente, podemos criar scripts shell que fica ouvindo infinitamente, mas existem outras linguagens de programação que possuem ferramentas melhores para isso. - -## 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). \ No newline at end of file From cfa1479e00bfdf82cfd237f32f26670f7786636a Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 16:16:57 -0300 Subject: [PATCH 3/8] Rename chapter 18 to 19 files --- ...htning_Setup.md => 19_0_Understanding_Your_Lightning_Setup.md} | 0 ..._Lightning_Setup.md => 19_1_Verifying_Your_Lightning_Setup.md} | 0 ...ur_lightning_Setup.md => 19_2_Knowing_Your_lightning_Setup.md} | 0 ...de.md => 19_2__Interlude_Accessing_a_Second_Lightning_Node.md} | 0 pt/{18_3_Setting_Up_a_Channel.md => 19_3_Setting_Up_a_Channel.md} | 0 5 files changed, 0 insertions(+), 0 deletions(-) rename pt/{18_0_Understanding_Your_Lightning_Setup.md => 19_0_Understanding_Your_Lightning_Setup.md} (100%) rename pt/{18_1_Verifying_Your_Lightning_Setup.md => 19_1_Verifying_Your_Lightning_Setup.md} (100%) rename pt/{18_2_Knowing_Your_lightning_Setup.md => 19_2_Knowing_Your_lightning_Setup.md} (100%) rename pt/{18_2__Interlude_Accessing_a_Second_Lightning_Node.md => 19_2__Interlude_Accessing_a_Second_Lightning_Node.md} (100%) rename pt/{18_3_Setting_Up_a_Channel.md => 19_3_Setting_Up_a_Channel.md} (100%) diff --git a/pt/18_0_Understanding_Your_Lightning_Setup.md b/pt/19_0_Understanding_Your_Lightning_Setup.md similarity index 100% rename from pt/18_0_Understanding_Your_Lightning_Setup.md rename to pt/19_0_Understanding_Your_Lightning_Setup.md diff --git a/pt/18_1_Verifying_Your_Lightning_Setup.md b/pt/19_1_Verifying_Your_Lightning_Setup.md similarity index 100% rename from pt/18_1_Verifying_Your_Lightning_Setup.md rename to pt/19_1_Verifying_Your_Lightning_Setup.md diff --git a/pt/18_2_Knowing_Your_lightning_Setup.md b/pt/19_2_Knowing_Your_lightning_Setup.md similarity index 100% rename from pt/18_2_Knowing_Your_lightning_Setup.md rename to pt/19_2_Knowing_Your_lightning_Setup.md diff --git a/pt/18_2__Interlude_Accessing_a_Second_Lightning_Node.md b/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md similarity index 100% rename from pt/18_2__Interlude_Accessing_a_Second_Lightning_Node.md rename to pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md diff --git a/pt/18_3_Setting_Up_a_Channel.md b/pt/19_3_Setting_Up_a_Channel.md similarity index 100% rename from pt/18_3_Setting_Up_a_Channel.md rename to pt/19_3_Setting_Up_a_Channel.md From 485176ee596bd4087ad990db1a3862d9f7e7ce4b Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 16:24:10 -0300 Subject: [PATCH 4/8] Review 19_0 --- pt/19_0_Understanding_Your_Lightning_Setup.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/pt/19_0_Understanding_Your_Lightning_Setup.md b/pt/19_0_Understanding_Your_Lightning_Setup.md index 3a3a6bf..e02d6f6 100644 --- a/pt/19_0_Understanding_Your_Lightning_Setup.md +++ b/pt/19_0_Understanding_Your_Lightning_Setup.md @@ -1,15 +1,15 @@ -# Capítulo 18: Compreendendo a configuração da Lightning +# Capítulo 19: Compreendendo a 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. O capítulo anterior concluiu nosso trabalho com o Bitcoin propriamente dito, por meio do CLI, scripts e linguagens de programação. No entanto, existem muitos outros utilitários dentro do ecossistema Bitcoin. Neste capítulo e no próximo, iremos cobrir o que pode ser o maior e mais importante deles, a Lightning Network. Aqui, começaremos a trabalhar com a interface de linha de comando `lightning-cli`, entendendo a configuração do c-lightning e dos seus recursos, incluindo alguns exemplos e configuração básica. -## Objetivos deste capítulo +## Objetivos Deste Capítulo Depois de trabalhar neste capítulo, um desenvolvedor será capaz de: * Avaliar se um node c-lightning está instalado e atualizado; - * Executar comandos básicos de uma carteira Lightning ; + * Executar comandos básicos de uma carteira Lightning; * Criar um canal na Lightning. Os objetivos secundários do capítulo incluem a capacidade de: @@ -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 do c-lightning](18_1_Verifying_Your_Lightning_Setup.md) -* [Seção 2: Conhecendo a configuração do c-lightning](18_2_Knowing_Your_lightning_Setup.md) - * [Adendo: Acessando um segundo node Lightning](18_2__Interlude_Accessing_a_Second_Lightning_Node.md) -* [Seção 3: Criando um canal na Lightning](18_3_Setting_Up_a_Channel.md) \ No newline at end of file +* [Seção 1: Verificando a Configuração do c-lightning](19_1_Verifying_Your_Lightning_Setup.md) +* [Seção 2: Conhecendo a Configuração do 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) \ No newline at end of file From 851d2a74d492883b64d393ab4dbaca1427e98329 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 16:49:07 -0300 Subject: [PATCH 5/8] Review 19_1 --- pt/19_0_Understanding_Your_Lightning_Setup.md | 4 +- pt/19_1_Verifying_Your_Lightning_Setup.md | 72 +++++++++---------- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/pt/19_0_Understanding_Your_Lightning_Setup.md b/pt/19_0_Understanding_Your_Lightning_Setup.md index e02d6f6..279604f 100644 --- a/pt/19_0_Understanding_Your_Lightning_Setup.md +++ b/pt/19_0_Understanding_Your_Lightning_Setup.md @@ -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 do c-lightning](19_1_Verifying_Your_Lightning_Setup.md) -* [Seção 2: Conhecendo a Configuração do c-lightning](19_2_Knowing_Your_lightning_Setup.md) +* [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) * [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) \ No newline at end of file diff --git a/pt/19_1_Verifying_Your_Lightning_Setup.md b/pt/19_1_Verifying_Your_Lightning_Setup.md index 5d3cb0c..cbf3844 100644 --- a/pt/19_1_Verifying_Your_Lightning_Setup.md +++ b/pt/19_1_Verifying_Your_Lightning_Setup.md @@ -1,16 +1,16 @@ -# 18.1: Verificando a configuração do c-lightning +# 19.1: Verificando a 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. +>: information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. -Nesta seção, instalaremos e verificaremos o c-lightning, nosso utilitário para acessar a Lightning Network. +Nesta seção, instalaremos e verificaremos a c-lightning, nosso utilitário para acessar a Lightning Network. -> :book: ***O que é a Lightning Network?*** A Rede Lightning é uma rede descentralizada que usa a funcionalidade de contrato inteligente da blockchain do Bitcoin para permitir pagamentos instantâneos em uma rede de participantes. A Lightning é construída como um protocolo de segunda camada que interage com o Bitcoin para permitir que os usuários troquem seus bitcoins "fora da blockchain (ou como muitos falam, offchain)". +> :book: ***O que é a Lightning Network?*** A Rede Lightning é uma rede descentralizada que usa a funcionalidade de contrato inteligente da blockchain do Bitcoin para permitir pagamentos instantâneos em uma rede de participantes. A Lightning é construída como um protocolo de segunda camada que interage com o Bitcoin para permitir que os usuários troquem seus bitcoins "fora da blockchain" (ou o jargão em inglês, "off-chain"). -> :book: ***O que é um protocolo de segunda camada?*** A segunda camada refere-se a um protocolo secundário criado em cima do sistema de blockchain do Bitcoin. O objetivo principal desses protocolos é resolver a velocidade de transação e as dificuldades de escala que estão presentes no Bitcoin. O Bitcoin não é capaz de processar milhares de transações por segundo (TPS), então protocolos de segunda camada foram criados para resolver o problema de escalabilidade da blockchain . Essas soluções também são conhecidas como soluções de dimensionamento "offchain". +> :book: ***O que é um protocolo de segunda camada?*** A segunda camada refere-se a um protocolo secundário criado em cima do sistema de blockchain do Bitcoin. O objetivo principal desses protocolos é resolver a velocidade de transação e as dificuldades de escala que estão presentes no Bitcoin. O Bitcoin não é capaz de processar milhares de transações por segundo (TPS), então protocolos de segunda camada foram criados para resolver o problema de escalabilidade da blockchain. Essas soluções também são conhecidas como soluções de dimensionamento "off-chain". -## Instalando o C-Lightning +## Instalando a c-lightning -Se já usamos os [Bitcoin Standup Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts), talvez já o tenhamos instalado no início deste curso. Podemos testar isso verificando se o `lightningd` está em execução: +Se já usamos os [Bitcoin Standup Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts), talvez já o tenhamos instalado no início deste curso. Podemos testar isto verificando se o `lightningd` está em execução: ``` $ ps auxww | grep -i lightning standup 31213 0.0 0.2 24144 10424 pts/0 S 15:38 0:00 lightningd --testnet @@ -25,17 +25,17 @@ standup 31228 0.0 0.2 23044 8192 pts/0 S 15:38 0:00 /usr/local/libe standup 31229 0.0 0.1 22860 7556 pts/0 S 15:38 0:00 /usr/local/libexec/c-lightning/lightning_gossipd standup 32072 0.0 0.0 6208 888 pts/0 S+ 15:50 0:00 grep -i lightning ``` -Caso contrário, precisaremos instalá-lo agora. Infelizmente, se estivermos usando o Debian, precisaremos instalá-lo manualmente, compilando o código-fonte, mas ainda assim deve ser muito simples se seguirmos estas instruções. Se acontecer de estarmos em um sistema Ubuntu padrão, podemos tentar [Instalar a partir do Ubuntu ppa](#variant-install-from-ubuntu-ppa), e sempre pode tentar [Instalar os binários pré-compilados](#variant-install- binários pré-compilados). +Caso contrário, precisaremos instalá-lo agora. Infelizmente, se estivermos usando o Debian, precisaremos instalá-lo manualmente, compilando o código-fonte, mas ainda assim deve ser muito simples se seguirmos estas instruções. Se acontecer de estarmos em um sistema Ubuntu padrão, podemos tentar [Instalar a partir do Ubuntu ppa](#variant-install-from-ubuntu-ppa), e sempre podemos tentar [Instalar os binários pré-compilados](#variant-install-pre-compiled-binaries). -> :book: ***O que é a c-lightning?*** Existem três implementações diferentes da Lightning no momento: C-lightning, LND e Eclair. Todos devem ser funcionalmente compatíveis, com base nas mesmas [RFCs do BOLT](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), mas os detalhes de implementação podem ser diferentes. Escolhemos a c-lightning como base do curso porque ela também faz parte do mesmo [Elements Project](https://github.com/ElementsProject) que também contém a Libwally. +> :book: ***O que é a c-lightning?*** Existem três implementações diferentes da Lightning no momento: C-lightning, LND e Eclair. Todos devem ser funcionalmente compatíveis, com base nas mesmas [RFCs do BOLT](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), mas os detalhes de implementação podem ser diferentes. Escolhemos a c-lightning como base do curso porque ela também faz parte do [projeto Elements](https://github.com/ElementsProject), que contém a Libwally. -### Compilando o código-fonte da c-lightning +### Compilando o Código-Fonte da c-lightning A instalação da Lightning a partir do código-fonte deve ser bem simples se seguirmos estas instruções. -_Provavelmente_ desejaremos fazer isso em um node não prunado, pois trabalhar com nodes prunados na Lightning pode causar problemas de instalação e uso. Se configuramos nosso node no início deste curso para ser prunado, podemos querer substituí-lo por um full node agora. Se estivermos usando a testnet, devemos conseguir usar o mesmo tipo de máquina que usamos para o node prunado. +_Provavelmente_ desejaremos fazer isso em um node não prunado, pois trabalhar com nodes prunados na Lightning pode causar problemas de instalação e uso. Se, no início deste curso, configuramos nosso node para ser prunado, podemos querer substituí-lo por um full node agora. Se estivermos usando a testnet, provavelmente conseguiremos usar o mesmo tipo de máquina que usamos para o node prunado. -> :warning: **AVISO:** Realmente podemos executar o c-lightning em um node prunado. No entanto, conforme observamos no [repositório Lightning](https://github.com/ElementsProject/lightning#pruning), pode haver uma série de problemas. Para fazer isso funcionar, devemos garantir que o node da Lightning sempre tente atualizar informações sobre os blocos que o node do Bitcoin não excluiu. Para fazermos isso, devemos nos certificar de (1) que nosso node de Bitcoin está totalmente atualizado antes de iniciar nosso node da Lightning pela primeira vez e; (2) que nosso node Lightning nunca fique defasado do node do Bitcoin (para um node prunado em 550 blocos padrão, ele nunca pode ser desligado por 4 dias ou mais). Portanto, podemos usar o node assim, mas apresenta algum perigo, o que não é uma boa ideia se estivermos executando um serviço em produção. +> :warning: **AVISO:** Realmente podemos executar a c-lightning em um node prunado. No entanto, conforme observamos no [repositório Lightning](https://github.com/ElementsProject/lightning#pruning), pode haver uma série de problemas. Para fazer isso funcionar, devemos garantir que o node da Lightning sempre tente atualizar informações sobre os blocos que o node do Bitcoin não excluiu. Para fazermos isso, devemos nos certificar de que (1) nosso node de Bitcoin está totalmente atualizado antes de iniciar nosso node da Lightning pela primeira vez e; (2) nosso node Lightning nunca fique defasado do node do Bitcoin (para um node prunado em 550 blocos padrão, ele nunca pode ser desligado por 4 dias ou mais). Portanto, podemos usar o node assim, mas apresenta algum perigo, o que não é uma boa ideia se estivermos executando um serviço em produção. Dito isso, estamos prontos para instalar a Lightning: @@ -69,9 +69,9 @@ Depois disso, o que precisamos fazer é instalar: $ sudo make install ``` -## Verificando nossa instalação +## Verificando Nossa Instalação -Podemos confirmar que tudo foi instalado o lightningd corretamente usando o parâmetro `help`: +Podemos confirmar que o lightningd foi instalado corretamente usando o parâmetro `help`: ``` $ lightningd --help @@ -90,11 +90,11 @@ A bitcoin lightning daemon (default values shown for network: testnet). --mainnet Alias for --network=bitcoin ``` -## Executar a Lightningd +## Executando lightningd Começaremos a explorar a Lightning Network com o comando `lightning-cli`. No entanto, `lightningd` _deve_ estar rodando para podermos usar o `lightning-cli`, já que `lightning-cli` envia comandos JSON-RPC para o `lightningd` (tudo exatamente como o `bitcoin-cli` e o `bitcoind`). -Se instalamos o `c-lightning` manualmente, precisaremos iniciá-lo: +Se instalamos a `c-lightning` manualmente, precisaremos iniciá-la: ``` $ nohup lightningd --testnet & ``` @@ -151,7 +151,7 @@ $ sudo systemctl enable lightningd.service $ sudo systemctl start lightningd.service ``` -### Habilitando as conexões remotas +### Habilitando Conexões Remotas Se tivermos algum tipo de firewall, precisaremos abrir a porta 9735 para permitir que outros nodes da Lightning interajam conosco. @@ -160,9 +160,9 @@ Se usarmos o `ufw` do Bitcoin Standup, podemos fazer da seguinte maneira: $ sudo ufw allow 9735 ``` -## Verificando o nosso node +## Verificando o Nosso Node -Podemos verificar se o nosso node Lightning está pronto para funcionar comparando a saída de `bitcoin-cli getblockcount` com o resultado de do `blockheight` do `lightning-cli getinfo`. +Podemos verificar se o nosso node Lightning está pronto para funcionar comparando a saída de `bitcoin-cli getblockcount` com o resultado de `blockheight` do `lightning-cli getinfo`. ``` $ bitcoin-cli -testnet getblockcount @@ -220,14 +220,14 @@ Se o nosso node Lightning não estiver atualizado, receberemos uma mensagem como ``` "warning_lightningd_sync": "Still loading latest blocks from bitcoind." ``` -Se tentarmos executar em uma blockchain prunada em que o node Bitcoin não estava atualizado quando iniciamos o node Lightning, receberemos as mensagens de erro em nosso log, parecidas como esta: +Se tentarmos executar em uma blockchain prunada cujo node Bitcoin não estava atualizado quando iniciamos o node Lightning, receberemos mensagens de erro em nosso log parecidas com esta: ``` bitcoin-cli -testnet getblock 0000000000000559febee77ab6e0be1b8d0bef0f971c7a4bee9785393ecef451 0 exited with status 1 ``` -## Criando aliases +## Criando Aliases -Sugerimos a criação de alguns aliases para facilitar o uso do c-lightning. +Sugerimos a criação de alguns aliases (apelidos de comandos) para facilitar o uso da c-lightning. Podemos fazer isso colocando-os em nosso arquivo `.bash_profile`. ``` @@ -238,37 +238,37 @@ alias lnd="lightningd" alias lninfo='lightning-cli getinfo' EOF ``` -Depois de inserir esses alias, podemos executar o comando `source~/.bash_profile` para inseri-los ou apenas efetuar logout e login novamente. +Depois de inserir esses aliases, podemos executar o comando `source ~/.bash_profile` para inseri-los, ou apenas efetuar logout e login novamente. -Podemos observar que esses alias incluem atalhos para executar o `lightning-cli`, para executar o `lightningd` e para ir para o diretório c-lightning. Esses alias têm como objetivo principal tornar nossa vida mais fácil. Sugerimos criar outros apelidos para facilitar o uso de comandos frequentes (e dos argumentos) e para minimizar erros. Os aliases desse tipo podem ser ainda mais úteis se tivermos uma configuração complexa onde regularmente executamos comandos associados a Mainnet, com Testnet, _e_ com a Regtest, conforme explicado mais adiante. +Podemos observar que esses aliases incluem atalhos para executar o `lightning-cli`, para executar o `lightningd` e para ir para o diretório c-lightning. Esses aliases têm como objetivo principal tornar nossa vida mais fácil. Sugerimos criar outros apelidos para facilitar o uso de comandos frequentes (e seus argumentos) e para minimizar erros. Os aliases desse tipo podem ser ainda mais úteis se tivermos uma configuração complexa onde regularmente executamos comandos associados a Mainnet, com Testnet _e_ com a Regtest, conforme explicado mais adiante. Dito isso, o uso desses aliases _neste_ livro pode acidentalmente obscurecer as lições principais que estão sendo ensinadas sobre a c-lightning, portanto, continuaremos a mostrar os comandos completos. Podemos ajustá-los para nosso próprio uso conforme apropriado. -## Opcional: Modificando nossos tipos de servidor +## Opcional: Modificando Nossos Tipos de Servidor -> :link: **TESTNET vs MAINNET:** Ao configurar nosso node, escolhemos criá-lo como um node Mainnet, Testnet ou Regtest. Embora este documento presuma uma configuração no Testenet, vale a pena entender como podemos acessar e usar os outros tipos de configuração, mesmo todos estando na mesma máquina! Mas, se formos um usuário iniciante, podemos pular esta parte, pois não é necessário para uma configuração básica. +> :link: **TESTNET vs MAINNET:** Ao configurar nosso node, escolhemos criá-lo como um node Mainnet, Testnet ou Regtest. Embora este documento presuma uma configuração no Testenet, vale a pena entender como podemos acessar e usar os outros tipos de configuração, mesmo todos estando na mesma máquina! Mas, se você for um usuário iniciante, pode pular esta parte, pois não é necessária para uma configuração básica. -Quando o lightningd é inicializado, geralmente ele lê um arquivo de configuração cuja localização depende da rede que estamos usando (O padrão é: `~/.lightning/testnet/config`). Isso pode ser alterado com os sinalizadores `–conf` e `–lightning-dir`. +Quando o lightningd é inicializado, geralmente ele lê um arquivo de configuração cuja localização depende da rede que estamos usando (o padrão é `~/.lightning/testnet/config`). Isso pode ser alterado com os sinalizadores `–conf` e `–lightning-dir`. ``` ~/.lightning/testnet$ ls -la config -rw-rw-r-- 1 user user 267 jul 12 17:08 config ``` -Também existe um arquivo de configuração geral (O padrão é: `~/.lightning/config`). Se desejarmos executar vários tipos diferentes de nodes simultaneamente. Devemos deixar o sinalizador testnet (ou regtest) fora deste arquivo de configuração. Devemos então escolher se estamos usando a mainnet, a testnet ou a regtest toda vez que executarmos o `lightningd` ou o `lightning-cli`. +Também existe um arquivo de configuração geral (o padrão é `~/.lightning/config`). Se desejarmos executar vários tipos diferentes de nodes simultaneamente, devemos deixar o sinalizador testnet (ou regtest) fora deste arquivo de configuração. Devemos então escolher se estamos usando a mainnet, a testnet ou a regtest toda vez que executarmos o `lightningd` ou o `lightning-cli`. -Nossa configuração pode não ter nenhum arquivo de configuração. O c-lightning será executado com uma boa configuração padrão, sem eles. +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 do c-lightning +## Resumo: Verificando a Configuração da c-lightning -Antes de começar a brincar com o 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. +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 [§18.2: Conhecendo a configuração do c-lightning](18_2_Knowing_Your_lightning_Setup.md). +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). -## Variante: Instalando no Ubuntu ppa +## Variante: Instalando do Ubuntu ppa -Se estivermos usando uma versão do Ubuntu diferente do Debian, podemos instalar o c-lightning usando [Ubuntu ppa](https://launchpad.net/~lightningnetwork/+archive/ubuntu/ppa): +Se estivermos usando uma versão do Ubuntu diferente do Debian, podemos instalar a c-lightning usando [Ubuntu ppa](https://launchpad.net/~lightningnetwork/+archive/ubuntu/ppa): ``` $ sudo apt-get install -y software-properties-common @@ -276,9 +276,9 @@ $ sudo add-apt-repository -u ppa:lightningnetwork/ppa $ sudo apt-get install lightningd ``` -## Variante: Instale binários pré-compilados +## Variante: Instalando Binários Pré-Compilados -Outro método para instalar a Lightning é usar os binários pré-compilados no [repositório Github](https://github.com/ElementsProject/lightning/releases). Vamos escolher o tarball mais recente, como `clightning-v0.9.1-Ubuntu-20.04.tar.xz`. +Outro método para instalar a Lightning é usar os binários pré-compilados no [repositório Github](https://github.com/ElementsProject/lightning/releases). Vamos escolher o arquivo mais recente, como `clightning-v0.9.1-Ubuntu-20.04.tar.xz`. Depois de baixá-lo, precisaremos ir para o diretório raiz e descompactá-lo: ``` From 1b36e74550e3ed2203304b59ff441aede7c21b66 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 16:55:38 -0300 Subject: [PATCH 6/8] Review 19_2 --- pt/19_2_Knowing_Your_lightning_Setup.md | 26 ++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/pt/19_2_Knowing_Your_lightning_Setup.md b/pt/19_2_Knowing_Your_lightning_Setup.md index edb617c..18c2aa0 100644 --- a/pt/19_2_Knowing_Your_lightning_Setup.md +++ b/pt/19_2_Knowing_Your_lightning_Setup.md @@ -1,29 +1,29 @@ -# 18.2: Conhecendo a configuração do c-lightning +# 19.2: Conhecendo a 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. -Antes de começar a acessar a Lightning Network, devemos compreender melhor nossa configuração. +Antes de começar a acessar a Lightning Network, devemos compreender melhor a nossa configuração. -## Conhecendo o diretório da c-lightning +## Conhecendo o Diretório da c-lightning -Ao usar o c-lightning, tudo será mantindo dentro do diretório `~/.lightning`. +Ao usar a c-lightning, tudo será mantindo dentro do diretório `~/.lightning`. O diretório principal contém apenas os diretórios para as redes configuradas, neste caso da Testnet: ``` $ ls ~/.lightning testnet ``` -O diretório `~/.lightning/testnet` irá então conter a essência de nossa configuração: +O diretório `~/.lightning/testnet` irá então conter a essência da nossa configuração: ``` $ ls ~/.lightning/testnet3 config gossip_store hsm_secret lightningd.sqlite3 lightningd.sqlite3-journal lightning-rpc ``` -> :link: **TESTNET vs MAINNET:** Se estivermos usando a Mainnet, então _tudo_ será colocado no diretório principal `~/.lightning/bitcoin`. Essas várias configurações _empilham-se_ elegantemente, então se estivermos usando a Mainnet, Testnet e Regtest, descobriremos que `~/.lightning/bitcoin` contém os arquivos de configuração e os dados de mainnet, o diretório `~/.lightning/testnet` contém os dados da Testnet, e o diretório `~/.lightning/regtest` contém os dados Regtest. +> :link: **TESTNET vs MAINNET:** Se estivermos usando a Mainnet, então _tudo_ será colocado no diretório principal `~/.lightning/bitcoin`. Essas várias configurações _empilham-se_ elegantemente, então se estivermos usando a Mainnet, Testnet e Regtest, descobriremos que `~/.lightning/bitcoin` contém os arquivos de configuração e os dados da Mainnet, o diretório `~/.lightning/testnet` contém os dados da Testnet, e o diretório `~/.lightning/regtest` contém os dados Regtest. -## Conhecendo os comandos lightning-cli +## Conhecendo os Comandos lightning-cli -A maior parte do nosso trabalho inicial será feito com o comando `lightning-cli`, que oferece uma interface fácil para a `lightningd`, assim como o `bitcoin-cli`. +A maior parte do nosso trabalho inicial será feito com o comando `lightning-cli`, que oferece uma interface fácil para o `lightningd`, assim como o `bitcoin-cli`. Já vimos que o comando `help` nos dará uma lista de outros comandos: @@ -228,7 +228,7 @@ dev-rescan-outputs run `lightning-cli help ` for more information on a specific command ``` -## Conhecendo as informações de Lightning +## Conhecendo Informações da Lightning Uma variedade de comandos `lightning-cli` podem fornecer informações adicionais sobre nosso node Lightning. Os mais comuns são: ``` @@ -329,12 +329,12 @@ c$ lightning-cli --testnet listconfigs } ``` -## Resumo: Conhecendo a configuração do c-lightning +## Resumo: Conhecendo a 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 nossa configuração e funcionamento da Lightning Network. +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 precisaremos de suporte para configurar um, podemos ler o [Adendo: Acessando um segundo node Lightning](18_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 [Adendo: Acessando um segundo node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). -Caso contrário, vamos continuar "Compreendendo sua configuração do Lightning" na seção [§18.3: Criando um canal na Lightning](18_3_Setting_Up_a_Channel.md). \ No newline at end of file +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). \ No newline at end of file From e54c2dafa3cbb3cbc3d3dcd23a750c41f34fa225 Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 17:13:57 -0300 Subject: [PATCH 7/8] Review 19_2__Interlude --- pt/19_2_Knowing_Your_lightning_Setup.md | 2 +- ...rlude_Accessing_a_Second_Lightning_Node.md | 72 +++++++++---------- 2 files changed, 37 insertions(+), 37 deletions(-) diff --git a/pt/19_2_Knowing_Your_lightning_Setup.md b/pt/19_2_Knowing_Your_lightning_Setup.md index 18c2aa0..044cf8c 100644 --- a/pt/19_2_Knowing_Your_lightning_Setup.md +++ b/pt/19_2_Knowing_Your_lightning_Setup.md @@ -335,6 +335,6 @@ O diretório `~/.lightning` contém todos os arquivos, enquanto o comando `light ## 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 [Adendo: 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). \ No newline at end of file diff --git a/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md b/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md index cccd6ea..33f330d 100644 --- a/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md +++ b/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md @@ -1,16 +1,16 @@ -# Adendo: Acessando um segundo node Lightning +# Adendo: 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. +> :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. -Quando estávamos brincando com o Bitcoin, estávamos acessando uma rede existente, e isso torna tudo relativamente fácil para se trabalhar. Apenas ligávamos o `bitcoind` e estávamos imediatamente interagindo com a rede. Agora, é assim que a Lightning funciona: É fundamentalmente uma rede ponto a ponto, construída a partir das conexões entre dois nodes individuais. Em outras palavras, para interagir com a Lightning Network, precisaremos primeiro encontrar um node ao qual podemos nos conectar. +Quando estávamos brincando com o Bitcoin, estávamos acessando uma rede existente, e isso torna tudo relativamente fácil para se trabalhar. Apenas ligávamos o `bitcoind` e estávamos imediatamente interagindo com a rede. Agora, a Lightning funciona da seguinte maneira: é fundamentalmente uma rede ponto a ponto, construída a partir das conexões entre dois nodes individuais. Em outras palavras, para interagir com a Lightning Network, precisaremos primeiro encontrar um node ao qual podemos nos conectar. -Existem quatro maneiras de fazermos isso, as três primeiras são possíveis para a nossa primeira conexão: +Existem quatro maneiras de fazermos isso (das quais as três primeiras são possíveis para a nossa primeira conexão): -## Pedindo informações sobre um node +## Pedindo Informações Sobre um Node Se outra pessoa já tiver um node da Lightning Network na rede que escolhemos, podemos pedir o ID dele. -Se estiverem executando o c-lightning, eles só precisam usar o comando `getinfo`: +Se estiverem executando a c-lightning, eles só precisam usar o comando `getinfo`: ``` $ lightning-cli getinfo lightning-cli: WARNING: default network changing in 2020: please set network=testnet in config! @@ -48,23 +48,23 @@ lightning-cli: WARNING: default network changing in 2020: please set network=tes "lightning-dir": "/home/standup/.lightning/testnet" } ``` -Eles podem então poderão nos dizer o `ID` (`03240a4878a9a64aea6c3921a434e573845267b86e89ab19003b0c910a86d17687`). Eles também precisarão informar o endereço IP (`74.207.240.32`) e porta (`9735`). +Eles poderão então nos dizer o `ID` deles (`03240a4878a9a64aea6c3921a434e573845267b86e89ab19003b0c910a86d17687`). Eles também precisarão informar o endereço IP (`74.207.240.32`) e porta (`9735`). -## Criando um novo node c-lightning +## Criando um Novo Node c-lightning -No entanto, para fins de teste, provavelmente iremos desejar ter um segundo node sob nosso próprio controle. A maneira mais fácil de fazer isso é criar um segundo node c-lightning em uma nova máquina, usando Bitcoin Standup, de acordo com a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) ou compilando-o manualmente, de acordo com a seção [§18.1](18_1_Verifying_Your_Lightning_Setup .md). +No entanto, para fins de teste, provavelmente iremos desejar ter um segundo node sob nosso próprio controle. A maneira mais fácil de fazer isso é criar um segundo node c-lightning em uma nova máquina, usando Bitcoin Standup, de acordo com a seção [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) ou compilando-o manualmente, de acordo com a seção [§19.1](19_1_Verifying_Your_Lightning_Setup.md). Depois de ter nosso node em execução, podemos executar o `getinfo` para recuperar nossas informações, como mostrado acima. -## Criando um novo node LND +## Criando um Novo Node LND -No entanto, para nossos exemplos no próximo capítulo, vamos criar um node LND. Isso nos permitirá demonstrar um pouco da profundidade do ecossistema Lightning, mostrando como comandos semelhantes funcionam nas duas plataformas diferentes. +No entanto, para os exemplos do próximo capítulo, vamos criar um node LND. Isso nos permitirá demonstrar um pouco da profundidade do ecossistema Lightning, mostrando como comandos semelhantes funcionam nas duas plataformas diferentes. Uma maneira de criar um node LND é executar os scripts Bitcoin Standup novamente em uma nova máquina, mas desta vez escolher a LND, de acordo com a seção [§2.1](2_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md). Outra forma é compilar o LND a partir do código-fonte em uma máquina em que já estejamos executando um node Bitcoin, como falaremos abaixo. -### Compilando o código-fonte LND +### Compilando o Código-Fonte do LND Primeiro, precisaremos baixar e instalar o Go: ``` @@ -72,9 +72,9 @@ $ wget --progress=bar:force https://dl.google.com/go/"go1.14.4"."linux"-"amd64". $ /bin/tar xzf ~standup/"go1.14.4"."linux"-"amd64".tar.gz -C ~standup $ sudo mv ~standup/go /usr/local ``` -Depois, precisamos nos certificar de que a versão Go é a mais atualizada (atualmente é a `go1.14.4`), e a plataforma e arquitetura são adequadas para nossa máquina. O item acima funcionará para o Debian. +Depois, precisamos nos certificar de que a versão Go é a mais atualizada (atualmente é a `go1.14.4`), e que a plataforma e arquitetura são adequadas para nossa máquina. O item acima funcionará para o Debian. -Vamos atulizar o caminho: +Vamos atualizar nosso PATH: ``` $ export GOPATH=~standup/gocode $ export PATH="$PATH":/usr/local/go/bin:"$GOPATH"/bin @@ -89,7 +89,7 @@ Também precisaremos do `git` e do `make`: $ sudo apt-get install git $ sudo apt-get install build-essential ``` -Agora estamos pronto para recuperar o LND. Certifique-se de obter a versão atual (no momento, é a `v0.11.0-beta.rc4`). +Agora estamos prontos para recuperar o LND. Certifique-se de obter a versão atual (no momento, é a `v0.11.0-beta.rc4`). ``` $ go get -d github.com/lightningnetwork/lnd ``` @@ -107,21 +107,21 @@ Devemos alterá-la para os diretórios globais: $ sudo cp $GOPATH/bin/lnd $GOPATH/bin/lncli /usr/bin ``` -### Criando um arquivo de configuração LND +### Criando um Arquivo de Configuração do LND -Ao contrário do c-lightning, precisaremos criar um arquivo de configuração padrão para o LND. +Ao contrário da c-lightning, precisaremos criar um arquivo de configuração padrão para o LND. -No entanto, primeiro, iremos precisar habilitar o ZMQ em nosso Bitcoind, se ainda não o fizemos na seção [§15.3](15_3_Receiving_Bitcoind_Notifications_with_C.md). +No entanto, primeiro, iremos precisar habilitar o ZMQ em nosso Bitcoind, se ainda não o fizemos na seção [§16.3](16_3_Receiving_Bitcoind_Notifications_with_C.md). -Isso requer adicionar o seguinte ao nosso arquivo `~/.bitcoin/bitcoin.conf` se ainda não estiver lá: +Isso requer adicionar o seguinte ao nosso arquivo `~/.bitcoin/bitcoin.conf`, se ainda não estiver lá: ``` zmqpubrawblock=tcp://127.0.0.1:28332 zmqpubrawtx=tcp://127.0.0.1:28333 ``` -Se estivermos usando um arquivo de configuração Bitcoin do Standup ou algum outro `conf` especializado, precisamos nos certificar de colocar nossos novos comandos na seção correta. Idealmente, devemos chegar perto do topo do arquivo, caso contrário, na seção `[test]` (assumindo, como de costume, que estamos testando na testnet). +Se estivermos usando um arquivo de configuração Bitcoin do Standup ou algum outro `conf` especializado, precisamos nos certificar de colocar nossos novos comandos na seção correta. Idealmente, devemos chegar perto do topo do arquivo, caso contrário, na seção `[test]` (assumindo, como de costume, que estamos usando a testnet). -Devemos então, reiniciar o bitcoin (ou apenas reiniciar nossa máquina). Podemos testar se está tudo funcionando da seguinte maneira: +Devemos então reiniciar o Bitcoin (ou apenas reiniciar nossa máquina). Podemos testar se está tudo funcionando da seguinte maneira: ``` $ bitcoin-cli getzmqnotifications [ @@ -139,7 +139,7 @@ $ bitcoin-cli getzmqnotifications ``` Agora estamos prontos para criar um arquivo de configuração. -Primeiro, precisamos recuperar nosso rpcuser e rpcpassword. Esta é uma maneira automatizada de fazer isso: +Primeiro, precisamos recuperar nosso rpcuser e rpcpassword. A seguinte é uma maneira automatizada de fazer isso: ``` $ BITCOINRPC_USER=$(cat ~standup/.bitcoin/bitcoin.conf | grep rpcuser | awk -F = '{print $2}') $ BITCOINRPC_PASS=$(cat ~standup/.bitcoin/bitcoin.conf | grep rpcpassword | awk -F = '{print $2}') @@ -171,7 +171,7 @@ bitcoind.zmqpubrawtx=tcp://127.0.0.1:28333 EOF ``` -### Criando um serviço LND +### Criando um Serviço LND Finalmente, podemos criar um serviço LND para executar automaticamente o `lnd`: ``` @@ -203,22 +203,22 @@ RestartSec=60 WantedBy=multi-user.target EOF ``` -Em seguida, precisaremos instalar isso e iniciar as coisas: +Em seguida, precisaremos instalar aquilo e iniciar as coisas: ``` $ sudo cp ~/lnd.service /etc/systemd/system $ sudo systemctl enable lnd $ sudo systemctl start lnd ``` -É esperado que a primeira vez demore um tempo para a inicialização. +(É esperado que a primeira vez leve um certo tempo.) -### Habilitando as conexões remotas +### Habilitando Conexões Remotas -Assim como com o c-lightning, precisaremos tornar o LND acessível a outros nodes. Veja como fazer isso se usarmos o `ufw`, de acordo com as configurações do Bitcoin Standup: +Assim como na c-lightning, precisaremos tornar o LND acessível a outros nodes. Veja como fazer isso se usarmos o `ufw`, de acordo com as configurações do Bitcoin Standup: ``` $ sudo ufw allow 9735 ``` -### Criando uma carteira +### Criando uma Carteira Na primeira vez que executamos o LND, devemos criar uma carteira: ``` @@ -292,11 +292,11 @@ $ lncli --network=testnet getinfo } } ``` -O ID deste node é `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`. Embora este comando não mostre o endereço IP e a porta, eles devem ser o endereço IP da nossa máquina e a porta `9735`. +O ID deste node é `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`. Embora este comando não nos mostre o endereço IP e a porta, eles devem ser o endereço IP da nossa máquina e a porta `9735`. -## Ouvindo a Lightning +## Escute a Fofoca -Se já estivermos conectados à Lightning Network, nosso node já deve estar "fofocando" com seus pares, também já pode ser capaz de encontrar informações sobre os pares automaticamente, por meio do comando `listpeers`: +Se já estivéssemos conectados à Lightning Network, e nosso node já estivesse "fofocando" com seus pares, também poderíamos ser capazes de encontrar informações sobre os pares automaticamente, por meio do comando `listpeers`: ``` c$ lightning-cli --network=testnet listpeers { @@ -313,14 +313,14 @@ c$ lightning-cli --network=testnet listpeers ] } ``` -No entanto, esse definitivamente não será o caso da nossa primeira interação com a Lightning Network. +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: Adendo: 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, usando c-lightning ou (como faremos em nossos exemplos) usando a LND. +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, o c-lightning permanecerá o coração 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 19](19_0_Understanding_Your_Lightning_Setup.md). -Vamos continuar "Compreendendo a configuração da Lightning" na seção [§18.3: Criando um canal na Lightning](18_3_Setting_Up_a_Channel.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). From b804f5147b545b3b1c66f0d124005031fb92a0ea Mon Sep 17 00:00:00 2001 From: namcios Date: Wed, 25 Aug 2021 17:43:27 -0300 Subject: [PATCH 8/8] Review 19_3 --- pt/19_3_Setting_Up_a_Channel.md | 40 ++++++++++++++++----------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/pt/19_3_Setting_Up_a_Channel.md b/pt/19_3_Setting_Up_a_Channel.md index b193b06..386c43e 100644 --- a/pt/19_3_Setting_Up_a_Channel.md +++ b/pt/19_3_Setting_Up_a_Channel.md @@ -1,30 +1,30 @@ -# 18.3: Criando um canal na Lightning +# 19.3: Criando um Canal na Lightning > :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. -Agora que entendemos o básico da configuração da Lightning e, com sorte, já criamos ou recebemos informações sobre um segundo node Lightning. Estamos prontos para criar nosso primeiro canal na Lightning Network. Claro, precisaremos entender o que é e como é criado usando o c-lightning. +Agora que entendemos o básico da configuração da Lightning e, com sorte, já criamos ou recebemos informações sobre um segundo node Lightning, estamos prontos para criar nosso primeiro canal na Lightning Network. Claro, precisaremos entender o que ele é e como é criado usando a c-lightning. -> :book: ***O que é um canal Lightning?*** De maneira simples, um canal Lightning é um tubo de dinheiro que permite transferências rápidas, baratas e privadas sem enviar transações para a blockchain. Mais tecnicamente, um canal é uma transação de Bitcoin em cadeia com várias assinaturas 2 de 2 que estabelece um relacionamento financeiro sem confiança entre duas pessoas ou dois agentes. Uma certa quantia de dinheiro é depositada no canal, quando então se mantém um banco de dados local com saldo em bitcoins para ambas as partes, mantendo o registro de qual é o saldo de cada parte. Os dois usuários podem então trocar bitcoins por meio do canal Lightning sem nunca escrever na blockchain do Bitcoin. Somente quando desejam fechar o canal, eles liquidam os bitcoins na blockchain, com base no saldo final das moedas. +> :book: ***O que é um canal Lightning?*** De maneira simples, um canal Lightning é um tubo de dinheiro que permite transferências rápidas, baratas e privadas sem enviar transações para a blockchain. Mais tecnicamente, um canal é uma transação multisig 2-de-2 no Bitcoin que estabelece um relacionamento financeiro sem confiança entre duas pessoas ou dois agentes. Uma certa quantia de dinheiro é depositada no canal, quando então se mantém um banco de dados local com saldo em bitcoins para ambas as partes, mantendo o registro de qual é o saldo de cada parte. Os dois usuários podem então trocar bitcoins por meio do canal Lightning sem nunca escrever na blockchain do Bitcoin. Somente quando desejam fechar o canal é que eles dividem os bitcoins na blockchain, com base na divisão final das moedas para cada um. > :book: ***Como os canais Lightning criam uma rede Lightning?*** Embora um canal Lightning só permita o pagamento entre dois usuários, os canais podem ser conectados para formar uma rede que permite pagamentos entre membros que não têm um canal direto entre eles. Isso cria uma rede entre várias pessoas, construída a partir de conexões em pares. -Nesta seção, continuaremos usando nossa configuração c-lightning como nosso node principal. +Nesta seção, continuaremos usando nossa configuraçãa c-lightning como nosso node principal. -## Criando um canal +## Criando um Canal A criação de um canal Lightning requer as seguintes etapas: * Financiar nossa carteira c-lightning com alguns satoshis; -* Conectar-se a um nó remoto como um par; +* Conectar-se a um node remoto como um par; * Abrir um canal. -### Financiando nossa carteira c-lightning +### Financiando Nossa Carteira c-lightning Para mover fundos para um canal Lightning, primeiro é necessário financiar nossa carteira c-lightning. -> :book: ***O que é uma carteira c-lightning?*** A implementação padrão a c-lightning vem com uma carteira Bitcoin integrada que permite enviar e receber transações bitcoin na blockchain. Esta carteira será usada para criar novos canais. +> :book: ***O que é uma carteira c-lightning?*** A implementação padrão da c-lightning vem com uma carteira Bitcoin integrada que permite enviar e receber transações de bitcoin na blockchain. Esta carteira será usada para criar novos canais. -A primeira coisa que precisamos fazer é enviar alguns satoshis para nossa carteira c-lightning. Podemos criar um novo endereço usando o comando `lightning-cli newaddr`. Isso gera um novo endereço que pode ser subsequentemente usado para financiar canais gerenciados pelo node c-lightning. Podemos especificar o tipo de endereço desejado. Se não for especificado, o endereço gerado será um bech32. +A primeira coisa que precisamos fazer é enviar alguns satoshis para nossa carteira c-lightning. Podemos criar um novo endereço usando o comando `lightning-cli newaddr`. Isto gera um novo endereço que pode ser subsequentemente usado para financiar canais gerenciados pelo node c-lightning. Podemos especificar o tipo de endereço desejado; se não for especificado, o endereço gerado será um bech32. ``` $ lightning-cli --testnet newaddr @@ -37,7 +37,7 @@ Podemos então enviar fundos para este endereço usando `bitcoin-cli sendtoaddre Esta transação é chamada de [transação de financiamento](https://github.com/lightningnetwork/lightning-rfc/blob/master/03-transactions.md#funding-transaction-output) e precisa ser confirmada antes que os fundos possam ser utilizados. -> :book: ***O que é uma transação de financiamento?*** Uma transação de financiamento é uma transação de Bitcoin que coloca dinheiro em um canal Lightning. Pode ser de financiamento único (por um participante) ou de financiamento duplo (por ambos). A partir daí, as transações da Lightning tratam de realocar a propriedade da transação de financiamento, mas só se ajustam na blockchain quando o canal é fechado. +> :book: ***O que é uma transação de financiamento?*** Uma transação de financiamento é uma transação de bitcoin que coloca dinheiro em um canal Lightning. Pode ser de financiamento único (por um participante) ou de financiamento duplo (por ambos). A partir daí, as transações da Lightning tratam de realocar a propriedade da transação de financiamento, mas só se ajustam na blockchain quando o canal é fechado. Para verificar nosso saldo local, devemos usar o comando `lightning-cli listfunds`: @@ -76,11 +76,11 @@ Observe que o valor está listado em satoshis ou microsatoshis, não em Bitcoin! Agora que financiamos nossa carteira c-lightning, precisaremos de informações sobre um node remoto para começar a criar o processo do canal. -### Conectando a um node Remoto +### Conectando a um Node Remoto A próxima coisa que precisaremos fazer é conectar nosso node a um par. Isso é feito com o comando `lightning-cli connect`. Lembre-se que se quisermos mais informações sobre este comando, devemos digitar `lightning-cli help connect`. -Para conectar nosso nodes a um par remoto, precisaremos do nosso id, que representa a chave pública do node de destino. Por conveniência, o `ID` pode ter a forma `id@host` ou `id@host:port`. Podemos ter recuperado isso com o `lightning-cli getinfo` (no c-lightning) ou `lncli --network=testnet getinfo` (no LND) conforme discutido no [adendo anterior](18_2__Interlude_Accessing_a_Second_Lightning_Node.md). +Para conectar nosso node a um par remoto, precisaremos do nosso id, que representa a chave pública do node de destino. Por conveniência, o `ID` pode ter a forma `id@host` ou `id@host:port`. Podemos já ter pego esta informação com o `lightning-cli getinfo` (na c-lightning) ou `lncli --network=testnet getinfo` (no LND) conforme discutido no [adendo anterior](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). Selecionamos o node LND, `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`, que está localizado no endereço IP `45.33.35.151`, ao qual vamos nos conectar a partir de nosso node c-lightning: @@ -92,15 +92,15 @@ $ lightning-cli --network=testnet connect 032a7572dc013b6382cde391d79f292ced2730 } ``` -### Abrindo um canal +### Abrindo um Canal -O comando fundchannel do RPC abre um canal de pagamento com um par ao comprometer uma transação de financiamento para o blockchain. Devemos usar o comando `lightning-cli fundchannel` para fazer isso, com os seguintes parâmetros: +O comando fundchannel do RPC abre um canal de pagamento com um par ao comprometer uma transação de financiamento para a blockchain. Devemos usar o comando `lightning-cli fundchannel` para fazer isso, com os seguintes parâmetros: * **id** é o retorno do id do peer da conexão; * **amount** é o valor em satoshis retirado da carteira interna para financiar o canal. O valor não pode ser inferior ao limite mínimo, atualmente definido como 546 satoshis, nem superior a 16.777.215 satoshis (a menos que grandes canais tenham sido negociados com o par). * **feerate** é o feerate opcional usado para a transação de abertura e como feerate inicial para transações de confirmação e HTLC. * **announce** é um sinalizador opcional que aciona o anúncio deste canal ou não. O padrão é verdadeiro. Se desejarmos criar um canal privado, precisamos definí-lo como falso. -* **minconf** especifica o número mínimo de confirmações que devem ter saídas usadas no processo de abertura de canal. O padrão é 1. +* **minconf** especifica o número mínimo de confirmações que saídas usadas no processo de abertura do canal devem ter. O padrão é 1. * **utxos** especifica os utxos a serem usados ​​para financiar o canal, como uma matriz de “txid:vout”. Agora podemos abrir o canal assim: @@ -158,11 +158,11 @@ c$ lightning-cli --testnet listfunds } ``` -Embora este novo canal com 100.000 satoshis não esteja confirmado, nosso estado será `CHANNELD_AWAITING_LOCKIN`. Observe que a alteração não confirmada de satoshis `99847` também está aparecendo como uma nova transação na carteira. Depois que todas as seis confirmações forem concluídas, o canal mudará para o estado `CHANNELD_NORMAL`, que será o estado permanente. Nesse momento, um `short_channel_id` também aparecerá, como: +Embora este novo canal com 100.000 satoshis não esteja confirmado, nosso estado será `CHANNELD_AWAITING_LOCKIN`. Observe que a alteração não confirmada de `99847` satoshis também está aparecendo como uma nova transação na carteira. Depois que todas as seis confirmações forem concluídas, o canal mudará para o estado `CHANNELD_NORMAL`, que será o estado permanente. Nesse momento, um `short_channel_id` também aparecerá, por exemplo: ``` "short_channel_id": "1862856x29x0", ``` -Esses valores indicam onde a transação de financiamento pode ser encontrada na blockchain. Ele aparece na forma `bloco x txid x vout`. +Esses valores indicam onde a transação de financiamento pode ser encontrada na blockchain. Ela aparece na forma `bloco x txid x vout`. Neste caso, `1862856x29x0` significa: @@ -174,12 +174,12 @@ Podemos precisar usar este `short_channel_id` para certos comandos na Lightning. Esta transação de financiamento também pode ser encontrada onchain pelo TXID [66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d] (https://mempool.space/pt/testnet/tx/66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d) -> :book: ***O que é a capacidade do canal?*** Em um canal Lightning, ambos os lados do canal possuem uma parte da capacidade. O valor do 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. +> :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 na 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 19: Usando Lightning](19_0_Using_Lightning.md). \ No newline at end of file +Você está pronto para passar para o [Capítulo 20: Usando Lightning](20_0_Using_Lightning.md). \ No newline at end of file